@cortexkit/opencode-magic-context 0.43.2 → 0.44.1

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

@@ -1,6 +1,8 @@
 import { describe, expect, mock, test } from "bun:test";
 
+import { HiddenAgentStepLimit } from "../v2/hooks/hidden-child";
 import {
+    getPromptFailureDetail,
     promptSyncWithModelSuggestionRetry,
     promptSyncWithValidatedOutputRetry,
 } from "./model-suggestion-retry";
@@ -158,6 +160,18 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         expect(prompt).toHaveBeenCalledTimes(0);
     });
 
+    test("pre-aborted lease signal carries its loss reason into the prompt error", async () => {
+        const controller = new AbortController();
+        controller.abort(new Error("lease_lost: taken by holder-b"));
+        const prompt = mock(async () => {});
+        await expect(
+            promptSyncWithModelSuggestionRetry(createClient(prompt), createArgs(), {
+                signal: controller.signal,
+            }),
+        ).rejects.toThrow("prompt aborted by external signal: lease_lost: taken by holder-b");
+        expect(prompt).not.toHaveBeenCalled();
+    });
+
     test("AbortError name short-circuits", async () => {
         const abortError = new Error("aborted by provider");
         abortError.name = "AbortError";
@@ -280,10 +294,10 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         const abort = mock(async () => ({}));
         const client = createClient(prompt as never, abort);
 
-        setTimeout(() => controller.abort(), 10);
+        setTimeout(() => controller.abort(new Error("lease_lost: taken by holder-b")), 10);
         await expect(
             promptSyncWithModelSuggestionRetry(client, createArgs(), { signal: controller.signal }),
-        ).rejects.toThrow(/aborted by external signal/);
+        ).rejects.toThrow("prompt aborted by external signal: lease_lost: taken by holder-b");
         expect(abort).toHaveBeenCalledTimes(1);
         expect((abort.mock.calls[0]?.[0] as { path: { id: string } }).path.id).toBe("ses-test");
     });
@@ -393,6 +407,28 @@ describe("promptSyncWithModelSuggestionRetry", () => {
 });
 
 describe("promptSyncWithValidatedOutputRetry", () => {
+    test("records a step cap as step_limit without a provider error", async () => {
+        const prompt = mock(async () => {
+            throw new HiddenAgentStepLimit("dreamer-retrospective", 40);
+        });
+        const client = createClient(prompt);
+        let caught: unknown;
+        try {
+            await promptSyncWithValidatedOutputRetry(client, createArgs(), {
+                fetchOutput: async () => "unused",
+                validateOutput: (output) => output,
+            });
+        } catch (error) {
+            caught = error;
+        }
+        expect(caught).toBeInstanceOf(HiddenAgentStepLimit);
+        expect(getPromptFailureDetail(caught)).toMatchObject({
+            failureClass: "step_limit",
+            providerError: null,
+        });
+        expect(prompt).toHaveBeenCalledTimes(1);
+    });
+
     test("surfaces a host-recorded assistant refusal even when the row has no text", async () => {
         const client = createClient(mock(async () => ({})));
         const refusal =
@@ -517,7 +553,7 @@ describe("promptSyncWithValidatedOutputRetry", () => {
         });
     });
 
-    test("all empty outputs surface the original validation failure", async () => {
+    test("all empty outputs surface the last validation failure and every attempted model", async () => {
         const prompt = mock(async () => ({}));
         const messages = mock(async () => "");
         const client = createClient(prompt, undefined, messages);
@@ -533,9 +569,84 @@ describe("promptSyncWithValidatedOutputRetry", () => {
                     return output.trim();
                 },
             }),
-        ).rejects.toThrow("empty output from primary");
+        ).rejects.toThrow(
+            /All models exhausted \(primary, anthropic\/claude-sonnet-4-6\): empty output from anthropic\/claude-sonnet-4-6/,
+        );
 
         expect(prompt).toHaveBeenCalledTimes(2);
         expect(messages).toHaveBeenCalledTimes(2);
     });
 });
+
+/**
+ * Bun's fetch rejects with this exact object when its default request timer
+ * fires on a plugin SDK request (the name is "TimeoutError", legacy code 23).
+ * The dreamer ledger shows it as `TimeoutError message="The operation timed out." code=23`.
+ */
+function hostFetchTimeout(): Error {
+    return new DOMException("The operation timed out.", "TimeoutError") as unknown as Error;
+}
+
+describe("host fetch TimeoutError is a timeout", () => {
+    test("validated retry stops the chain, aborts the child, and reports provider_timeout", async () => {
+        const prompt = mock(async () => {
+            throw hostFetchTimeout();
+        });
+        const abort = mock(async () => ({}));
+        const client = createClient(prompt, abort);
+
+        let caught: unknown;
+        try {
+            await promptSyncWithValidatedOutputRetry(client, createArgs(), {
+                fallbackModels: ["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"],
+                fetchOutput: async () => "unused",
+                validateOutput: (output: string) => output,
+            });
+        } catch (error) {
+            caught = error;
+        }
+
+        expect((caught as Error | undefined)?.name).toBe("TimeoutError");
+        // Another model would be sent into the same still-running child session and
+        // hit the same host timer, so the chain must stop at the first attempt.
+        expect(prompt).toHaveBeenCalledTimes(1);
+        expect(getPromptFailureDetail(caught)?.failureClass).toBe("provider_timeout");
+        // The host loop keeps running after the client-side timer fires unless the
+        // child is aborted explicitly.
+        expect(abort).toHaveBeenCalledTimes(1);
+        expect(abort.mock.calls[0]?.[0]).toEqual({ path: { id: "ses-test" } });
+    });
+
+    test("unvalidated retry stops the chain and aborts the child", async () => {
+        const prompt = mock(async () => {
+            throw hostFetchTimeout();
+        });
+        const abort = mock(async () => ({}));
+        const client = createClient(prompt, abort);
+
+        await expect(
+            promptSyncWithModelSuggestionRetry(client, createArgs(), {
+                fallbackModels: ["anthropic/claude-sonnet-4-6"],
+            }),
+        ).rejects.toThrow("The operation timed out.");
+
+        expect(prompt).toHaveBeenCalledTimes(1);
+        expect(abort).toHaveBeenCalledTimes(1);
+    });
+
+    test("an ordinary provider error still falls back and does not abort the child", async () => {
+        const prompt = mock(async () => {
+            if (prompt.mock.calls.length === 1) throw new Error("upstream 502");
+            return {};
+        });
+        const abort = mock(async () => ({}));
+        const client = createClient(prompt, abort);
+
+        await promptSyncWithModelSuggestionRetry(client, createArgs(), {
+            fallbackModels: ["anthropic/claude-sonnet-4-6"],
+        });
+
+        expect(prompt).toHaveBeenCalledTimes(2);
+        expect(abort).not.toHaveBeenCalled();
+    });
+});

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

@@ -1,6 +1,7 @@
 import type { createOpencodeClient } from "@opencode-ai/sdk";
 
 import { detectOverflow } from "../features/magic-context/overflow-detection";
+import { HiddenAgentStepLimit } from "../v2/hooks/hidden-child";
 import {
     extractLatestAssistantFailure,
     extractLatestAssistantText,
@@ -113,6 +114,7 @@ export interface ValidatedPromptRetryResult<TOutput, TValidated> {
 export type PromptFailureClass =
     | "provider_timeout"
     | "provider_error"
+    | "step_limit"
     | "empty_completion"
     | "no_models"
     | "child_aborted"
@@ -131,6 +133,29 @@ export interface PromptFailureDetail {
 
 const promptFailureDetails = new WeakMap<object, PromptFailureDetail>();
 
+/**
+ * True for a request timer that fired inside the host client rather than ours.
+ * Bun's fetch rejects with a DOMException named "TimeoutError" ("The operation
+ * timed out.", legacy code 23) when its default per-request timer expires, and
+ * `AbortSignal.timeout` produces the same shape. Some OpenCode 1 builds hand
+ * plugins an SDK client whose fetch keeps Bun's default timer (about five to six
+ * minutes), so a synchronous `session.prompt` that stays open for a whole agent
+ * loop fails this way while the host keeps running the child session.
+ */
+export function isHostTimeoutError(error: unknown): boolean {
+    return (
+        error !== null &&
+        typeof error === "object" &&
+        (error as { name?: unknown }).name === "TimeoutError"
+    );
+}
+
+/** Our own slice expiry (see `promptWithTimeout`) or a host request timer. */
+export function isPromptTimeoutError(error: unknown): boolean {
+    if (isHostTimeoutError(error)) return true;
+    return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
+}
+
 export function getPromptFailureDetail(error: unknown): PromptFailureDetail | null {
     return error !== null && typeof error === "object"
         ? (promptFailureDetails.get(error) ?? null)
@@ -204,6 +229,11 @@ export function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null
     };
 }
 
+function externalAbortMessage(signal: AbortSignal): string {
+    const reason = signal.reason;
+    return `prompt aborted by external signal${reason instanceof Error && /^lease_(?:lost|expired):/.test(reason.message) ? `: ${reason.message}` : ""}`;
+}
+
 async function promptWithTimeout(
     client: Client,
     args: PromptArgs,
@@ -218,7 +248,7 @@ async function promptWithTimeout(
     // and avoids one wasted upstream `client.session.prompt` round-trip
     // before `isNonRetryable` catches the cancellation at the chain loop.
     if (signal?.aborted) {
-        throw new Error("prompt aborted by external signal");
+        throw new Error(externalAbortMessage(signal));
     }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -242,7 +272,7 @@ async function promptWithTimeout(
             if (!transport || transport.childSessionId) {
                 await abortChildRun(client, transport?.childSessionId ?? args.path.id);
             }
-            throw new Error("prompt aborted by external signal");
+            throw new Error(externalAbortMessage(signal));
         }
         if (controller.signal.aborted) {
             // Our timeout fired. Same problem: abort the server-side run loop, not
@@ -253,6 +283,15 @@ async function promptWithTimeout(
             }
             throw new Error(`prompt timed out after ${timeoutMs}ms`);
         }
+        if (isHostTimeoutError(error)) {
+            // The host client's own request timer fired. Only our side of the
+            // request ended: the child's run loop is still going on the server and
+            // would keep calling the model, so stop it the same way as above. The
+            // original error is kept so the ledger still shows which timer fired.
+            if (!transport || transport.childSessionId) {
+                await abortChildRun(client, transport?.childSessionId ?? args.path.id);
+            }
+        }
         throw error;
     } finally {
         clearTimeout(timeout);
@@ -266,7 +305,7 @@ async function promptWithTimeout(
         }
         throw new Error(
             signal?.aborted
-                ? "prompt aborted by external signal"
+                ? externalAbortMessage(signal)
                 : `prompt timed out after ${timeoutMs}ms`,
         );
     }
@@ -312,7 +351,7 @@ async function abortChildRun(client: Client, sessionId: string): Promise<void> {
  * different model.
  */
 function isNonRetryable(error: unknown, externalSignal?: AbortSignal): boolean {
-    if (externalSignal?.aborted) return true;
+    if (externalSignal?.aborted || error instanceof HiddenAgentStepLimit) return true;
 
     if (error instanceof Error) {
         if (error.name === "AbortError") return true;
@@ -321,6 +360,9 @@ function isNonRetryable(error: unknown, externalSignal?: AbortSignal): boolean {
         if (error.message === "prompt aborted by external signal") return true;
         if (/^prompt timed out after \d+ms$/.test(error.message)) return true;
     }
+    // A host request timer is a timeout too. Retrying would send the next model
+    // into the same child session, where it meets the same timer.
+    if (isHostTimeoutError(error)) return true;
 
     if (detectOverflow(error).isOverflow) return true;
 
@@ -350,10 +392,13 @@ function classifyPromptFailure(
     externalSignal?: AbortSignal,
 ): PromptFailureClass {
     const message = extractMessage(error);
+    if (error instanceof HiddenAgentStepLimit) return "step_limit";
     if (externalSignal?.aborted || message === "prompt aborted by external signal") {
         return "child_aborted";
     }
-    if (/^prompt timed out after \d+ms$/.test(message)) return "provider_timeout";
+    if (/^prompt timed out after \d+ms$/.test(message) || isHostTimeoutError(error)) {
+        return "provider_timeout";
+    }
     if (phase === "validation") {
         if (/returned no (?:assistant )?output|no assistant output/i.test(message)) {
             return "empty_completion";
@@ -764,11 +809,11 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     log(
         `[${callContext}] all models exhausted; tried: ${failedAttempts.map((failure) => failure.attempt.label).join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
     );
-    throwWithPromptFailure(
-        firstError ?? lastError ?? new Error("All fallback models failed validation"),
-        failedAttempts,
-        args,
-        timeoutMs,
-        options.transport,
-    );
+    const cause = lastError ?? firstError;
+    const exhausted =
+        cause instanceof Error
+            ? cause
+            : new Error(String(cause ?? "All fallback models failed validation"));
+    exhausted.message = `All models exhausted (${failedAttempts.map((failure) => failure.attempt.label).join(", ")}): ${exhausted.message}`;
+    throwWithPromptFailure(exhausted, failedAttempts, args, timeoutMs, options.transport);
 }

package/src/shared/prompt-async-transport.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import { promptSyncWithValidatedOutputRetry } from "./model-suggestion-retry";
+import {
+    createPromptAsyncTransport,
+    promptAsyncAndWaitForIdle,
+    supportsPromptAsync,
+} from "./prompt-async-transport";
+
+type Message = {
+    info: {
+        id: string;
+        role: string;
+        time: { created: number; completed?: number };
+        finish?: string;
+        error?: unknown;
+    };
+    parts: Array<{ type: string; text?: string }>;
+};
+
+/**
+ * A host double for one child session. `plan` describes what each status poll
+ * after the prompt sees: a busy tick, or the moment the run settles with a
+ * final assistant message.
+ */
+function asyncHost(options: {
+    plan: Array<"busy" | "idle-pending" | "settle">;
+    initialMessages?: Message[];
+    answer?: string;
+}) {
+    const messages: Message[] = [...(options.initialMessages ?? [])];
+    let polls = 0;
+    let prompted = false;
+    const promptAsync = mock(async (_request: unknown) => {
+        prompted = true;
+        messages.push({
+            info: { id: `msg_user_${messages.length}`, role: "user", time: { created: 1 } },
+            parts: [{ type: "text", text: "go" }],
+        });
+        return { data: undefined };
+    });
+    const prompt = mock(async () => ({}));
+    const abort = mock(async () => ({ data: true }));
+    const status = mock(async () => {
+        if (!prompted) return { data: {} };
+        const step = options.plan[Math.min(polls, options.plan.length - 1)];
+        polls += 1;
+        if (step === "busy") {
+            // An intermediate tool-call step is already complete while the loop runs.
+            messages.push({
+                info: {
+                    id: `msg_step_${messages.length}`,
+                    role: "assistant",
+                    time: { created: 2, completed: 3 },
+                    finish: "tool-calls",
+                },
+                parts: [{ type: "tool" }],
+            });
+            return { data: { "ses-child": { type: "busy" } } };
+        }
+        if (step === "settle" && messages.at(-1)?.info.finish !== "stop") {
+            messages.push({
+                info: {
+                    id: `msg_final_${messages.length}`,
+                    role: "assistant",
+                    time: { created: 4, completed: 5 },
+                    finish: "stop",
+                },
+                parts: [{ type: "text", text: options.answer ?? "<done/>" }],
+            });
+        }
+        return { data: {} };
+    });
+    const list = mock(async () => ({ data: [...messages] }));
+    return {
+        client: { session: { promptAsync, prompt, abort, status, messages: list } } as never,
+        promptAsync,
+        prompt,
+        abort,
+        status,
+        list,
+        polls: () => polls,
+    };
+}
+
+function request(signal?: AbortSignal) {
+    return {
+        path: { id: "ses-child" },
+        query: { directory: "/repo" },
+        body: { parts: [{ type: "text", text: "go" }] },
+        ...(signal ? { signal } : {}),
+    };
+}
+
+describe("supportsPromptAsync", () => {
+    test("requires both prompt_async and session status", () => {
+        expect(supportsPromptAsync(asyncHost({ plan: ["settle"] }).client)).toBe(true);
+        expect(supportsPromptAsync({ session: { prompt: async () => ({}) } } as never)).toBe(false);
+        expect(supportsPromptAsync(undefined)).toBe(false);
+        expect(createPromptAsyncTransport({ session: {} } as never, "ses-child")).toBeUndefined();
+    });
+});
+
+describe("promptAsyncAndWaitForIdle", () => {
+    test("returns only after the child is idle with a settled final assistant message", async () => {
+        const host = asyncHost({ plan: ["busy", "busy", "busy", "settle"] });
+
+        await promptAsyncAndWaitForIdle(host.client, request(), { pollIntervalMs: 1 });
+
+        expect(host.promptAsync).toHaveBeenCalledTimes(1);
+        expect(host.prompt).not.toHaveBeenCalled();
+        // Completed tool-call steps during busy polls must not end the wait early.
+        expect(host.polls()).toBe(4);
+        expect(host.promptAsync.mock.calls[0]?.[0]).toMatchObject({
+            path: { id: "ses-child" },
+            query: { directory: "/repo" },
+        });
+    });
+
+    test("keeps waiting through an idle gap before the run starts", async () => {
+        const host = asyncHost({ plan: ["idle-pending", "idle-pending", "busy", "settle"] });
+
+        await promptAsyncAndWaitForIdle(host.client, request(), {
+            pollIntervalMs: 1,
+            startGraceMs: 60_000,
+        });
+
+        expect(host.polls()).toBe(4);
+    });
+
+    test("ignores an assistant answer left by an earlier attempt in the same child", async () => {
+        const earlier: Message = {
+            info: {
+                id: "msg_old",
+                role: "assistant",
+                time: { created: 0, completed: 0 },
+                finish: "stop",
+            },
+            parts: [{ type: "text", text: "stale" }],
+        };
+        const host = asyncHost({
+            plan: ["idle-pending", "busy", "settle"],
+            initialMessages: [earlier],
+        });
+
+        await promptAsyncAndWaitForIdle(host.client, request(), {
+            pollIntervalMs: 1,
+            startGraceMs: 60_000,
+        });
+
+        expect(host.polls()).toBe(3);
+    });
+
+    test("fails when no run starts within the start grace", async () => {
+        const host = asyncHost({ plan: ["idle-pending"] });
+        host.promptAsync.mockImplementation(async () => ({ data: undefined }));
+
+        await expect(
+            promptAsyncAndWaitForIdle(host.client, request(), {
+                pollIntervalMs: 1,
+                startGraceMs: 20,
+            }),
+        ).rejects.toThrow("did not start a run");
+    });
+
+    test("surfaces a rejected prompt_async request", async () => {
+        const host = asyncHost({ plan: ["settle"] });
+        host.promptAsync.mockImplementation(async () => ({
+            data: undefined,
+            error: { name: "BadRequest", data: { message: "unknown agent" } },
+        }));
+
+        await expect(
+            promptAsyncAndWaitForIdle(host.client, request(), { pollIntervalMs: 1 }),
+        ).rejects.toThrow("prompt_async was rejected");
+    });
+
+    test("stops waiting as soon as the caller's signal aborts", async () => {
+        const host = asyncHost({ plan: ["busy"] });
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), 20);
+
+        await expect(
+            promptAsyncAndWaitForIdle(host.client, request(controller.signal), {
+                pollIntervalMs: 5,
+            }),
+        ).rejects.toBeDefined();
+    });
+});
+
+describe("prompt_async transport under the retry chain", () => {
+    test("our slice stays the only timer and aborts the busy child when it expires", async () => {
+        const host = asyncHost({ plan: ["busy"] });
+        const transport = createPromptAsyncTransport(host.client, "ses-child", {
+            pollIntervalMs: 5,
+        });
+        expect(transport).toBeDefined();
+
+        let caught: unknown;
+        try {
+            await promptSyncWithValidatedOutputRetry(host.client, request(), {
+                transport,
+                timeoutMs: 60,
+                fallbackModels: ["anthropic/claude-sonnet-4-6"],
+                fetchOutput: async () => "unused",
+                validateOutput: (output: string) => output,
+            });
+        } catch (error) {
+            caught = error;
+        }
+
+        expect((caught as Error).message).toBe("prompt timed out after 60ms");
+        expect(host.promptAsync).toHaveBeenCalledTimes(1);
+        expect(host.prompt).not.toHaveBeenCalled();
+        expect(host.abort).toHaveBeenCalledWith({ path: { id: "ses-child" } });
+    });
+});