@cortexkit/opencode-magic-context 0.49.18 → 0.49.20

package/src/shared/model-resolution.test.ts

@@ -118,12 +118,22 @@ describe("model-resolution", () => {
         // Inheritance is deliberately absent because a fallback model may not support the
         // qualifier selected for the primary model.
         expect(resolveHistorianModel(config, "opencode")).toEqual({
-            primary: { model: "open/primary", qualifier: "primary-only" },
-            fallbacks: [{ model: "open/fallback" }],
+            primary: {
+                model: "open/primary",
+                qualifier: "primary-only",
+                sourceConfigKey: "historian.opencode.model",
+            },
+            fallbacks: [
+                { model: "open/fallback", sourceConfigKey: "historian.opencode.fallback_models" },
+            ],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/primary", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback" }],
+            primary: {
+                model: "pi/primary",
+                qualifier: "high",
+                sourceConfigKey: "historian.pi.model",
+            },
+            fallbacks: [{ model: "pi/fallback", sourceConfigKey: "historian.pi.fallback_models" }],
         });
     });
 
@@ -143,12 +153,32 @@ describe("model-resolution", () => {
         };
 
         expect(resolveHistorianModel(config, "opencode")).toEqual({
-            primary: { model: "open/code", qualifier: "oc-primary" },
-            fallbacks: [{ model: "open/fallback", qualifier: "oc-fallback" }],
+            primary: {
+                model: "open/code",
+                qualifier: "oc-primary",
+                sourceConfigKey: "historian.opencode.model",
+            },
+            fallbacks: [
+                {
+                    model: "open/fallback",
+                    qualifier: "oc-fallback",
+                    sourceConfigKey: "historian.opencode.fallback_models",
+                },
+            ],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/model", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback", qualifier: "max" }],
+            primary: {
+                model: "pi/model",
+                qualifier: "high",
+                sourceConfigKey: "historian.pi.model",
+            },
+            fallbacks: [
+                {
+                    model: "pi/fallback",
+                    qualifier: "max",
+                    sourceConfigKey: "historian.pi.fallback_models",
+                },
+            ],
         });
     });
 
@@ -182,8 +212,18 @@ describe("model-resolution", () => {
         };
 
         expect(resolveHistorianModel(configured, "omp")).toEqual({
-            primary: { model: "omp/historian", qualifier: "auto" },
-            fallbacks: [{ model: "omp/historian-fallback", qualifier: "max" }],
+            primary: {
+                model: "omp/historian",
+                qualifier: "auto",
+                sourceConfigKey: "historian.omp.model",
+            },
+            fallbacks: [
+                {
+                    model: "omp/historian-fallback",
+                    qualifier: "max",
+                    sourceConfigKey: "historian.omp.fallback_models",
+                },
+            ],
         });
         expect(
             resolveDreamerTaskModel({ config: configured, harness: "omp", task: "verify" }),
@@ -197,6 +237,7 @@ describe("model-resolution", () => {
         expect(resolveHistorianModel(piFallback, "omp")?.primary).toEqual({
             model: "pi/historian",
             qualifier: "high",
+            sourceConfigKey: "historian.pi.model",
         });
         expect(
             resolveDreamerTaskModel({ config: piFallback, harness: "omp", task: "verify" }),
@@ -245,8 +286,22 @@ describe("model-resolution", () => {
         };
 
         expect(resolveDreamerTaskModel({ config, harness: "opencode", task: "curate" })).toEqual({
-            primary: { model: "open/task", qualifier: "task-variant" },
-            fallbacks: [{ model: "open/bare" }, { model: "open/qualified", qualifier: "fb" }],
+            primary: {
+                model: "open/task",
+                qualifier: "task-variant",
+                sourceConfigKey: "dreamer.opencode.tasks.curate.model",
+            },
+            fallbacks: [
+                {
+                    model: "open/bare",
+                    sourceConfigKey: "dreamer.opencode.tasks.curate.fallback_models",
+                },
+                {
+                    model: "open/qualified",
+                    qualifier: "fb",
+                    sourceConfigKey: "dreamer.opencode.tasks.curate.fallback_models",
+                },
+            ],
             schedule: "0 4 * * *",
             timeoutMinutes: 12,
             promotionThreshold: 3,

package/src/shared/model-resolution.ts

@@ -5,6 +5,8 @@ export interface ResolvedModelEntry {
     model: string;
     /** OpenCode variant or Pi thinking level, selected for the active entry only. */
     qualifier?: string;
+    /** Config location that supplied this attempt, for accurate failure diagnostics. */
+    sourceConfigKey?: string;
 }
 
 export type ModelInput = string | ResolvedModelEntry;
@@ -35,6 +37,10 @@ function resolveHarnessBlock(
     return asRecord(selected);
 }
 
+function sourceHarness(container: ConfigRecord | undefined, harness: ModelHarness): ModelHarness {
+    return harness === "omp" && container?.omp == null ? "pi" : harness;
+}
+
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -116,14 +122,20 @@ export function resolveHistorianModel(
     const historian = asRecord(asRecord(config)?.historian);
     const block = resolveHarnessBlock(historian, harness);
     if (!block) return { fallbacks: [] };
+    const source = `historian.${sourceHarness(historian, harness)}`;
+    const primary = resolvePrimaryEntry({
+        entry: block.model,
+        defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+        harness,
+    });
+    const fallbacks = resolveFallbackEntries(block.fallback_models, harness);
 
     return {
-        primary: resolvePrimaryEntry({
-            entry: block.model,
-            defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
-            harness,
-        }),
-        fallbacks: resolveFallbackEntries(block.fallback_models, harness),
+        primary: primary ? { ...primary, sourceConfigKey: `${source}.model` } : undefined,
+        fallbacks: fallbacks.map((entry) => ({
+            ...entry,
+            sourceConfigKey: `${source}.fallback_models`,
+        })),
     };
 }
 
@@ -171,19 +183,34 @@ export function resolveDreamerTaskModel(args: {
         harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ??
         normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
     const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+    const taskHasFallbacks = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models");
     const primarySource = taskHasModel ? taskBlock?.model : harnessBlock.model;
-    const fallbackSource =
-        taskBlock !== undefined && hasOwn(taskBlock, "fallback_models")
-            ? taskBlock.fallback_models
-            : harnessBlock.fallback_models;
+    const fallbackSource = taskHasFallbacks
+        ? taskBlock?.fallback_models
+        : harnessBlock.fallback_models;
+    const source = `dreamer.${sourceHarness(dreamer, args.harness)}`;
+    const primary = resolvePrimaryEntry({
+        entry: primarySource,
+        defaultQualifier: taskQualifier ?? harnessQualifier,
+        harness: args.harness,
+    });
+    const fallbacks = resolveFallbackEntries(fallbackSource, args.harness);
 
     return {
-        primary: resolvePrimaryEntry({
-            entry: primarySource,
-            defaultQualifier: taskQualifier ?? harnessQualifier,
-            harness: args.harness,
-        }),
-        fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+        primary: primary
+            ? {
+                  ...primary,
+                  sourceConfigKey: taskHasModel
+                      ? `${source}.tasks.${args.task}.model`
+                      : `${source}.model`,
+              }
+            : undefined,
+        fallbacks: fallbacks.map((entry) => ({
+            ...entry,
+            sourceConfigKey: taskHasFallbacks
+                ? `${source}.tasks.${args.task}.fallback_models`
+                : `${source}.fallback_models`,
+        })),
         schedule: readString(schedulingTask?.schedule),
         timeoutMinutes:
             typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,

package/src/shared/model-suggestion-retry.test.ts

@@ -5,6 +5,8 @@ import { recordedGeminiQuotaMessages } from "../features/magic-context/dreamer/p
 import { HiddenAgentStepLimit } from "../v2/hooks/hidden-child";
 import {
     getPromptFailureDetail,
+    noteModelActivityMonitored,
+    noteModelOutputReceived,
     promptSyncWithModelSuggestionRetry,
     promptSyncWithValidatedOutputRetry,
 } from "./model-suggestion-retry";
@@ -833,3 +835,167 @@ test("timeout rejects an uncooperative carrier and aborts its child", async () =
         clearTimeout(timer);
     }
 });
+
+describe("first-output deadline", () => {
+    const primary = { providerID: "opencode", modelID: "free-model" };
+    type Behaviour = "silent" | "partial" | "answer" | "unmonitored";
+
+    /**
+     * A transport double that behaves per model. "silent" watches the child but the
+     * model never answers; "partial" streams something and then hangs; "unmonitored"
+     * hangs without ever reporting whether the model answered (the Pi and OpenCode 2
+     * carriers); "answer" completes at once.
+     */
+    function modelTransport(behaviours: Record<string, Behaviour>) {
+        const calls: Array<{ model: string; startedAt: number }> = [];
+        const transport = Object.assign(
+            async (request: PromptCall & { signal?: AbortSignal }) => {
+                const model = request.body.model
+                    ? `${request.body.model.providerID}/${request.body.model.modelID}`
+                    : "primary";
+                calls.push({ model, startedAt: Date.now() });
+                const behaviour = behaviours[model] ?? "answer";
+                if (behaviour === "answer") return;
+                if (behaviour === "silent") noteModelActivityMonitored(request.signal);
+                if (behaviour === "partial") noteModelOutputReceived(request.signal);
+                await new Promise<void>((_resolve, reject) =>
+                    request.signal?.addEventListener("abort", () => reject(new Error("aborted"))),
+                );
+            },
+            { childSessionId: "child-first-output" },
+        );
+        return { transport, calls };
+    }
+
+    async function run(
+        behaviours: Record<string, Behaviour>,
+        options: { timeoutMs: number; firstOutputTimeoutMs?: number; fallbackModels?: string[] },
+    ) {
+        const { transport, calls } = modelTransport(behaviours);
+        const startedAt = Date.now();
+        let caught: unknown;
+        let result: Awaited<ReturnType<typeof promptSyncWithValidatedOutputRetry>> | undefined;
+        try {
+            result = await promptSyncWithValidatedOutputRetry(
+                createClient(mock(async () => ({}))),
+                createArgs(primary),
+                {
+                    transport: transport as never,
+                    timeoutMs: options.timeoutMs,
+                    ...(options.firstOutputTimeoutMs !== undefined
+                        ? { firstOutputTimeoutMs: options.firstOutputTimeoutMs }
+                        : {}),
+                    fallbackModels: options.fallbackModels ?? ["anthropic/claude-sonnet-5-5"],
+                    fetchOutput: async () => "<classify></classify>",
+                    validateOutput: (output: string) => output,
+                },
+            );
+        } catch (error) {
+            caught = error;
+        }
+        return { result, caught, calls, elapsedMs: Date.now() - startedAt };
+    }
+
+    test("a primary that streams nothing by the deadline moves on to the fallback", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "silent" },
+            { timeoutMs: 2_000, firstOutputTimeoutMs: 40 },
+        );
+        expect(outcome.caught).toBeUndefined();
+        expect(outcome.result?.attempt.label).toBe("anthropic/claude-sonnet-5-5");
+        expect(outcome.calls.map((call) => call.model)).toEqual([
+            "opencode/free-model",
+            "anthropic/claude-sonnet-5-5",
+        ]);
+        // The silent primary was cut at its first-output deadline, not its timeout.
+        expect(outcome.elapsedMs).toBeLessThan(1_000);
+    });
+
+    test("the unvalidated chain also moves on from a silent primary", async () => {
+        const { transport, calls } = modelTransport({ "opencode/free-model": "silent" });
+        await promptSyncWithModelSuggestionRetry(
+            createClient(mock(async () => ({}))),
+            createArgs(primary),
+            {
+                transport: transport as never,
+                timeoutMs: 2_000,
+                firstOutputTimeoutMs: 40,
+                fallbackModels: ["anthropic/claude-sonnet-5-5"],
+            },
+        );
+        expect(calls.map((call) => call.model)).toEqual([
+            "opencode/free-model",
+            "anthropic/claude-sonnet-5-5",
+        ]);
+    });
+
+    test("a primary that produced output before timing out does not fall back", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "partial" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20 },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+        expect(getPromptFailureDetail(outcome.caught)?.failureClass).toBe("provider_timeout");
+    });
+
+    test("a silent primary's time comes out of the fallback's timeout", async () => {
+        // The fallback is the last model, so it gets no first-output cut of its own;
+        // its timeout is what the silent primary left of the overall 300 ms.
+        const outcome = await run(
+            { "opencode/free-model": "silent", "anthropic/claude-sonnet-5-5": "silent" },
+            { timeoutMs: 300, firstOutputTimeoutMs: 100 },
+        );
+        const message = (outcome.caught as Error).message;
+        const fallbackTimeoutMs = Number(/prompt timed out after (\d+)ms$/.exec(message)?.[1]);
+        expect(outcome.calls).toHaveLength(2);
+        expect(fallbackTimeoutMs).toBeLessThanOrEqual(200);
+        expect(fallbackTimeoutMs).toBeGreaterThan(100);
+        expect(outcome.elapsedMs).toBeLessThan(300 + 150);
+    });
+
+    test("the last model in the chain is never cut for silence", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "silent" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20, fallbackModels: [] },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a transport that cannot see model output keeps the plain timeout", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "unmonitored" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20 },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a caller without a first-output deadline keeps timeouts final", async () => {
+        // The historian passes no first-output deadline: a silent model still ends
+        // its chain at the timeout, exactly as before.
+        const outcome = await run({ "opencode/free-model": "silent" }, { timeoutMs: 120 });
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a caller without a first-output deadline still falls back on a provider failure", async () => {
+        const prompt = mock(async (args: PromptCall) => {
+            if (args.body.model?.providerID === "opencode")
+                throw new Error("429 Too Many Requests: quota exceeded");
+            return {};
+        });
+        const result = await promptSyncWithValidatedOutputRetry(
+            createClient(prompt),
+            createArgs(primary),
+            {
+                fallbackModels: ["anthropic/claude-sonnet-5-5"],
+                fetchOutput: async () => "summary",
+                validateOutput: (output: string) => output,
+            },
+        );
+        expect(result.attempt.label).toBe("anthropic/claude-sonnet-5-5");
+        expect(prompt).toHaveBeenCalledTimes(2);
+    });
+});