@springbrand/agent-runtime 0.2.0-alpha.13 → 0.2.0-alpha.14

package/src/pi/tool/base.ts

@@ -15,47 +15,122 @@ import {
 import { webSearchPiToolCandidate } from "./web-search";
 import type { WebSearch } from "./web-search/api";
 
-const askUserParameters = Type.Object({
+const askUserQuestion = Type.Object({
   question: Type.String({
+    minLength: 1,
     description: "The question to put to the user.",
   }),
-  options: Type.Array(Type.String(), {
+  options: Type.Optional(Type.Array(Type.String({ minLength: 1 }), {
     minItems: 2,
     maxItems: 6,
+    uniqueItems: true,
     description: "2-6 mutually distinct options for the user to choose from.",
-  }),
+  })),
   multiSelect: Type.Optional(Type.Boolean({
     description:
       "Whether the user may select more than one option. Defaults to false.",
   })),
+  allowCustom: Type.Optional(Type.Boolean({
+    description:
+      "Whether the user may add free text. Defaults to false with options and true without options.",
+  })),
+});
+
+const askUserParameters = Type.Object({
+  questions: Type.Array(askUserQuestion, {
+    minItems: 1,
+    maxItems: 4,
+    description:
+      "All user decisions needed to continue. Ask them together in one call.",
+  }),
 });
 
 /**
  * `ask_user` 的客户端响应体。
  *
- * `selections` 是选中的选项原文（多选时多于一项），`text` 是可选的补充说明。
+ * `answers` 与 Tool 输入的 `questions` 按下标一一对应。
  * 刻意用结构化数组而不是拼好的字符串 —— 选项本身可能含分隔符，拼了再拆是有损的。
  */
 const askUserResponse = Type.Object({
-  selections: Type.Array(Type.String()),
-  text: Type.Optional(Type.String()),
+  answers: Type.Array(Type.Object({
+    selections: Type.Array(Type.String()),
+    text: Type.Optional(Type.String()),
+  })),
 });
 
-// 手写校验而不是拉 TypeBox 的 compiler：这里只需要判真假，
-// 且校验必须在 Worker 冷启动路径上零成本。
-function isAskUserResponse(value: unknown): boolean {
-  if (typeof value !== "object" || value === null) return false;
-  const record = value as Record<string, unknown>;
-  if (!Array.isArray(record.selections)) return false;
-  if (!record.selections.every((item) => typeof item === "string")) {
-    return false;
+type AskUserInput = Static<typeof askUserParameters>;
+type AskUserResponse = Static<typeof askUserResponse>;
+
+function recordOf(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function questionsOf(value: unknown): AskUserInput["questions"] | null {
+  const questions = recordOf(value)?.questions;
+  if (!Array.isArray(questions) || questions.length < 1 || questions.length > 4) {
+    return null;
   }
-  if (record.text !== undefined && typeof record.text !== "string") {
+  for (const value of questions) {
+    const question = recordOf(value);
+    if (!question || typeof question.question !== "string" || !question.question) {
+      return null;
+    }
+    if (
+      question.multiSelect !== undefined &&
+      typeof question.multiSelect !== "boolean"
+    ) return null;
+    if (
+      question.allowCustom !== undefined &&
+      typeof question.allowCustom !== "boolean"
+    ) return null;
+    if (question.options !== undefined) {
+      if (
+        !Array.isArray(question.options) ||
+        question.options.length < 2 ||
+        question.options.length > 6 ||
+        !question.options.every((option) =>
+          typeof option === "string" && option.length > 0
+        ) ||
+        new Set(question.options).size !== question.options.length
+      ) return null;
+    }
+  }
+  return questions as AskUserInput["questions"];
+}
+
+// 手写校验而不是拉 TypeBox compiler：这里只需要判真假，
+// 且校验位于 Worker 响应信任边界，不应为每次回答编译 schema。
+function isAskUserResponse(input: unknown, value: unknown): boolean {
+  const questions = questionsOf(input);
+  const answers = recordOf(value)?.answers;
+  if (!questions || !Array.isArray(answers) || answers.length !== questions.length) {
     return false;
   }
-  // 什么都没选、也没写字，等于没回答 —— 不该被当成一次有效结算。
-  return record.selections.length > 0 ||
-    (typeof record.text === "string" && record.text.trim().length > 0);
+
+  return questions.every((question, index) => {
+    const answer = recordOf(answers[index]);
+    if (!answer || !Array.isArray(answer.selections)) return false;
+    if (!answer.selections.every((item) => typeof item === "string")) {
+      return false;
+    }
+    if (answer.text !== undefined && typeof answer.text !== "string") {
+      return false;
+    }
+
+    const options = question.options ?? [];
+    const text = typeof answer.text === "string" ? answer.text : "";
+    if (text.length > 2_000) return false;
+    if (answer.selections.some((selection) => !options.includes(selection))) {
+      return false;
+    }
+    if (new Set(answer.selections).size !== answer.selections.length) return false;
+    if (!question.multiSelect && answer.selections.length > 1) return false;
+    const allowCustom = options.length === 0 || question.allowCustom === true;
+    if (!allowCustom && text.trim()) return false;
+    return answer.selections.length > 0 || text.trim().length > 0;
+  });
 }
 
 const suggestFollowupsParameters = Type.Object({
@@ -162,7 +237,7 @@ export function basePiToolCandidates(
         name: "ask_user",
         label: "Ask user",
         description:
-          "Ask the user to choose among a small set of options. Call this tool whenever you need the user to make a choice from limited options — do NOT write plain text like 'please pick A / B / C'. The user's choice comes back to you as this tool's result, so just continue once you have it. Do NOT end your turn after calling this tool.",
+          "Ask all 1-4 user questions needed to continue in one call. Each question may offer 2-6 options, allow multiple selections, and/or allow a custom answer. Do not make one call per question or write plain text like 'please pick A / B / C'. The answers return as this tool's result, so continue the same turn after calling it.",
         parameters: askUserParameters,
         // 永远不会被调用：执行链在 interaction 闸就 park 住了。留一个失败关闭的
         // 实现，是为了万一哪次改动绕过了那道闸，能立刻炸出来而不是静默返回空答案。
@@ -174,18 +249,29 @@ export function basePiToolCandidates(
       }),
       interaction: {
         validateResponse: isAskUserResponse,
-        settle: (_input, response) => {
-          const answer = response as Static<typeof askUserResponse>;
-          const parts = [
-            ...answer.selections,
-            ...(answer.text?.trim() ? [answer.text.trim()] : []),
-          ];
+        settle: (input, response) => {
+          const questions = (input as AskUserInput).questions;
+          const responseAnswers = (response as AskUserResponse).answers;
+          const answers = questions.map((question, index) => {
+            const answer = responseAnswers[index]!;
+            return {
+              question: question.question,
+              selections: answer.selections,
+              ...(answer.text !== undefined ? { text: answer.text.trim() } : {}),
+            };
+          });
           return {
             content: [{
               type: "text",
-              text: `The user answered: ${parts.join(" / ")}`,
+              text: `The user answered:\n${answers.map((answer, index) => {
+                const parts = [
+                  ...answer.selections,
+                  ...(answer.text ? [answer.text] : []),
+                ];
+                return `${index + 1}. ${answer.question}\n   ${parts.join(" / ")}`;
+              }).join("\n")}`,
             }],
-            details: answer,
+            details: { answers },
           };
         },
       },

package/src/pi/tool/compiler.ts

@@ -4,7 +4,16 @@ import type {
   AgentToolResult,
 } from "@earendil-works/pi-agent-core";
 import type { ApprovalReceipt } from "../../kernel/receipts";
-import { boundDurableToolOutput } from "../../layers/context/budget/gate";
+import {
+  boundDurableToolOutput,
+  type BudgetPolicy,
+  spillDurableToolOutput,
+} from "../../layers/context/budget/gate";
+import {
+  type ArtifactRef,
+  serializeOutput,
+  type SpillWorkspace,
+} from "../../lib/artifacts";
 import {
   type ExecutionLevel,
 } from "../../lib/execution-level";
@@ -24,8 +33,8 @@ import {
  * 会让下一次模型调用非法。
  */
 export interface PiToolInteractionSpec {
-  /** 校验客户端响应体；不通过则拒绝投递，park 保持不变。 */
-  readonly validateResponse: (response: unknown) => boolean;
+  /** 结合 Tool 输入校验客户端响应体；不通过则拒绝投递，park 保持不变。 */
+  readonly validateResponse: (input: unknown, response: unknown) => boolean;
   /** 把通过校验的响应映射成 ToolResult；缺省是原样回传。 */
   readonly settle?: (
     input: unknown,
@@ -54,11 +63,14 @@ export interface PiToolCandidate {
   readonly summary?: string;
   readonly source?: ApprovalReceipt["source"];
   readonly interaction?: PiToolInteractionSpec;
+  /** Large payloads spill by default; protocol-shaped results opt into structure. */
+  readonly outputBudget?: BudgetPolicy;
 }
 
 /** 控制候选 Pi 工具如何被编译为可执行工具集。 */
 export interface CompilePiToolsOptions {
   readonly governance?: PiToolGovernance;
+  readonly workspace?: SpillWorkspace;
   readonly settle: (
     call: SettledPiToolCall,
   ) => void | Promise<void>;
@@ -200,6 +212,52 @@ function emitToolTelemetry(
   }
 }
 
+// Most Pi adapters keep the original Tool value in details and its serialized
+// model form in one text block. Spill that original once instead of duplicating
+// it inside an AgentToolResult JSON envelope.
+function spillPayload(result: AgentToolResult<unknown>): unknown {
+  const text = result.content.length === 1 && result.content[0]?.type === "text"
+    ? result.content[0].text
+    : undefined;
+  if (text !== undefined && serializeOutput(result.details).text === text) {
+    return result.details;
+  }
+  return result;
+}
+
+function artifactResult(
+  result: AgentToolResult<unknown>,
+  ref: ArtifactRef,
+): AgentToolResult<unknown> {
+  return {
+    ...result,
+    content: [{
+      type: "text",
+      text: [
+        ref.note,
+        `Path: ${ref.path}`,
+        `Bytes: ${ref.bytes}`,
+        `Preview:\n${ref.preview}`,
+      ].join("\n"),
+    }],
+    details: ref,
+  };
+}
+
+async function durableResult(
+  result: AgentToolResult<unknown>,
+  candidate: PiToolCandidate,
+  workspace: SpillWorkspace | undefined,
+): Promise<AgentToolResult<unknown>> {
+  if ((candidate.outputBudget ?? { kind: "spill" }).kind === "spill") {
+    const ref = await spillDurableToolOutput(spillPayload(result), {
+      workspace,
+    });
+    if (ref) return artifactResult(result, ref);
+  }
+  return boundDurableToolOutput(result) as AgentToolResult<unknown>;
+}
+
 // 记录一次工具失败并在 Turn 达到上限时打开断路器。
 // 受治理 execute 方法在工具或结算失败后调用。
 // 同时记录单输入次数和 Turn 总数，是为了既阻止原样重试又防止换参数无限失败。
@@ -341,9 +399,11 @@ function governedTool(
 
       let result: AgentToolResult<unknown>;
       try {
-        result = boundDurableToolOutput(
+        result = await durableResult(
           await execute(toolCallId, args, signal, onUpdate),
-        ) as AgentToolResult<unknown>;
+          candidate,
+          options.workspace,
+        );
       } catch (cause) {
         const message = errorMessage(cause);
         const result = boundDurableToolOutput({
@@ -442,7 +502,7 @@ export function compilePiTools(
   options: CompilePiToolsOptions,
 ): AgentTool<any, any>[] {
   if (!options?.settle) {
-    throw new Error("Pi Tool settlement port is required");
+    throw new Error("SpringBrand Tool settlement port is required");
   }
   return candidates.map((candidate) => governedTool(candidate, options));
 }

package/src/pi/tool/core-host.ts

@@ -3,10 +3,14 @@ import {
   type WorkspaceFsLike,
 } from "@cloudflare/shell";
 import { createExecuteRuntime } from "@cloudflare/think/tools/execute";
+import { jsonSchema, tool as aiTool, type ToolSet } from "ai";
 import type {
-  RuntimeCodeExecutionPort,
   WorkspacePort,
 } from "../../kernel/bindings";
+import type {
+  RuntimeCodeExecutionFactory,
+  ToolRegistry,
+} from "../../tool-registry";
 
 // 本文件沿用 `../../index.ts` 入口定义的 Workspace、Port 和 Tool Candidate 术语。
 
@@ -19,36 +23,55 @@ const CODEMODE_SANDBOX_TIMEOUT_MS = 55_000;
  *
  * Think 的独立 execute factory 接受显式宿主参数，不要求 Agent 继承 Think；这里只借它组装 Codemode Runtime、Dynamic Worker executor 和已限定范围的 Workspace state connector。
  */
-export function createWorkspaceCodeExecutionPort(options: {
+function codeExecutionTools(tools: ToolRegistry): ToolSet {
+  return Object.fromEntries(Object.entries(tools).map(([name, spec]) => [
+    name,
+    aiTool({
+      description: spec.description,
+      inputSchema: jsonSchema(spec.parameters as never),
+      execute: (input, options) => spec.execute(input, {
+        toolCallId: options?.toolCallId ?? name,
+        signal: options?.abortSignal ?? new AbortController().signal,
+      }),
+    }),
+  ]));
+}
+
+export function createWorkspaceCodeExecutionFactory(options: {
   readonly ctx: DurableObjectState;
   readonly loader: WorkerLoader;
   readonly outbound: Fetcher;
   readonly workspace: WorkspacePort;
-}): RuntimeCodeExecutionPort {
-  const { tool } = createExecuteRuntime({
-    ctx: options.ctx,
-    loader: options.loader,
-    globalOutbound: options.outbound,
-    // 先于外层 60s 截止结束，给 Runtime RPC 结算和 Worker 释放留出时间。
-    timeout: CODEMODE_SANDBOX_TIMEOUT_MS,
-    state: createWorkspaceStateBackend(
-      options.workspace as unknown as WorkspaceFsLike,
-    ),
-    name: "execute",
-  });
-  const { description, execute } = tool;
-  if (typeof description !== "string" || description.length === 0) {
-    throw new Error("Think createExecuteRuntime returned a tool without a description");
-  }
-  if (typeof execute !== "function") {
-    throw new Error("Think createExecuteRuntime returned a non-executable tool");
-  }
+}): RuntimeCodeExecutionFactory {
   return {
-    description,
-    execute: (input) => Promise.resolve(execute(input, {
-      toolCallId: "execute",
-      messages: [],
-      context: undefined,
-    })),
+    create(tools) {
+      const { tool } = createExecuteRuntime({
+        ctx: options.ctx,
+        loader: options.loader,
+        globalOutbound: options.outbound,
+        tools: codeExecutionTools(tools),
+        // 先于外层 60s 截止结束，给 Runtime RPC 结算和 Worker 释放留出时间。
+        timeout: CODEMODE_SANDBOX_TIMEOUT_MS,
+        state: createWorkspaceStateBackend(
+          options.workspace as unknown as WorkspaceFsLike,
+        ),
+        name: "execute",
+      });
+      const { description, execute } = tool;
+      if (typeof description !== "string" || description.length === 0) {
+        throw new Error("Think createExecuteRuntime returned a tool without a description");
+      }
+      if (typeof execute !== "function") {
+        throw new Error("Think createExecuteRuntime returned a non-executable tool");
+      }
+      return {
+        description,
+        execute: (input) => Promise.resolve(execute(input, {
+          toolCallId: "execute",
+          messages: [],
+          context: undefined,
+        })),
+      };
+    },
   };
 }

package/src/pi/tool/core.ts

@@ -12,10 +12,6 @@ import { serializeOutput } from "../../lib/artifacts";
 import type { PiLoadedExtension } from "../assembly/extensions";
 import { aiToolToPi } from "./ai-adapter";
 import type { PiToolCandidate } from "./compiler";
-import {
-  toolRegistryFromPiCandidates,
-  type ToolRegistry,
-} from "../../tool-registry";
 
 // 本文件沿用 `../../index.ts` 入口定义的 Extension、Port 和 Tool Candidate 术语。
 
@@ -164,19 +160,11 @@ export function codeExecutionPiToolCandidate(
   return {
     owner: "core:codemode",
     requiredExecutionLevel: "high",
+    outputBudget: { kind: "structure" },
     source: "codemode",
     summary: "Run JavaScript with network and configured connector access",
     tool,
   };
 }
 
-/** 从 Codemode Runtime Port 生成 `execute` Tool。 */
-export function createCodeExecutionTool(
-  runtime: RuntimeCodeExecutionPort,
-): ToolRegistry {
-  return toolRegistryFromPiCandidates([
-    codeExecutionPiToolCandidate(runtime),
-  ]);
-}
-
 // #endregion

package/src/pi/tool/skill.ts

@@ -1,17 +1,20 @@
 import {
   runner as createSkillScriptRunner,
   SkillRegistry,
+  type SkillResource,
   type SkillScriptRequest,
   type SkillScriptRunner,
   type SkillSource,
 } from "agents/skills";
-import { jsonSchema, type ToolSet } from "ai";
+import { jsonSchema, tool, type ToolSet } from "ai";
+import { z } from "zod";
 import type {
   RuntimeSkillScriptPolicy,
   WorkspacePort,
 } from "../../kernel/bindings";
 import { aiToolToPi } from "./ai-adapter";
 import type { PiToolCandidate } from "./compiler";
+import { serializeWorkspaceMutation } from "./workspace-sandbox";
 
 /** A configured Skill source and its script capabilities. */
 export interface PiSkillBinding {
@@ -103,11 +106,72 @@ const SKILL_TOOL_LABELS: Readonly<Record<string, string>> = {
   activate_skill: "Activate Skill",
   read_skill_resource: "Read Skill resource",
   run_skill_script: "Run Skill script",
+  materialize_skill_resource: "Materialize Skill resource",
 };
 
 const SKILL_ENTRY_READ_GUIDANCE =
   "SKILL.md contains the Skill instructions; use activate_skill instead.";
 
+function resourceBytes(resource: SkillResource): Uint8Array {
+  if ((resource.encoding ?? "text") === "text") {
+    return new TextEncoder().encode(resource.content);
+  }
+  const binary = atob(resource.content);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+function materializeSkillResourceTool(
+  bindings: readonly PiSkillBinding[],
+  workspace: WorkspacePort,
+) {
+  const names = bindings.map(({ name }) => name) as [string, ...string[]];
+  const byName = new Map(bindings.map((binding) => [binding.name, binding]));
+  return tool({
+    description:
+      "Copy a complete bundled Skill resource directly into the Workspace without returning its contents to the model. " +
+      "Use this instead of read_skill_resource when a template, script, image, font, or other asset must become a Workspace file. " +
+      "The destination is created or overwritten, including parent directories.",
+    inputSchema: z.object({
+      name: z.enum(names).describe("Activated Skill name"),
+      path: z.string().min(1).describe("Bundled resource path listed by activate_skill"),
+      destination: z.string().min(1).describe("Absolute destination path in the Workspace"),
+    }),
+    execute: async ({ name, path, destination }, { abortSignal }) => {
+      abortSignal?.throwIfAborted();
+      const source = byName.get(name)?.source;
+      if (!source?.readResource) {
+        throw new Error(`Skill \"${name}\" has no readable resources.`);
+      }
+      const resource = await source.readResource(name, path);
+      if (!resource) throw new Error(`Resource not found: ${name}/${path}`);
+      abortSignal?.throwIfAborted();
+      const bytes = resourceBytes(resource);
+
+      await serializeWorkspaceMutation(workspace, destination, async () => {
+        abortSignal?.throwIfAborted();
+        const parent = destination.replace(/\/[^/]+$/, "");
+        if (parent && parent !== "/") {
+          await workspace.mkdir(parent, { recursive: true });
+        }
+        await workspace.writeFileBytes(destination, bytes, resource.mimeType);
+      });
+
+      return {
+        name,
+        path: resource.path,
+        destination,
+        bytesWritten: bytes.byteLength,
+        encoding: resource.encoding ?? "text",
+        ...(resource.mimeType ? { mimeType: resource.mimeType } : {}),
+      };
+    },
+  });
+}
+
 /** Create Pi candidates from the official Agents SDK SkillRegistry tools. */
 export async function skillPiToolCandidates(
   bindings: readonly PiSkillBinding[],
@@ -121,7 +185,15 @@ export async function skillPiToolCandidates(
   );
   await registry.load();
 
-  return Object.entries(registry.tools()).map(([name, tool]) => {
+  const tools = registry.tools();
+  if (options.workspace) {
+    tools.materialize_skill_resource = materializeSkillResourceTool(
+      bindings,
+      options.workspace,
+    );
+  }
+
+  return Object.entries(tools).map(([name, tool]) => {
     const adapted = aiToolToPi(name, tool, {
       label: SKILL_TOOL_LABELS[name] ?? name,
       ...(name === "read_skill_resource"
@@ -154,7 +226,10 @@ export async function skillPiToolCandidates(
     }
     return {
       owner: "runtime-skill",
-      requiredExecutionLevel: name === "run_skill_script" ? "high" : "safe",
+      requiredExecutionLevel:
+        name === "run_skill_script" || name === "materialize_skill_resource"
+          ? "high"
+          : "safe",
       tool: adapted,
     };
   });

package/src/pi/tool/workspace-sandbox.ts

@@ -111,7 +111,7 @@ const mutationQueues = new WeakMap<
   Map<string, Promise<void>>
 >();
 
-function serializeByPath<T>(
+export function serializeWorkspaceMutation<T>(
   workspace: WorkspacePort,
   path: string,
   run: () => Promise<T>,
@@ -193,7 +193,7 @@ export function workspacePiToolCandidates(
       signal?.throwIfAborted();
       running(onUpdate, "Writing the Workspace file.");
 
-      return serializeByPath(workspace, path, async () => {
+      return serializeWorkspaceMutation(workspace, path, async () => {
         // 排队期间可能已经被取消,拿到闸之后必须重新确认,否则会写一个已放弃的结果。
         signal?.throwIfAborted();
         return writeTool.execute(
@@ -221,7 +221,7 @@ export function workspacePiToolCandidates(
       running(onUpdate, "Editing the Workspace file.");
       // 读-比对-写整段都在闸内:闸只包住最后那次 writeFile 的话,基准内容仍然可能在
       // 比对之后被别的调用换掉,丢写照旧发生。
-      return serializeByPath(workspace, params.path, async () => {
+      return serializeWorkspaceMutation(workspace, params.path, async () => {
         signal?.throwIfAborted();
         const output = await editTool.execute(
           toolCallId,
@@ -267,7 +267,7 @@ export function workspacePiToolCandidates(
       if (typeof path !== "string") {
         return removeTool.execute(toolCallId, params, signal, onUpdate);
       }
-      return serializeByPath(workspace, path, () =>
+      return serializeWorkspaceMutation(workspace, path, () =>
         removeTool.execute(toolCallId, params, signal, onUpdate),
       );
     },

package/src/pi/turn/tool-recovery.ts

@@ -429,7 +429,7 @@ function assertIdentity(
       state.assemblyRevision !== milestone.assemblyRevision)
   ) {
     throw new Error(
-      "Pi recovery milestone does not belong to the active Turn revision",
+      "SpringBrand recovery milestone does not belong to the active Turn revision",
     );
   }
 }
@@ -496,7 +496,7 @@ export function replayPiToolRecovery(
         const previous = tools[milestone.toolCallId];
         if (previous && !sameToolInput(previous, milestone)) {
           throw new Error(
-            `Conflicting Pi Tool input for ${milestone.toolCallId}`,
+            `Conflicting SpringBrand Tool input for ${milestone.toolCallId}`,
           );
         }
         tools[milestone.toolCallId] = previous ?? {
@@ -891,7 +891,7 @@ export function applyRecoveredPiApprovalDecision(
 ): RecoveredPiApprovalDecision {
   const approval = state.approvals[input.executionId];
   if (!approval) {
-    throw new Error(`Unknown Pi Tool approval ${input.executionId}`);
+    throw new Error(`Unknown SpringBrand Tool approval ${input.executionId}`);
   }
   const transition = decidePiToolApproval(
     approval,
@@ -908,7 +908,7 @@ export function applyRecoveredPiApprovalDecision(
     return { milestones: [], outcome: transition.outcome };
   }
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool approval is missing its Turn revision");
+    throw new Error("SpringBrand Tool approval is missing its Turn revision");
   }
 
   const identity: RecoveryIdentity = {
@@ -951,7 +951,7 @@ export function recordRecoveredPiToolInteraction(
   interaction: PiToolInteraction,
 ): PiToolRecoveryMilestone[] {
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool interaction is missing its Turn revision");
+    throw new Error("SpringBrand Tool interaction is missing its Turn revision");
   }
   return [{
     version: 1,
@@ -989,7 +989,7 @@ export function applyRecoveredPiToolInteractionSettlement(
 ): RecoveredPiToolInteractionSettlement {
   const interaction = state.interactions[input.interactionId];
   if (!interaction) {
-    throw new Error(`Unknown Pi Tool interaction ${input.interactionId}`);
+    throw new Error(`Unknown SpringBrand Tool interaction ${input.interactionId}`);
   }
   const transition = input.kind === "respond"
     ? respondPiToolInteraction(interaction, {
@@ -1008,7 +1008,7 @@ export function applyRecoveredPiToolInteractionSettlement(
     return { milestones: [], outcome };
   }
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool interaction is missing its Turn revision");
+    throw new Error("SpringBrand Tool interaction is missing its Turn revision");
   }
 
   const identity: RecoveryIdentity = {

package/src/runtime-agent.ts

@@ -652,9 +652,14 @@ export function defineRuntimeAgent<
         const policy = assembly.surfacePolicy;
         return {
           ...assembly,
-          bindings: assembly.bindings?.workspace
-            ? { workspace: assembly.bindings.workspace }
-            : {},
+          bindings: {
+            ...(assembly.bindings?.workspace
+              ? { workspace: assembly.bindings.workspace }
+              : {}),
+            ...(assembly.bindings?.codeExecution
+              ? { codeExecution: assembly.bindings.codeExecution }
+              : {}),
+          },
           memoryProfile: {
             enabled: false,
             memoryTokens: 2_000,