Give auto-chain fallback models the call options they would have received as primary

src/ipc/utils/fallback_ai_model.test.ts

@@ -0,0 +1,238 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3StreamPart,
+} from "@ai-sdk/provider";
+import { describe, expect, it } from "vitest";
+
+import { createFallback } from "./fallback_ai_model";
+
+/**
+ * The regression under test: call options (temperature) are resolved for the
+ * PRIMARY model before the request; forwarding them verbatim to a fallback of
+ * a different provider produced a hard 400 (Anthropic rejects an explicit
+ * temperature for thinking models), turning a recoverable stream blip into a
+ * fatal error. On any non-primary model the fallback wrapper must drop
+ * `temperature` and let the provider default apply.
+ */
+
+function textStream(): ReadableStream<LanguageModelV3StreamPart> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue({ type: "stream-start", warnings: [] } as any);
+      controller.enqueue({ type: "text-delta", id: "1", delta: "ok" } as any);
+      controller.close();
+    },
+  });
+}
+
+function fakeModel(params: {
+  modelId: string;
+  behavior: "succeed" | "reject-retryable";
+  seen: LanguageModelV3CallOptions[];
+}): LanguageModelV3 {
+  return {
+    specificationVersion: "v3",
+    provider: "fake",
+    modelId: params.modelId,
+    supportedUrls: {},
+    async doGenerate() {
+      throw new Error("not used");
+    },
+    async doStream(options: LanguageModelV3CallOptions) {
+      params.seen.push(options);
+      if (params.behavior === "reject-retryable") {
+        // Matches RETRYABLE_ERROR_PATTERNS ("service unavailable").
+        throw new Error("service unavailable");
+      }
+      return { stream: textStream() };
+    },
+  } as unknown as LanguageModelV3;
+}
+
+async function drain(stream: ReadableStream<LanguageModelV3StreamPart>) {
+  const reader = stream.getReader();
+  while (!(await reader.read()).done) {
+    // consume
+  }
+}
+
+describe("fallback model call options", () => {
+  it("passes temperature to the primary model untouched", async () => {
+    const seen: LanguageModelV3CallOptions[] = [];
+    const model = createFallback({
+      models: [fakeModel({ modelId: "primary", behavior: "succeed", seen })],
+    }) as unknown as LanguageModelV3;
+
+    const result = await model.doStream({
+      prompt: [],
+      temperature: 1,
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(result.stream);
+
+    expect(seen).toHaveLength(1);
+    expect(seen[0].temperature).toBe(1);
+  });
+
+  it("drops temperature when failing over to a non-primary model", async () => {
+    const primarySeen: LanguageModelV3CallOptions[] = [];
+    const fallbackSeen: LanguageModelV3CallOptions[] = [];
+    const model = createFallback({
+      models: [
+        fakeModel({
+          modelId: "primary",
+          behavior: "reject-retryable",
+          seen: primarySeen,
+        }),
+        fakeModel({
+          modelId: "fallback",
+          behavior: "succeed",
+          seen: fallbackSeen,
+        }),
+      ],
+    }) as unknown as LanguageModelV3;
+
+    const result = await model.doStream({
+      prompt: [],
+      temperature: 1,
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(result.stream);
+
+    // Primary was tried with the caller's options...
+    expect(primarySeen.length).toBeGreaterThanOrEqual(1);
+    expect(primarySeen[0].temperature).toBe(1);
+    // ...the fallback's provider default must apply instead.
+    expect(fallbackSeen).toHaveLength(1);
+    expect(fallbackSeen[0].temperature).toBeUndefined();
+    // Everything else survives the strip.
+    expect(fallbackSeen[0].prompt).toEqual([]);
+  });
+
+  it("applies a fallback model's own call options as if it were primary", async () => {
+    const primarySeen: LanguageModelV3CallOptions[] = [];
+    const fallbackSeen: LanguageModelV3CallOptions[] = [];
+    const model = createFallback({
+      models: [
+        fakeModel({
+          modelId: "primary",
+          behavior: "reject-retryable",
+          seen: primarySeen,
+        }),
+        fakeModel({
+          modelId: "fallback",
+          behavior: "succeed",
+          seen: fallbackSeen,
+        }),
+      ],
+      modelCallOptions: [
+        undefined, // primary always gets the caller's options
+        {
+          temperature: 1,
+          maxOutputTokens: 32_000,
+          providerOptions: {
+            anthropic: { thinking: { type: "adaptive" } },
+          },
+        },
+      ],
+    }) as unknown as LanguageModelV3;
+
+    const result = await model.doStream({
+      prompt: [],
+      temperature: 0.2,
+      maxOutputTokens: 128_000,
+      providerOptions: {
+        "dyad-engine": { dyadRequestId: "req-1" },
+        openai: { reasoningEffort: "medium" },
+      },
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(result.stream);
+
+    expect(fallbackSeen).toHaveLength(1);
+    const seen = fallbackSeen[0];
+    // The model-derived subset is the fallback's own...
+    expect(seen.temperature).toBe(1);
+    expect(seen.maxOutputTokens).toBe(32_000);
+    expect((seen.providerOptions as any).anthropic).toEqual({
+      thinking: { type: "adaptive" },
+    });
+    // ...request-scoped options pass through untouched.
+    expect((seen.providerOptions as any)["dyad-engine"]).toEqual({
+      dyadRequestId: "req-1",
+    });
+    expect(seen.prompt).toEqual([]);
+  });
+
+  it("unsets temperature when the fallback's own options have none", async () => {
+    const fallbackSeen: LanguageModelV3CallOptions[] = [];
+    const model = createFallback({
+      models: [
+        fakeModel({
+          modelId: "primary",
+          behavior: "reject-retryable",
+          seen: [],
+        }),
+        fakeModel({
+          modelId: "fallback",
+          behavior: "succeed",
+          seen: fallbackSeen,
+        }),
+      ],
+      modelCallOptions: [
+        undefined,
+        // catalog had no temperature/cap for this model: undefined means
+        // "unset", never "inherit the primary's"
+        { providerOptions: { anthropic: { thinking: { type: "adaptive" } } } },
+      ],
+    }) as unknown as LanguageModelV3;
+
+    const result = await model.doStream({
+      prompt: [],
+      temperature: 0.2,
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(result.stream);
+
+    expect(fallbackSeen).toHaveLength(1);
+    expect(fallbackSeen[0].temperature).toBeUndefined();
+  });
+
+  it("drops temperature on a sticky non-primary index without a same-request failover", async () => {
+    // After a failover the index stays on the fallback for modelResetInterval;
+    // a FRESH request's first call then already targets the fallback while its
+    // options were still computed for the primary selection.
+    const primarySeen: LanguageModelV3CallOptions[] = [];
+    const fallbackSeen: LanguageModelV3CallOptions[] = [];
+    const model = createFallback({
+      models: [
+        fakeModel({
+          modelId: "primary",
+          behavior: "reject-retryable",
+          seen: primarySeen,
+        }),
+        fakeModel({
+          modelId: "fallback",
+          behavior: "succeed",
+          seen: fallbackSeen,
+        }),
+      ],
+    }) as unknown as LanguageModelV3;
+
+    // First request fails over primary -> fallback.
+    const first = await model.doStream({
+      prompt: [],
+      temperature: 1,
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(first.stream);
+
+    // Second request starts on the sticky fallback index.
+    const second = await model.doStream({
+      prompt: [],
+      temperature: 1,
+    } as unknown as LanguageModelV3CallOptions);
+    await drain(second.stream);
+
+    expect(fallbackSeen).toHaveLength(2);
+    expect(fallbackSeen[1].temperature).toBeUndefined();
+    // The primary saw only the first request's attempt.
+    expect(primarySeen.every((o) => o.temperature === 1)).toBe(true);
+  });
+});

src/ipc/utils/fallback_ai_model.ts

@@ -10,8 +10,29 @@ import { DyadError, DyadErrorKind } from "@/errors/dyad_error";
 const logger = log.scope("fallback_model");
 
 // Types
+
+/**
+ * The model-derived subset of call options — what a model should receive
+ * because of what it is, as opposed to what the request is. Everything else
+ * (prompt, tools, headers, request metadata) passes through unchanged.
+ */
+export interface FallbackModelCallOptions {
+  temperature?: number;
+  maxOutputTokens?: number;
+  providerOptions?: Record<string, unknown>;
+}
+
 interface FallbackSettings {
   models: Array<LanguageModel>;
+  /**
+   * Per-model call-option overrides, parallel to `models`. The caller's
+   * options are computed for the PRIMARY selection and encode that model's
+   * constraints; an entry here expresses what the model at the same index
+   * would have received had it been selected as primary. Models without an
+   * entry get the conservative default on failover: `temperature` stripped
+   * (valid on every provider), everything else forwarded.
+   */
+  modelCallOptions?: Array<FallbackModelCallOptions | undefined>;
 }
 
 interface RetryState {
@@ -177,6 +198,59 @@ class FallbackModel implements LanguageModelV3 {
     return model;
   }
 
+  /**
+   * Call options are resolved for the PRIMARY model before the request is made
+   * (e.g. `getTemperature(settings.selectedModel)`), so they encode that
+   * model's constraints, not the fallback's. Forwarding them verbatim across a
+   * provider switch produces hard 400s — observed: a gpt-5.6 stream error
+   * failed over to an Anthropic thinking model, which rejected the forwarded
+   * `temperature` ("`temperature` may only be set to 1 when thinking is
+   * enabled"), converting a recoverable blip into a fatal stream error.
+   *
+   * When calling any model other than the primary, apply that model's
+   * `modelCallOptions` entry — the options it would have received as the
+   * primary selection, computed at chain-build time where catalog access
+   * exists. Without an entry, fall back to stripping `temperature` (an absent
+   * temperature is valid on every provider). Applies to sticky-index first
+   * attempts too — after a failover, `currentModelIndex` stays non-zero for
+   * `modelResetInterval`, so a fresh request's first call can already target a
+   * fallback model.
+   */
+  private optionsForCurrentModel(
+    options: LanguageModelV3CallOptions,
+  ): LanguageModelV3CallOptions {
+    if (this.currentModelIndex === 0) return options;
+    const overrides = this.settings.modelCallOptions?.[this.currentModelIndex];
+    if (!overrides) {
+      // No per-model knowledge: strip temperature (an absent temperature is
+      // valid on every provider) and forward the rest.
+      if (options.temperature === undefined) return options;
+      const { temperature: _dropped, ...rest } = options;
+      return rest;
+    }
+    // Rebuild the model-derived subset as if this model had been primary.
+    // temperature is REPLACED (undefined in the overrides means "unset", not
+    // "keep the primary's"); maxOutputTokens falls back to the caller's when
+    // the catalog had none; providerOptions merge at the provider-family key —
+    // request-scoped keys (e.g. dyad-engine) pass through, the fallback's
+    // family entry is added, and a stale foreign family key is inert because
+    // providers only read their own key.
+    const { temperature: _replaced, ...rest } = options;
+    return {
+      ...rest,
+      ...(overrides.temperature !== undefined
+        ? { temperature: overrides.temperature }
+        : {}),
+      ...(overrides.maxOutputTokens !== undefined
+        ? { maxOutputTokens: overrides.maxOutputTokens }
+        : {}),
+      providerOptions: {
+        ...options.providerOptions,
+        ...(overrides.providerOptions ?? {}),
+      } as LanguageModelV3CallOptions["providerOptions"],
+    };
+  }
+
   private checkAndResetModel(): void {
     // Only reset if we're not currently in a retry cycle
     if (this.isRetrying) return;
@@ -269,7 +343,9 @@ class FallbackModel implements LanguageModelV3 {
     this.checkAndResetModel();
 
     return this.retry(async (retryState) => {
-      const result = await this.getUnderlyingModel().doStream(options);
+      const result = await this.getUnderlyingModel().doStream(
+        this.optionsForCurrentModel(options),
+      );
 
       // Create a wrapped stream that handles errors gracefully
       const wrappedStream = this.createWrappedStream(
@@ -380,7 +456,7 @@ class FallbackModel implements LanguageModelV3 {
             try {
               const nextResult = await fallbackModel
                 .getUnderlyingModel()
-                .doStream(options);
+                .doStream(fallbackModel.optionsForCurrentModel(options));
               await processStream(nextResult.stream);
             } catch (nextError) {
               controller.error(nextError);

src/ipc/utils/get_model_client.test.ts

@@ -32,6 +32,11 @@ vi.mock("./model_effort", () => ({
 }));
 
 vi.mock("../shared/language_model_helpers", () => ({
+  // The auto chain now computes each fallback model's own call options
+  // (temperature/maxOutputTokens) via findLanguageModel -> getLanguageModels.
+  // An empty catalog means "no per-model data", which exercises the
+  // conservative path without inventing model entries these tests don't need.
+  getLanguageModels: vi.fn(async () => []),
   getLanguageModelProviders: vi.fn(async () => [
     {
       id: "auto",