fix(code-mode): return structured worker error codes

Kaspre · steipete · commit edab6531788f · 2026-05-22T10:36:18.000+01:00
diff --git a/src/agents/code-mode.test.ts b/src/agents/code-mode.test.ts
@@ -828,5 +828,68 @@ describe("Code Mode", () => {
     await expect(heartbeat).resolves.toBe("main-event-loop-alive");
     expect(details.status).toBe("failed");
     expect(String(details.error)).toContain("timeout exceeded");
+    expect(details.code).toBe("timeout");
+  });
+
+  it("classifies missing worker runtime as unavailable", async () => {
+    const config = resolveCodeModeConfig({ tools: { codeMode: true } } as never);
+    const missingWorkerUrl = new URL("./missing-code-mode.worker.js", import.meta.url);
+
+    const result = await __testing.runCodeModeWorker(
+      {
+        kind: "exec",
+        source: "return 1;",
+        config,
+        catalog: [],
+      },
+      500,
+      missingWorkerUrl,
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result).toMatchObject({
+      code: "runtime_unavailable",
+    });
+  });
+
+  it("classifies nonzero worker exits as unavailable", async () => {
+    const config = resolveCodeModeConfig({ tools: { codeMode: true } } as never);
+    const exitingWorkerUrl = new URL("data:text/javascript,process.exit(1)");
+
+    const result = await __testing.runCodeModeWorker(
+      {
+        kind: "exec",
+        source: "return 1;",
+        config,
+        catalog: [],
+      },
+      500,
+      exitingWorkerUrl,
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result).toMatchObject({
+      code: "runtime_unavailable",
+    });
+  });
+
+  it("does not classify guest interrupted errors as timeouts", async () => {
+    const config = resolveCodeModeConfig({ tools: { codeMode: true } } as never);
+
+    const result = await __testing.runCodeModeWorker(
+      {
+        kind: "exec",
+        source: 'throw new Error("interrupted");',
+        config,
+        catalog: [],
+      },
+      500,
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result).toMatchObject({
+      code: "internal_error",
+      error: "interrupted",
+    });
   });
 });
diff --git a/src/agents/code-mode.ts b/src/agents/code-mode.ts
@@ -101,6 +101,8 @@ type CodeModeRunState = {
 
 type CodeModeToolContext = ToolSearchToolContext;
 
+type CodeModeFailureCode = "invalid_input" | "runtime_unavailable" | "timeout" | "internal_error";
+
 type CodeModeWorkerResult =
   | {
       status: "completed";
@@ -116,7 +118,7 @@ type CodeModeWorkerResult =
   | {
       status: "failed";
       error: string;
-      code: "invalid_input" | "internal_error";
+      code: CodeModeFailureCode;
       output: unknown[];
     };
 
@@ -504,13 +506,31 @@ function codeModeWorkerUrl(): URL {
   return resolveCodeModeWorkerUrl(import.meta.url);
 }
 
+function failedCodeModeWorkerResult(
+  error: unknown,
+  code: CodeModeFailureCode,
+): Extract<CodeModeWorkerResult, { status: "failed" }> {
+  return {
+    status: "failed",
+    error: errorMessage(error),
+    code,
+    output: [],
+  };
+}
+
 async function runCodeModeWorker(
   workerData: unknown,
   timeoutMs: number,
+  workerUrl?: URL,
 ): Promise<CodeModeWorkerResult> {
-  const worker = new Worker(codeModeWorkerUrl(), {
-    workerData,
-  });
+  let worker: Worker;
+  try {
+    worker = new Worker(workerUrl ?? codeModeWorkerUrl(), {
+      workerData,
+    });
+  } catch (error) {
+    return failedCodeModeWorkerResult(error, "runtime_unavailable");
+  }
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     return await new Promise<CodeModeWorkerResult>((resolve) => {
@@ -527,7 +547,7 @@ async function runCodeModeWorker(
         finish({
           status: "failed",
           error: "code mode worker timeout exceeded",
-          code: "internal_error",
+          code: "timeout",
           output: [],
         });
       }, timeoutMs);
@@ -545,21 +565,16 @@ async function runCodeModeWorker(
         );
       });
       worker.once("error", (error) => {
-        finish({
-          status: "failed",
-          error: errorMessage(error),
-          code: "internal_error",
-          output: [],
-        });
+        finish(failedCodeModeWorkerResult(error, "runtime_unavailable"));
       });
       worker.once("exit", (code) => {
         if (code !== 0) {
-          finish({
-            status: "failed",
-            error: `code mode worker exited with code ${code}`,
-            code: "internal_error",
-            output: [],
-          });
+          finish(
+            failedCodeModeWorkerResult(
+              new Error(`code mode worker exited with code ${code}`),
+              "runtime_unavailable",
+            ),
+          );
         }
       });
     });
@@ -949,6 +964,7 @@ export const testing = {
   activeRuns,
   resumingRunIds,
   codeModeWorkerUrl,
+  runCodeModeWorker,
   resolveCodeModeWorkerUrl,
   resolveCodeModeConfig,
   getTypescriptRuntimePromise: () => typescriptRuntimePromise,
diff --git a/src/agents/code-mode.worker.ts b/src/agents/code-mode.worker.ts
@@ -53,10 +53,38 @@ type CodeModeWorkerResult =
   | {
       status: "failed";
       error: string;
-      code: "invalid_input" | "internal_error";
+      code: "invalid_input" | "runtime_unavailable" | "timeout" | "internal_error";
       output: unknown[];
     };
 
+class CodeModeWorkerFailure extends Error {
+  readonly code: Extract<CodeModeWorkerResult, { status: "failed" }>["code"];
+
+  constructor(
+    code: Extract<CodeModeWorkerResult, { status: "failed" }>["code"],
+    message: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "CodeModeWorkerFailure";
+    this.code = code;
+  }
+}
+
+class CodeModeGuestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CodeModeGuestError";
+  }
+}
+
+function isQuickJsInterruptedError(error: unknown): boolean {
+  if (error instanceof CodeModeGuestError) {
+    return false;
+  }
+  return errorMessage(error) === "interrupted";
+}
+
 type VmRun = {
   vm: QuickJS;
   didTimeout: () => boolean;
@@ -329,7 +357,7 @@ async function readCompletedResult(vm: QuickJS, resultHandle: JSValueHandle): Pr
   const settled = await vm.resolvePromise(resultHandle);
   if ("error" in settled) {
     try {
-      throw new Error(errorMessage(vm.dump(settled.error)));
+      throw new CodeModeGuestError(errorMessage(vm.dump(settled.error)));
     } finally {
       settled.error.dispose();
     }
@@ -391,8 +419,8 @@ async function runExec(input: Extract<CodeModeWorkerInput, { kind: "exec" }>) {
       resultHandle.dispose();
     }
   } catch (error) {
-    if (didTimeout()) {
-      throw new Error("code mode timeout exceeded", { cause: error });
+    if (didTimeout() || isQuickJsInterruptedError(error)) {
+      throw new CodeModeWorkerFailure("timeout", "code mode timeout exceeded", { cause: error });
     }
     throw error;
   } finally {
@@ -448,8 +476,8 @@ async function runResume(input: Extract<CodeModeWorkerInput, { kind: "resume" }>
       resultHandle.dispose();
     }
   } catch (error) {
-    if (didTimeout()) {
-      throw new Error("code mode timeout exceeded", { cause: error });
+    if (didTimeout() || isQuickJsInterruptedError(error)) {
+      throw new CodeModeWorkerFailure("timeout", "code mode timeout exceeded", { cause: error });
     }
     throw error;
   } finally {
@@ -496,7 +524,7 @@ async function main(): Promise<CodeModeWorkerResult> {
     return {
       status: "failed",
       error: errorMessage(error),
-      code: "internal_error",
+      code: error instanceof CodeModeWorkerFailure ? error.code : "internal_error",
       output: [],
     };
   }
