computer: read callable state from the runtime, not tool options

The exec tool learned which backends were callable from a `callable`
flag on each backend description the caller passed to createAITools.
That duplicated a fact the Workspace already holds: it derives the
callable set from each backend's own `callable` flag at construction.
Declaring it a second time on the tool let the two drift.

Expose `isCallable(id)` on the runtime and have the tool ask it,
dropping `callable` from the backend description. The runtime answers
from the same set that guards its own structured-input check, so the
tool and the runtime can no longer disagree about which backends
accept input.

Author: aron-cf

packages/computer/src/runtime/runtime.ts

@@ -26,6 +26,14 @@ export class WorkspaceRuntime {
     this.#options = options;
   }
 
+  // Whether the named backend accepts a structured `input` value and
+  // returns a structured result. Consumers such as the exec tool ask
+  // this to know whether a backend is callable without the caller
+  // having to declare it a second time.
+  isCallable(id: string): boolean {
+    return this.#options.callableBackendIds.has(id);
+  }
+
   exec(source: string): Promise<WorkspaceRuntimeExecHandle<undefined>>;
   exec(
     source: string,
@@ -41,7 +49,7 @@ export class WorkspaceRuntime {
   ): Promise<WorkspaceRuntimeExecHandle<E>> {
     if (options.id !== undefined) assertExecutionId(options.id);
     const backend = this.#backend(options.backend);
-    if (options.input !== undefined && !this.#options.callableBackendIds.has(backend)) {
+    if (options.input !== undefined && !this.isCallable(backend)) {
       throw new Error(
         `Backend ${JSON.stringify(backend)} is not callable; it does not accept structured input.`,
       );

packages/computer/src/tools/ai.test.ts

@@ -552,14 +552,15 @@ describe("createAITools callable exec", () => {
             }),
           };
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
       workspace,
       shell: {
         defaultBackend: "js",
         backends: {
-          js: { description: "JavaScript module runtime", callable: true },
+          js: { description: "JavaScript module runtime" },
         },
       },
     });
@@ -597,13 +598,14 @@ describe("createAITools callable exec", () => {
             result: async () => ({ exitCode: 0, stdout: "ok", stderr: "" }),
           };
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
       workspace,
       shell: {
         defaultBackend: "js",
-        backends: { js: { description: "JavaScript module runtime", callable: true } },
+        backends: { js: { description: "JavaScript module runtime" } },
       },
     });
 
@@ -620,6 +622,7 @@ describe("createAITools callable exec", () => {
           called = true;
           return { result: async () => ({ exitCode: 0, stdout: "", stderr: "" }) };
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
@@ -628,7 +631,7 @@ describe("createAITools callable exec", () => {
         defaultBackend: "shell",
         backends: {
           shell: { description: "fast shell" },
-          js: { description: "JavaScript module runtime", callable: true },
+          js: { description: "JavaScript module runtime" },
         },
       },
     });
@@ -674,13 +677,14 @@ describe("createAITools callable exec", () => {
         async exec() {
           throw new Error("not used");
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
       workspace,
       shell: {
         defaultBackend: "js",
-        backends: { js: { description: "JavaScript module runtime", callable: true } },
+        backends: { js: { description: "JavaScript module runtime" } },
       },
     });
 
@@ -749,13 +753,14 @@ describe("createAITools exec streaming", () => {
             { name: "exit", value: 0 },
           ]);
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
       workspace,
       shell: {
         defaultBackend: "js",
-        backends: { js: { description: "JavaScript module runtime", callable: true } },
+        backends: { js: { description: "JavaScript module runtime" } },
       },
     });
 
@@ -784,13 +789,14 @@ describe("createAITools exec streaming", () => {
             { name: "exit", value: 0, result: { ok: true } },
           ]);
         },
+        isCallable: (id: string) => id === "js",
       },
     };
     const tools = createAITools({
       workspace,
       shell: {
         defaultBackend: "js",
-        backends: { js: { description: "JavaScript module runtime", callable: true } },
+        backends: { js: { description: "JavaScript module runtime" } },
       },
     });
 

packages/computer/src/tools/exec.ts

@@ -40,15 +40,16 @@ export interface ExecWorkspaceLike {
         input?: unknown;
       },
     ): Promise<ExecRuntimeHandle>;
+    // Whether a backend accepts a structured `input` value and returns
+    // a structured result. The tool asks this to know which backends
+    // are callable; the runtime derives it from each backend's
+    // `callable` flag. Omit when no backend is callable.
+    isCallable?(id: string): boolean;
   };
 }
 
 export interface ExecBackendDescription {
   description: string;
-  // Whether the backend accepts a structured `input` value and
-  // returns a structured `result` value. When false or omitted the
-  // tool rejects `input` for this backend before touching the wire.
-  callable?: boolean;
 }
 
 export interface ExecToolOptions {
@@ -97,9 +98,8 @@ export function createExecTool(options: ExecToolOptions): Tool<
     );
   }
 
-  const callableBackendIds = new Set(
-    backendIds.filter((id) => options.backends[id].callable === true),
-  );
+  const isCallable = options.workspace.runtime.isCallable?.bind(options.workspace.runtime);
+  const callableBackendIds = new Set(backendIds.filter((id) => isCallable?.(id) === true));
   const backendGuidance = backendIds
     .map((id) => {
       const suffix = callableBackendIds.has(id) ? " (callable)" : "";