experimental-agent 0.0.5 → 0.1.2

package/dist/chunk-ILPVXRI5.mjs

@@ -0,0 +1,2026 @@
+import {
+  DEFAULT_WAIT_UNTIL
+} from "./chunk-64THY7Y7.mjs";
+
+// src/agent-workflow.ts
+import { defineHook, FatalError as FatalError2, getWritable } from "workflow";
+
+// src/agent-workflow-steps.ts
+import {
+  convertToModelMessages,
+  createUIMessageStream,
+  stepCountIs,
+  streamText
+} from "ai";
+import { ulid } from "ulid";
+import { FatalError } from "workflow";
+
+// src/skills/parser.ts
+function parseSkillFrontmatter(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMarkerIndex = trimmed.indexOf("---", 3);
+  if (endMarkerIndex === -1) {
+    return null;
+  }
+  const frontmatterBlock = trimmed.slice(3, endMarkerIndex).trim();
+  const parsed = parseSimpleYaml(frontmatterBlock);
+  if (!(parsed.name && parsed.description)) {
+    return null;
+  }
+  return {
+    name: String(parsed.name),
+    description: String(parsed.description)
+  };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = trimmedLine.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmedLine.slice(0, colonIndex).trim();
+    let value = trimmedLine.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function normalizeSkillsDirs(skillsDir) {
+  if (!skillsDir) {
+    return [];
+  }
+  return Array.isArray(skillsDir) ? skillsDir : [skillsDir];
+}
+
+// src/skills/discover.ts
+async function discoverSkillsInSandbox(opts) {
+  const { sandbox, skillsDirs, debug } = opts;
+  const summaries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    const dirSummaries = await discoverSkillsInDirectory({
+      sandbox,
+      skillsDir,
+      debug
+    });
+    for (const summary of dirSummaries) {
+      if (!seenNames.has(summary.name)) {
+        seenNames.add(summary.name);
+        summaries.push(summary);
+      }
+    }
+  }
+  return summaries;
+}
+async function discoverSkillsInDirectory(opts) {
+  const { sandbox, skillsDir, debug } = opts;
+  const skillPaths = await findSkillFiles({ sandbox, skillsDir, debug });
+  if (skillPaths.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  for (const skillMdPath of skillPaths) {
+    const summary = await parseSkillFile({ sandbox, skillMdPath, debug });
+    if (summary) {
+      summaries.push(summary);
+    }
+  }
+  return summaries;
+}
+async function findSkillFiles(opts) {
+  const { sandbox, skillsDir, debug } = opts;
+  const execResult = await sandbox.exec({
+    command: "find",
+    args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
+  });
+  if (execResult instanceof Error) {
+    if (debug) {
+      console.warn(
+        `[discover] Failed to scan skills directory "${skillsDir}": ${execResult.message}`
+      );
+    }
+    return [];
+  }
+  const { stdout, stderr, exitCode } = await execResult.result;
+  if (debug) {
+    console.log(
+      `[discover] find result: exitCode=${exitCode}, stdout="${stdout.trim()}", stderr="${stderr.trim()}"`
+    );
+  }
+  if (exitCode !== 0) {
+    if (debug) {
+      console.warn(
+        `[discover] Skills directory not found or inaccessible: ${skillsDir}`
+      );
+    }
+    return [];
+  }
+  const paths = stdout.trim().split("\n").filter((p) => p.length > 0);
+  if (debug) {
+    console.log("[discover] Found skill paths:", paths);
+  }
+  return paths;
+}
+async function parseSkillFile(opts) {
+  const { sandbox, skillMdPath, debug } = opts;
+  const execResult = await sandbox.exec({
+    command: "cat",
+    args: [skillMdPath]
+  });
+  if (execResult instanceof Error) {
+    if (debug) {
+      console.warn(
+        `[discover] Failed to read skill file "${skillMdPath}": ${execResult.message}`
+      );
+    }
+    return null;
+  }
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    if (debug) {
+      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);
+    }
+    return null;
+  }
+  const parsed = parseSkillFrontmatter(stdout);
+  if (!parsed) {
+    if (debug) {
+      console.warn(
+        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`
+      );
+    }
+    return null;
+  }
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    skillMdPath
+  };
+}
+
+// src/tools/index.ts
+import { jsonSchema, tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+
+// src/tools/javascript.ts
+import { tool } from "ai";
+import { z } from "zod";
+var REQUEST_MARKER_START = "__TOOL_REQUEST__";
+var REQUEST_MARKER_END = "__TOOL_REQUEST_END__";
+var EXECUTION_TIMEOUT_MS = 5 * 60 * 1e3;
+var RUNNER_SCRIPT = `
+import { readFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const TOOL_CALL_TIMEOUT_MS = 300_000;
+
+let reqCounter = 0;
+
+async function callTool(name, input) {
+  const id = 'req_' + (++reqCounter) + '_' + Date.now();
+  const responseFile = join(SCRIPT_DIR, id + '.response.json');
+
+  const request = JSON.stringify({ id, tool: name, input });
+  process.stderr.write('${REQUEST_MARKER_START}' + request + '${REQUEST_MARKER_END}' + '\\n');
+
+  const start = Date.now();
+  while (!existsSync(responseFile)) {
+    if (Date.now() - start > TOOL_CALL_TIMEOUT_MS) {
+      throw new Error('Tool call ' + name + ' timed out waiting for response');
+    }
+    await new Promise(r => setTimeout(r, 30));
+  }
+
+  let raw;
+  try {
+    raw = readFileSync(responseFile, 'utf8');
+  } catch {
+    await new Promise(r => setTimeout(r, 50));
+    raw = readFileSync(responseFile, 'utf8');
+  }
+
+  const response = JSON.parse(raw);
+  try { unlinkSync(responseFile); } catch {}
+
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  return response.result;
+}
+
+const code = readFileSync(join(SCRIPT_DIR, 'code.js'), 'utf8');
+const toolNames = JSON.parse(readFileSync(join(SCRIPT_DIR, 'tools.json'), 'utf8'));
+
+const ctx = { tools: {} };
+for (const name of toolNames) {
+  ctx.tools[name] = (input) => callTool(name, input);
+}
+
+const logs = [];
+const customConsole = {
+  log: (...args) => logs.push(args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+  error: (...args) => logs.push('[error] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+  warn: (...args) => logs.push('[warn] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+};
+
+try {
+  const AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+  const fn = new AsyncFunction('ctx', 'console', code);
+  const result = await fn(ctx, customConsole);
+
+  const output = { success: true, result: result !== undefined ? result : null };
+  if (logs.length > 0) output.logs = logs;
+  process.stdout.write(JSON.stringify(output));
+} catch (err) {
+  const output = {
+    success: false,
+    error: err instanceof Error ? err.message + '\\n' + err.stack : String(err),
+  };
+  if (logs.length > 0) output.logs = logs;
+  process.stdout.write(JSON.stringify(output));
+}
+`;
+function extractJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return null;
+  }
+  if ("_def" in schema && typeof schema._def === "object") {
+    try {
+      return z.toJSONSchema(schema);
+    } catch {
+      return null;
+    }
+  }
+  const s = schema;
+  if (/* @__PURE__ */ Symbol.for("vercel.ai.schema") in s && "jsonSchema" in s) {
+    return s.jsonSchema;
+  }
+  if ("type" in s || "properties" in s) {
+    return s;
+  }
+  return null;
+}
+function jsonSchemaToTs(schema, indent = 0) {
+  if (!schema) {
+    return "unknown";
+  }
+  if (schema.enum && Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map((s) => jsonSchemaToTs(s, indent)).join(" | ");
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map((s) => jsonSchemaToTs(s, indent)).join(" | ");
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array": {
+      const items = schema.items ? jsonSchemaToTs(schema.items, indent) : "unknown";
+      return `Array<${items}>`;
+    }
+    case "object": {
+      const properties = schema.properties;
+      if (!properties) {
+        return "Record<string, unknown>";
+      }
+      const required = new Set(schema.required || []);
+      const pad = "  ".repeat(indent + 1);
+      const closePad = "  ".repeat(indent);
+      const props = Object.entries(properties).map(([key, value]) => {
+        const opt = required.has(key) ? "" : "?";
+        return `${pad}${key}${opt}: ${jsonSchemaToTs(value, indent + 1)}`;
+      });
+      return `{
+${props.join(";\n")};
+${closePad}}`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function generateContextTypeString(tools) {
+  const sigs = [];
+  for (const [name, t] of Object.entries(tools)) {
+    const raw = t;
+    const inputSchema = extractJsonSchema(raw.inputSchema ?? raw.parameters);
+    const outputSchema = extractJsonSchema(raw.outputSchema);
+    const inputType = inputSchema ? jsonSchemaToTs(inputSchema, 2) : "{}";
+    const outputType = outputSchema ? jsonSchemaToTs(outputSchema, 2) : "unknown";
+    sigs.push(`    ${name}(input: ${inputType}): Promise<${outputType}>`);
+  }
+  return `type Context = {
+  tools: {
+${sigs.join(";\n")};
+  }
+}`;
+}
+async function executeInSandbox({
+  code,
+  rpcDir,
+  abortController,
+  sandbox,
+  availableTools,
+  onSubToolCall
+}) {
+  const mkdirResult = await sandbox.exec({
+    command: "mkdir",
+    args: ["-p", rpcDir]
+  });
+  if (mkdirResult instanceof Error) {
+    return { success: false, error: mkdirResult.message };
+  }
+  await mkdirResult.result;
+  await sandbox.writeFiles({
+    files: [
+      { path: "runner.mjs", content: RUNNER_SCRIPT },
+      { path: "code.js", content: code },
+      {
+        path: "tools.json",
+        content: JSON.stringify(Object.keys(availableTools))
+      }
+    ],
+    destPath: rpcDir
+  });
+  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
+  const permissionFlag = nodeMajor >= 22 ? "--permission" : "--experimental-permission";
+  const execResult = await sandbox.exec({
+    command: "node",
+    args: [
+      permissionFlag,
+      `--allow-fs-read=${rpcDir}`,
+      `--allow-fs-write=${rpcDir}`,
+      `${rpcDir}/runner.mjs`
+    ],
+    signal: abortController.signal
+  });
+  if (execResult instanceof Error) {
+    return { success: false, error: execResult.message };
+  }
+  const fatal = { error: null };
+  const abort = (error) => {
+    if (!fatal.error) {
+      fatal.error = error;
+      abortController.abort();
+    }
+  };
+  const handleToolRequest = async (requestJson) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(requestJson);
+    } catch {
+      return;
+    }
+    const { id, tool: toolName, input } = parsed;
+    let response;
+    try {
+      const t = availableTools[toolName];
+      if (!t?.execute) {
+        throw new Error(
+          `Tool ${toolName} not found or has no execute function`
+        );
+      }
+      const exec = t.execute.bind(t);
+      if (onSubToolCall) {
+        response = await onSubToolCall(
+          toolName,
+          input,
+          () => exec(input, {
+            toolCallId: `js_${toolName}_${Date.now()}`,
+            messages: []
+          })
+        );
+      } else {
+        const result = await exec(input, {
+          toolCallId: `js_${toolName}_${Date.now()}`,
+          messages: []
+        });
+        response = { result };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      response = { error: msg };
+    }
+    try {
+      await sandbox.writeFiles({
+        files: [
+          {
+            path: `${id}.response.json`,
+            content: JSON.stringify(response)
+          }
+        ],
+        destPath: rpcDir
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      abort(new Error(`Failed to write RPC response for ${toolName}: ${msg}`));
+    }
+  };
+  const toolCallPromises = [];
+  let stderrBuffer = "";
+  let nonMarkerStderr = "";
+  const timeout = setTimeout(() => {
+    abort(
+      new Error(
+        `JavaScript execution timed out after ${EXECUTION_TIMEOUT_MS / 1e3}s`
+      )
+    );
+  }, EXECUTION_TIMEOUT_MS);
+  try {
+    for await (const entry of execResult.logs()) {
+      if (fatal.error) {
+        break;
+      }
+      if (entry.stream === "stderr") {
+        stderrBuffer += entry.data;
+        while (true) {
+          const startIdx = stderrBuffer.indexOf(REQUEST_MARKER_START);
+          if (startIdx === -1) {
+            break;
+          }
+          const beforeMarker = stderrBuffer.slice(0, startIdx);
+          if (beforeMarker.trim()) {
+            nonMarkerStderr += beforeMarker;
+          }
+          const contentStart = startIdx + REQUEST_MARKER_START.length;
+          const endIdx = stderrBuffer.indexOf(REQUEST_MARKER_END, contentStart);
+          if (endIdx === -1) {
+            break;
+          }
+          const requestJson = stderrBuffer.slice(contentStart, endIdx);
+          stderrBuffer = stderrBuffer.slice(endIdx + REQUEST_MARKER_END.length);
+          toolCallPromises.push(handleToolRequest(requestJson));
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (stderrBuffer.trim()) {
+    nonMarkerStderr += stderrBuffer;
+  }
+  await Promise.allSettled(toolCallPromises);
+  if (fatal.error) {
+    execResult.result.catch(() => void 0);
+    return {
+      success: false,
+      error: fatal.error.message,
+      ...nonMarkerStderr ? { stderr: nonMarkerStderr.slice(0, 2e3) } : {}
+    };
+  }
+  const { stdout, stderr, exitCode } = await execResult.result;
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return {
+      success: false,
+      error: `Runner failed (exit ${exitCode}).`,
+      stderr: (nonMarkerStderr + stderr).slice(0, 2e3),
+      stdout: stdout.slice(0, 1e3)
+    };
+  }
+}
+function createJavaScriptTool(opts) {
+  const { session, sandbox, onSubToolCall } = opts;
+  const activeSet = session.activeTools ? new Set(session.activeTools) : null;
+  const availableTools = {};
+  for (const [name, t] of Object.entries(opts.tools)) {
+    if (!activeSet || activeSet.has(name)) {
+      availableTools[name] = t;
+    }
+  }
+  const contextType = generateContextTypeString(availableTools);
+  return tool({
+    ...builtInTools.JavaScript,
+    description: `Execute JavaScript to orchestrate multiple tool calls in a single step. Use this when you need to run several tools in sequence, transform intermediate results, or parallelize independent operations with Promise.all.
+
+The code runs as an async function body with \`ctx\` in scope:
+
+\`\`\`typescript
+${contextType}
+\`\`\`
+
+Examples:
+- Sequential: \`const file = await ctx.tools.Read({ path: "package.json" }); return JSON.parse(file.content);\`
+- Parallel: \`const [a, b] = await Promise.all([ctx.tools.Read({ path: "a.ts" }), ctx.tools.Read({ path: "b.ts" })]); return { a: a.content, b: b.content };\`
+- Transform: \`const grep = await ctx.tools.Grep({ pattern: "TODO" }); return grep.matches.split("\\n").length;\`
+
+Return a value to pass results back. Use console.log() for debug output.`,
+    execute: ({ code }) => {
+      const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const rpcDir = `.agent/js-rpc/${runId}`;
+      const abortController = new AbortController();
+      return executeInSandbox({
+        code,
+        rpcDir,
+        abortController,
+        sandbox,
+        availableTools,
+        onSubToolCall
+      });
+    }
+  });
+}
+
+// src/tools/index.ts
+var AGENT_PROTOCOL_VERSION = "v1";
+function formatFileSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}K`;
+  }
+  if (bytes < 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+  }
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
+var builtInTools = {
+  Read: tool2({
+    description: "Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.",
+    inputSchema: z2.object({
+      path: z2.string().describe("Path to the file relative to workspace root"),
+      startLine: z2.number().optional().describe(
+        "Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size."
+      ),
+      endLine: z2.number().optional().describe(
+        "Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size."
+      )
+    }),
+    outputSchema: z2.object({
+      content: z2.string().describe("File content"),
+      metadata: z2.object({
+        totalLines: z2.number().describe("Total number of lines in the file"),
+        linesShown: z2.number().describe("Number of lines included in this response"),
+        startLine: z2.number().describe("First line number shown (1-indexed)"),
+        endLine: z2.number().describe("Last line number shown (1-indexed)"),
+        isPaginated: z2.boolean().describe("Whether this is a partial view of the file"),
+        fileSize: z2.string().describe("Human-readable file size (e.g., '2.5K', '1.2M')"),
+        path: z2.string().describe("Path to the file relative to workspace root")
+      })
+    })
+  }),
+  Grep: tool2({
+    description: "Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.",
+    inputSchema: z2.object({
+      pattern: z2.string().describe("Regex pattern to search for (ripgrep syntax)"),
+      path: z2.string().optional().describe(
+        "Path to search in (defaults to workspace root). Can be a file or directory."
+      ),
+      fileType: z2.string().optional().describe(
+        "File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters."
+      ),
+      glob: z2.string().optional().describe(
+        "Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')"
+      ),
+      caseSensitive: z2.boolean().optional().default(true).describe("Whether search is case-sensitive (default: true)"),
+      contextLines: z2.number().optional().describe(
+        "Number of context lines to show before and after each match"
+      ),
+      maxCount: z2.number().optional().describe(
+        "Maximum number of matches per file (useful for limiting output)"
+      ),
+      filesWithMatches: z2.boolean().optional().default(false).describe(
+        "Only show file paths that contain matches, not the matching lines themselves"
+      )
+    }),
+    outputSchema: z2.object({
+      matches: z2.string().describe(
+        "Search results with file paths, line numbers, and matching content"
+      ),
+      summary: z2.object({
+        matchCount: z2.number().describe("Number of matches found"),
+        fileCount: z2.number().describe("Number of files containing matches"),
+        searchPath: z2.string().describe("Path that was searched"),
+        pattern: z2.string().describe("Pattern that was searched for")
+      })
+    })
+  }),
+  List: tool2({
+    description: "Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.",
+    inputSchema: z2.object({
+      path: z2.string().optional().describe("Path to list (defaults to workspace root)"),
+      depth: z2.number().optional().describe(
+        "Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping"
+      ),
+      includeHidden: z2.boolean().optional().default(false).describe(
+        "Include hidden files and directories (those starting with '.')"
+      ),
+      filesOnly: z2.boolean().optional().default(false).describe("Only show files, not directories"),
+      pattern: z2.string().optional().describe("Glob pattern to filter results (e.g., '*.ts', '*test*')")
+    }),
+    outputSchema: z2.object({
+      listing: z2.string().describe(
+        "Directory tree listing showing paths relative to search root"
+      ),
+      summary: z2.object({
+        totalItems: z2.number().describe("Total number of items found"),
+        totalFiles: z2.number().describe("Total number of files found"),
+        totalDirs: z2.number().describe("Total number of directories found"),
+        searchPath: z2.string().describe("Path that was listed"),
+        depth: z2.number().optional().describe("Maximum depth used (if specified)")
+      })
+    })
+  }),
+  Write: tool2({
+    description: "Write content to a file. Creates parent directories automatically. Overwrites existing files.",
+    inputSchema: z2.object({
+      path: z2.string().describe("Path to the file relative to workspace root"),
+      content: z2.string().describe("Content to write to the file")
+    }),
+    outputSchema: z2.object({
+      success: z2.boolean().describe("Whether the write succeeded"),
+      path: z2.string().describe("Path to the written file"),
+      bytesWritten: z2.number().describe("Number of bytes written"),
+      error: z2.string().optional().describe("Error message if write failed")
+    })
+  }),
+  Edit: tool2({
+    description: "Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.",
+    inputSchema: z2.object({
+      path: z2.string().describe("Path to the file relative to workspace root"),
+      old_string: z2.string().describe("Exact string to find and replace (must be unique in file)"),
+      new_string: z2.string().describe("String to replace old_string with")
+    }),
+    outputSchema: z2.object({
+      success: z2.boolean().describe("Whether the edit succeeded"),
+      path: z2.string().describe("Path to the edited file"),
+      error: z2.string().optional().describe("Error message if edit failed")
+    })
+  }),
+  Bash: tool2({
+    description: "Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).",
+    inputSchema: z2.object({
+      command: z2.string().describe("The shell command to execute"),
+      waitUntil: z2.number().optional().describe(
+        `Max ms to wait for completion (default: ${DEFAULT_WAIT_UNTIL}). Use 0 to run in background and return immediately.`
+      )
+    }),
+    outputSchema: z2.object({
+      pid: z2.number().describe(
+        "System PID (0 for foreground, >0 for background - use to kill)"
+      ),
+      output: z2.string().describe("Command stdout+stderr combined (empty for background)"),
+      exitCode: z2.number().describe("Exit code (-1 for background/running)"),
+      status: z2.enum(["running", "completed", "failed"]).describe("Process status"),
+      cwd: z2.string().describe("Current working directory after command"),
+      outputFile: z2.string().describe("Path to output log (for background processes)")
+    })
+  }),
+  JavaScript: tool2({
+    inputSchema: z2.object({
+      code: z2.string().describe(
+        "JavaScript async function body. `ctx` is in scope. Must use `return` to produce output."
+      )
+    })
+  })
+};
+var builtinToolNames = Object.fromEntries(
+  Object.entries(builtInTools).map(([name]) => [name, name])
+);
+function getTools(context) {
+  const tools = {
+    [builtinToolNames.Read]: tool2({
+      ...builtInTools.Read,
+      execute: async ({ path, startLine, endLine }) => {
+        const filePath = path;
+        const result = await context.sandbox.readFile({ path: filePath });
+        if (result instanceof Error) {
+          console.error("[Read Tool]", result);
+          throw result;
+        }
+        if (result === null) {
+          return {
+            content: `Error: File not found - ${filePath}`,
+            metadata: {
+              totalLines: 0,
+              linesShown: 0,
+              startLine: 0,
+              endLine: 0,
+              isPaginated: false,
+              fileSize: "0",
+              path: filePath
+            }
+          };
+        }
+        const fullContent = result.toString("utf-8");
+        const lines = fullContent.split("\n");
+        if (lines.length > 0 && lines.at(-1) === "") {
+          lines.pop();
+        }
+        const totalLines = lines.length;
+        const fileBytes = Buffer.byteLength(fullContent);
+        const fileSize = formatFileSize(fileBytes);
+        const PAGE_SIZE = 100;
+        let actualStart;
+        let actualEnd;
+        if (startLine !== void 0 && endLine !== void 0) {
+          actualStart = startLine;
+          actualEnd = endLine;
+        } else if (startLine !== void 0) {
+          actualStart = startLine;
+          actualEnd = Math.min(startLine + PAGE_SIZE - 1, totalLines);
+        } else if (endLine !== void 0) {
+          actualStart = 1;
+          actualEnd = endLine;
+        } else if (totalLines > 200) {
+          actualStart = 1;
+          actualEnd = PAGE_SIZE;
+        } else {
+          actualStart = 1;
+          actualEnd = totalLines;
+        }
+        const slicedLines = lines.slice(actualStart - 1, actualEnd);
+        const content = slicedLines.join("\n");
+        return {
+          metadata: {
+            totalLines,
+            linesShown: Math.max(0, actualEnd - actualStart + 1),
+            startLine: actualStart,
+            endLine: actualEnd,
+            isPaginated: actualEnd < totalLines,
+            fileSize,
+            path: filePath
+          },
+          content
+        };
+      }
+    }),
+    [builtinToolNames.Grep]: tool2({
+      ...builtInTools.Grep,
+      execute: async ({
+        pattern,
+        path,
+        fileType,
+        glob,
+        caseSensitive,
+        contextLines,
+        maxCount,
+        filesWithMatches
+      }) => {
+        const searchPath = path ?? ".";
+        const args = [];
+        args.push("--line-number");
+        args.push("--heading");
+        args.push("--color", "never");
+        if (!caseSensitive) {
+          args.push("-i");
+        }
+        if (fileType) {
+          args.push("--type", fileType);
+        }
+        if (glob) {
+          args.push("--glob", glob);
+        }
+        if (contextLines !== void 0) {
+          args.push("-C", String(contextLines));
+        }
+        if (maxCount !== void 0) {
+          args.push("--max-count", String(maxCount));
+        }
+        if (filesWithMatches) {
+          args.push("--files-with-matches");
+        }
+        args.push("--", pattern, searchPath);
+        const result = await context.sandbox.exec({ command: "rg", args });
+        if (result instanceof Error) {
+          console.error("[Grep Tool]", result);
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr && !stderr.toLowerCase().includes("no matches")) {
+          console.error(`[Grep Tool] Warning: ${stderr}`);
+        }
+        const MAX_GREP_OUTPUT_CHARS = 5e4;
+        let finalOutput = stdout;
+        let wasTruncated = false;
+        if (finalOutput.length > MAX_GREP_OUTPUT_CHARS) {
+          finalOutput = finalOutput.slice(0, MAX_GREP_OUTPUT_CHARS) + "\n\n[Output truncated - use more specific pattern or path]";
+          wasTruncated = true;
+        }
+        const lines = finalOutput.trim().split("\n").filter((l) => l.length > 0);
+        const fileCount = filesWithMatches ? lines.length : new Set(
+          lines.filter((l) => !l.startsWith(" ") && l.includes(":")).map((l) => l.split(":")[0])
+        ).size;
+        return {
+          summary: {
+            matchCount: filesWithMatches ? 0 : lines.filter((l) => l.includes(":")).length,
+            fileCount,
+            searchPath,
+            pattern,
+            wasTruncated
+          },
+          matches: finalOutput || "(no matches found)"
+        };
+      }
+    }),
+    [builtinToolNames.List]: tool2({
+      ...builtInTools.List,
+      execute: async ({ path, depth, includeHidden, filesOnly, pattern }) => {
+        const searchPath = path ?? ".";
+        const result = await context.sandbox.exec({
+          command: "bash",
+          args: [
+            "-c",
+            `
+            set -e
+            SEARCH_PATH="$1"
+            DEPTH="$2"
+            INCLUDE_HIDDEN="$3"
+            FILES_ONLY="$4"
+            PATTERN="$5"
+
+            # Build find command arguments
+            FIND_ARGS=""
+            [ -n "$DEPTH" ] && FIND_ARGS="$FIND_ARGS -maxdepth $DEPTH"
+            [ "$INCLUDE_HIDDEN" != "true" ] && FIND_ARGS="$FIND_ARGS ! -path '*/.*'"
+            [ "$FILES_ONLY" = "true" ] && FIND_ARGS="$FIND_ARGS -type f"
+            [ -n "$PATTERN" ] && FIND_ARGS="$FIND_ARGS -name '$PATTERN'"
+
+            # Get listing
+            LISTING=$(eval "find '$SEARCH_PATH' $FIND_ARGS" 2>/dev/null | sort)
+
+            # Get counts
+            COUNT_ARGS=""
+            [ -n "$DEPTH" ] && COUNT_ARGS="$COUNT_ARGS -maxdepth $DEPTH"
+            [ "$INCLUDE_HIDDEN" != "true" ] && COUNT_ARGS="$COUNT_ARGS ! -path '*/.*'"
+
+            FILE_COUNT=$(eval "find '$SEARCH_PATH' $COUNT_ARGS -type f" 2>/dev/null | wc -l)
+            DIR_COUNT=$(eval "find '$SEARCH_PATH' $COUNT_ARGS -type d" 2>/dev/null | wc -l)
+
+            # Output: counts first, then listing
+            echo "$FILE_COUNT|$DIR_COUNT"
+            echo "|||LISTING|||"
+            echo "$LISTING" | sed "s|^$SEARCH_PATH|.|"
+          `,
+            "--",
+            searchPath,
+            depth?.toString() || "",
+            includeHidden ? "true" : "false",
+            filesOnly ? "true" : "false",
+            pattern || ""
+          ]
+        });
+        if (result instanceof Error) {
+          console.error("[List Tool]", result);
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr) {
+          console.warn(`[List Tool] stderr: ${stderr}`);
+        }
+        const [countsLine, ...rest] = stdout.split("|||LISTING|||");
+        const listing = rest.join("|||LISTING|||").trim();
+        const [fileCountStr, dirCountStr] = countsLine.trim().split("|");
+        const totalFiles = Number.parseInt(fileCountStr, 10) || 0;
+        const totalDirs = Number.parseInt(dirCountStr, 10) || 0;
+        const lines = listing.split("\n").filter((l) => l.length > 0);
+        return {
+          summary: {
+            totalItems: lines.length,
+            totalFiles,
+            totalDirs,
+            searchPath,
+            depth
+          },
+          listing
+        };
+      }
+    }),
+    [builtinToolNames.Write]: tool2({
+      ...builtInTools.Write,
+      execute: async ({ path, content }) => {
+        const filePath = path.startsWith("/") ? path.slice(1) : path;
+        const dir = filePath.includes("/") ? filePath.split("/").slice(0, -1).join("/") : ".";
+        const fileName = filePath.split("/").pop() || filePath;
+        try {
+          if (dir !== ".") {
+            await context.sandbox.exec({ command: "mkdir", args: ["-p", dir] });
+          }
+          await context.sandbox.writeFiles({
+            files: [{ path: fileName, content }],
+            destPath: dir
+          });
+          return {
+            success: true,
+            path: filePath,
+            bytesWritten: Buffer.byteLength(content, "utf8")
+          };
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          return {
+            success: false,
+            path: filePath,
+            bytesWritten: 0,
+            error: errorMsg
+          };
+        }
+      }
+    }),
+    [builtinToolNames.Edit]: tool2({
+      ...builtInTools.Edit,
+      execute: async ({ path, old_string, new_string }) => {
+        const filePath = path.startsWith("/") ? path.slice(1) : path;
+        const result = await context.sandbox.readFile({ path: filePath });
+        if (result instanceof Error) {
+          return { success: false, path: filePath, error: result.message };
+        }
+        if (result === null) {
+          return {
+            success: false,
+            path: filePath,
+            error: `File not found: ${filePath}`
+          };
+        }
+        const content = result.toString("utf-8");
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return {
+            success: false,
+            path: filePath,
+            error: "old_string not found in file"
+          };
+        }
+        if (occurrences > 1) {
+          return {
+            success: false,
+            path: filePath,
+            error: `old_string appears ${occurrences} times in file (must be unique). Include more surrounding context to make the match unique.`
+          };
+        }
+        const newContent = content.replace(old_string, new_string);
+        const dir = filePath.includes("/") ? filePath.split("/").slice(0, -1).join("/") : ".";
+        const fileName = filePath.split("/").pop() || filePath;
+        try {
+          await context.sandbox.writeFiles({
+            files: [{ path: fileName, content: newContent }],
+            destPath: dir
+          });
+          return { success: true, path: filePath };
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          return { success: false, path: filePath, error: errorMsg };
+        }
+      }
+    }),
+    [builtinToolNames.Bash]: tool2({
+      ...builtInTools.Bash,
+      execute: async ({ command, waitUntil }) => {
+        const { createProcessManager } = await import("./process-manager-ZCET3VD2.mjs");
+        const processManager = createProcessManager({
+          sandbox: context.sandbox,
+          sessionId: context.input.sessionId
+        });
+        await processManager.init();
+        const result = await processManager.run({ command, waitUntil });
+        return result;
+      }
+    })
+  };
+  if (context.apiToolsMetadata.length > 0) {
+    const apiTools = buildApiTools({
+      rpc: context.input.rpc,
+      metadata: context.apiToolsMetadata,
+      session: context.session,
+      sandboxRecord: context.sandboxRecord,
+      context: context.event.context
+    });
+    Object.assign(tools, apiTools);
+  }
+  tools[builtinToolNames.JavaScript] = createJavaScriptTool({
+    tools,
+    session: context.session,
+    sandbox: context.sandbox,
+    onSubToolCall: context.onSubToolCall
+  });
+  return tools;
+}
+async function fetchApiToolsMetadata(opts) {
+  const { rpc } = opts;
+  const result = await rpc({ method: "tools.list", params: {} });
+  if ("error" in result) {
+    console.error("[agent] Failed to fetch tools:", result.error?.message);
+    return [];
+  }
+  return result.result ?? [];
+}
+function buildApiTools(opts) {
+  const { rpc, metadata, session, sandboxRecord, context } = opts;
+  const tools = {};
+  for (const meta of metadata) {
+    tools[meta.name] = tool2({
+      description: meta.description ?? `Custom tool: ${meta.name}`,
+      inputSchema: meta.inputSchema ? jsonSchema(meta.inputSchema) : z2.object({}),
+      execute: async (input) => {
+        const result = await rpc({
+          method: "tools.execute",
+          params: {
+            name: meta.name,
+            input,
+            session,
+            sandboxRecord,
+            context
+          }
+        });
+        if ("error" in result) {
+          throw new Error(`Tool execution failed: ${result.error?.message}`);
+        }
+        return result.result;
+      }
+    });
+  }
+  return tools;
+}
+function resolveApiUrl(opts) {
+  let origin = "";
+  let path = `/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;
+  if (opts.api) {
+    if (opts.api.startsWith("/")) {
+      path = opts.api;
+    } else {
+      try {
+        const url = new URL(opts.api);
+        origin = url.origin;
+        const fullPath = url.pathname + url.search + url.hash;
+        if (fullPath.startsWith("/") && fullPath !== "/") {
+          path = fullPath;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!origin) {
+    if (process.env.NODE_ENV === "development") {
+      origin = `http://localhost:${process.env.PORT ?? process.env.NEXT_PUBLIC_PORT ?? 3e3}`;
+    }
+    const vercelUrl = process.env.VERCEL_URL ?? process.env.NEXT_PUBLIC_VERCEL_URL;
+    if (vercelUrl) {
+      origin = `https://${vercelUrl}`;
+    }
+  }
+  if (!origin) {
+    throw new Error(
+      "[agent] Couldn't determine API origin (no origin detected in `api` option and no VERCEL_URL set)"
+    );
+  }
+  return `${origin}${path}`;
+}
+
+// src/utils/prompt-cache.ts
+var ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST = 4;
+var CLAUDE_LIKE_MODEL_MATCHERS = ["claude", "anthropic"];
+var CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS = {
+  anthropic: {
+    cacheControl: { type: "ephemeral" }
+  },
+  openrouter: {
+    cacheControl: { type: "ephemeral" }
+  },
+  bedrock: {
+    cachePoint: { type: "default" }
+  },
+  openaiCompatible: {
+    cache_control: { type: "ephemeral" }
+  },
+  copilot: {
+    copilot_cache_control: { type: "ephemeral" }
+  }
+};
+function getGatewayProvider(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  return model.slice(0, slashIndex);
+}
+function countAnthropicCacheBreakpoints(messages) {
+  let count = 0;
+  for (const message of messages) {
+    const providerOptions = message.providerOptions;
+    if (providerOptions?.anthropic?.cacheControl) {
+      count += 1;
+    }
+    if (Array.isArray(message.content)) {
+      for (const part of message.content) {
+        const partProviderOptions = part.providerOptions;
+        if (partProviderOptions?.anthropic?.cacheControl) {
+          count += 1;
+        }
+      }
+    }
+  }
+  return count;
+}
+function isClaudeLikeModel(model) {
+  const lower = model.toLowerCase();
+  return CLAUDE_LIKE_MODEL_MATCHERS.some((m) => lower.includes(m));
+}
+function mergeProviderOptions(opts) {
+  const next = { ...opts.current ?? {} };
+  for (const [key, value] of Object.entries(opts.patch)) {
+    next[key] = { ...next[key] ?? {}, ...value };
+  }
+  return next;
+}
+function isCacheableClaudePart(part) {
+  if (!part || typeof part !== "object") {
+    return false;
+  }
+  if ("type" in part && part.type === "text") {
+    const text = part.text;
+    if (typeof text === "string") {
+      return text.trim().length > 0;
+    }
+  }
+  if ("type" in part) {
+    const type = part.type;
+    if (type === "thinking" || type === "reasoning") {
+      return false;
+    }
+  }
+  return true;
+}
+function hasCacheableContent(message) {
+  if (typeof message.content === "string") {
+    return message.content.trim().length > 0;
+  }
+  if (Array.isArray(message.content)) {
+    return message.content.some((part) => isCacheableClaudePart(part));
+  }
+  return false;
+}
+function findLastCacheablePartIndex(content) {
+  for (let i = content.length - 1; i >= 0; i -= 1) {
+    if (isCacheableClaudePart(content[i])) {
+      return i;
+    }
+  }
+  return null;
+}
+function selectClaudeCachingTargets(messages) {
+  const systemIndices = [];
+  const finalIndices = [];
+  for (let i = 0; i < messages.length && systemIndices.length < 2; i += 1) {
+    const message = messages[i];
+    if (message.role === "system" && hasCacheableContent(message)) {
+      systemIndices.push(i);
+    }
+  }
+  for (let i = messages.length - 1; i >= 0 && finalIndices.length < 2; i -= 1) {
+    const message = messages[i];
+    if (message.role !== "system" && hasCacheableContent(message)) {
+      finalIndices.push(i);
+    }
+  }
+  finalIndices.reverse();
+  return [...systemIndices, ...finalIndices];
+}
+function applyClaudePromptCaching(opts) {
+  const existingBreakpoints = countAnthropicCacheBreakpoints(opts.messages);
+  const remainingBudget = Math.max(
+    0,
+    opts.maxBreakpointsPerRequest - existingBreakpoints
+  );
+  if (remainingBudget === 0) {
+    return opts.messages;
+  }
+  const targetIndices = selectClaudeCachingTargets(opts.messages).slice(
+    0,
+    remainingBudget
+  );
+  if (targetIndices.length === 0) {
+    return opts.messages;
+  }
+  const useMessageLevelOptions = opts.providerId === "anthropic" || Boolean(opts.providerId?.includes("bedrock"));
+  const nextMessages = opts.messages.slice();
+  for (const messageIndex of targetIndices) {
+    const message = nextMessages[messageIndex];
+    const shouldUseContentOptions = !useMessageLevelOptions && Array.isArray(message.content) && message.content.length > 0;
+    if (shouldUseContentOptions && Array.isArray(message.content)) {
+      const partIndex = findLastCacheablePartIndex(message.content);
+      if (partIndex !== null) {
+        const part = message.content[partIndex];
+        if (part && typeof part === "object") {
+          const partProviderOptions = part.providerOptions;
+          const nextContent = message.content.slice();
+          nextContent[partIndex] = {
+            ...part,
+            providerOptions: mergeProviderOptions({
+              current: partProviderOptions,
+              patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS
+            })
+          };
+          nextMessages[messageIndex] = {
+            ...message,
+            content: nextContent
+          };
+          continue;
+        }
+      }
+    }
+    const messageProviderOptions = message.providerOptions;
+    nextMessages[messageIndex] = {
+      ...message,
+      providerOptions: mergeProviderOptions({
+        current: messageProviderOptions,
+        patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS
+      })
+    };
+  }
+  return nextMessages;
+}
+function applyPromptCachingToModelRequest(opts) {
+  const provider = getGatewayProvider(opts.model);
+  const providerOptions = {};
+  if ((provider === "openai" || provider === "azure") && opts.openai?.setPromptCacheKey !== false) {
+    providerOptions.openai = { promptCacheKey: opts.sessionId };
+  }
+  const maxBreakpointsPerRequest = opts.anthropic?.maxBreakpointsPerRequest ?? ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST;
+  const cachedMessages = isClaudeLikeModel(opts.model) ? applyClaudePromptCaching({
+    messages: opts.messages,
+    providerId: provider,
+    maxBreakpointsPerRequest
+  }) : opts.messages;
+  return {
+    messages: cachedMessages,
+    providerOptions
+  };
+}
+
+// src/utils/ui.ts
+function isSubToolPart(part) {
+  const p = part.part;
+  return typeof p?.toolCallId === "string" && p.toolCallId.startsWith("js_tc_");
+}
+function assembleUIMessages(opts) {
+  let filtered = opts.messages;
+  if (opts.until !== void 0) {
+    const until = opts.until;
+    filtered = filtered.filter((m) => m.createdAt <= until);
+  }
+  if (!opts.includeQueued) {
+    filtered = filtered.filter((m) => m.startedAt !== null);
+  }
+  const parts = opts.excludeSubToolParts ? opts.parts.filter((p) => !isSubToolPart(p)) : opts.parts;
+  const partsByMessage = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    const existing = partsByMessage.get(part.messageId) ?? [];
+    existing.push(part);
+    partsByMessage.set(part.messageId, existing);
+  }
+  return filtered.map((m) => {
+    const messageParts = partsByMessage.get(m.id) ?? [];
+    messageParts.sort((a, b) => a.index - b.index);
+    return {
+      id: m.id,
+      role: m.role,
+      parts: messageParts.map((p) => p.part)
+    };
+  }).filter((m) => m.parts.length > 0);
+}
+
+// src/utils/usage.ts
+function sum(items, key) {
+  return items.reduce((acc, item) => {
+    const value = item[key];
+    return acc + (typeof value === "number" ? value : 0);
+  }, 0);
+}
+function computeUsageSummary(steps) {
+  return {
+    model: steps[0]?.model ?? "unknown",
+    inputTokens: sum(steps, "inputTokens"),
+    outputTokens: sum(steps, "outputTokens"),
+    totalTokens: sum(steps, "totalTokens"),
+    cacheReadTokens: sum(steps, "cacheReadTokens"),
+    cacheWriteTokens: sum(steps, "cacheWriteTokens"),
+    reasoningTokens: sum(steps, "reasoningTokens"),
+    stepCount: steps.length
+  };
+}
+function computeSessionUsage(messages) {
+  const byMessageId = {};
+  for (const m of messages) {
+    byMessageId[m.id] = m.usage?.summary ?? null;
+  }
+  const summaries = messages.map((m) => m.usage?.summary).filter((s) => s !== void 0);
+  const total = {
+    model: summaries[0]?.model ?? "unknown",
+    inputTokens: summaries.reduce((acc, s) => acc + s.inputTokens, 0),
+    outputTokens: summaries.reduce((acc, s) => acc + s.outputTokens, 0),
+    totalTokens: summaries.reduce((acc, s) => acc + s.totalTokens, 0),
+    cacheReadTokens: summaries.reduce((acc, s) => acc + s.cacheReadTokens, 0),
+    cacheWriteTokens: summaries.reduce((acc, s) => acc + s.cacheWriteTokens, 0),
+    reasoningTokens: summaries.reduce((acc, s) => acc + s.reasoningTokens, 0),
+    stepCount: summaries.reduce((acc, s) => acc + s.stepCount, 0),
+    messageCount: summaries.length
+  };
+  return { total, byMessageId };
+}
+
+// src/agent-workflow-steps.ts
+function emitStatus({
+  writer,
+  status,
+  rpc
+}) {
+  writer?.({ type: "data-status", data: status, transient: true });
+  rpc({ method: "hook.status", params: { status } }).catch(() => {
+  });
+}
+var BASE_SYSTEM_PROMPT = "You are an AI assistant with basic tools to interact with your environment. Explore and work freely.";
+function joinPromptSections(...sections) {
+  return sections.filter((s) => s?.trim()).join("\n\n");
+}
+var backgroundProcessPrompt = `## Background Processes
+These background process instructions are for you to manipulate the processes, do not be to verbose to the user about the response details like "how to debug the process output" the user will have an UI.
+
+Use \`waitUntil: 0\` for dev servers that should run indefinitely.
+It is a good practice to check the output log after running processes like dev servers to make sure they started correctly.
+
+To run a background process:
+Bash({ command: "npm run dev", waitUntil: 0 })
+Returns immediately with \`pid\` and \`outputFile\` path.
+
+To check a process's output:
+Bash({ command: "tail -100 {outputFile}" })
+
+To kill a process:
+Bash({ command: "kill {pid}" })       // Graceful
+Bash({ command: "kill -9 {pid}" })    // Force
+
+To list all processes:
+Bash({ command: "ps aux | grep node" })
+`;
+function buildSkillsContext(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const skillLines = skills.map((s) => `- ${s.name}: ${s.description}
+  Path: ${s.skillMdPath}`).join("\n");
+  return `## Available Skills
+${skillLines}
+
+${backgroundProcessPrompt}
+
+You can use the Read tool to read any skill's SKILL.md file to learn more about it.`;
+}
+async function completeMessageStep({
+  assistantMessageId,
+  input,
+  writable,
+  usageSteps
+}) {
+  "use step";
+  const { getStorage } = await import("./client-YUU54ZZH.mjs");
+  const storage = getStorage({ config: input.storageConfig, rpc: input.rpc });
+  const message = await storage.message.get(assistantMessageId);
+  if (message instanceof Error) {
+    throw message;
+  }
+  if (!message) {
+    throw new Error(`Message ${assistantMessageId} not found`);
+  }
+  const usage = usageSteps.length > 0 ? {
+    steps: usageSteps,
+    summary: computeUsageSummary(usageSteps)
+  } : null;
+  const result = await storage.message.set({
+    ...message,
+    completedAt: Date.now(),
+    usage
+  });
+  if (result instanceof Error) {
+    throw result;
+  }
+  await writable.close();
+}
+var INTERRUPT_POLL_INTERVAL_MS = 500;
+function pollForInterrupt({
+  storage,
+  messageId,
+  signal,
+  abortController
+}) {
+  let resolveFirstCheck;
+  const firstCheck = new Promise((resolve) => {
+    resolveFirstCheck = resolve;
+  });
+  const poll = async () => {
+    let isFirst = true;
+    while (!signal.aborted) {
+      const message = await storage.message.get(messageId);
+      if (message instanceof Error) {
+        if (isFirst) {
+          resolveFirstCheck();
+        }
+        return;
+      }
+      if (message.interruptedAt !== null) {
+        abortController.abort();
+        if (isFirst) {
+          resolveFirstCheck();
+        }
+        return;
+      }
+      if (isFirst) {
+        isFirst = false;
+        resolveFirstCheck();
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)
+      );
+    }
+  };
+  poll();
+  return { firstCheck };
+}
+async function streamTextStep({
+  assistantMessageId,
+  input,
+  event,
+  writable,
+  lastPartIndex,
+  stepIndexOffset
+}) {
+  "use step";
+  const { getStorage } = await import("./client-YUU54ZZH.mjs");
+  const { getSandbox } = await import("./sandbox-GPCA35PJ.mjs");
+  const rpc = input.rpc;
+  const storage = getStorage({ config: input.storageConfig, rpc });
+  const abortController = new AbortController();
+  const pollController = new AbortController();
+  const { firstCheck } = pollForInterrupt({
+    storage,
+    messageId: assistantMessageId,
+    signal: pollController.signal,
+    abortController
+  });
+  const [
+    ,
+    messagesResult,
+    partsResult,
+    { session, sandbox, sandboxRecord },
+    apiToolsMetadata
+  ] = await Promise.all([
+    firstCheck,
+    storage.message.list(input.sessionId),
+    storage.part.listBySession(input.sessionId),
+    storage.session.get(input.sessionId).then(async (session2) => {
+      if (session2 instanceof Error) {
+        throw session2;
+      }
+      const sandboxRecord2 = session2.sandboxId ? await storage.sandbox.get(session2.sandboxId) : null;
+      if (sandboxRecord2 instanceof Error) {
+        throw sandboxRecord2;
+      }
+      if (!sandboxRecord2) {
+        throw new FatalError(
+          `Sandbox not found for session ${input.sessionId}`
+        );
+      }
+      const sandbox2 = getSandbox({
+        sandboxRecord: sandboxRecord2,
+        storageConfig: input.storageConfig,
+        storage
+      });
+      return { session: session2, sandbox: sandbox2, sandboxRecord: sandboxRecord2 };
+    }),
+    fetchApiToolsMetadata({
+      rpc
+    })
+  ]);
+  if (abortController.signal.aborted) {
+    pollController.abort();
+    return {
+      finishReason: "stop",
+      lastPartIndex,
+      usageSteps: [],
+      pendingApprovals: [],
+      maxSteps: void 0
+    };
+  }
+  if (messagesResult instanceof Error) {
+    throw messagesResult;
+  }
+  if (partsResult instanceof Error) {
+    throw partsResult;
+  }
+  const setStartedPromise = lastPartIndex === 0 ? (async () => {
+    const now = Date.now();
+    const pendingMessages = messagesResult.items.filter(
+      (m) => m.createdAt <= event.createdAt && m.startedAt === null
+    );
+    if (pendingMessages.length > 0) {
+      return await Promise.all(
+        pendingMessages.map(
+          (m) => storage.message.set({
+            ...m,
+            startedAt: now,
+            completedAt: m.role === "assistant" ? null : now
+          })
+        )
+      );
+    }
+  })() : null;
+  const streamWriterRef = { current: null };
+  const subToolPartIds = [];
+  let nextPartIndex = lastPartIndex;
+  const onSubToolCall = async (toolName, toolInput, execute) => {
+    const res = await rpc({
+      method: "tools.needsApproval",
+      params: {
+        toolName,
+        input: toolInput,
+        toolCallId: `js_${toolName}_${Date.now()}`,
+        messages: []
+      }
+    });
+    if ("error" in res || res.result !== true) {
+      try {
+        const result2 = await execute();
+        return { result: result2 };
+      } catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+    const approvalId = `js_approval_${ulid()}`;
+    const toolCallId = `js_tc_${ulid()}`;
+    const partId = `part_${ulid()}`;
+    subToolPartIds.push(partId);
+    await storage.part.set({
+      id: partId,
+      index: nextPartIndex++,
+      messageId: assistantMessageId,
+      sessionId: input.sessionId,
+      part: {
+        type: `tool-${toolName}`,
+        toolCallId,
+        state: "approval-requested",
+        input: toolInput,
+        approval: { id: approvalId }
+      }
+    });
+    streamWriterRef.current?.({
+      type: "tool-input-start",
+      toolCallId,
+      toolName
+    });
+    streamWriterRef.current?.({
+      type: "tool-input-available",
+      toolCallId,
+      toolName,
+      input: toolInput
+    });
+    streamWriterRef.current?.({
+      type: "tool-approval-request",
+      approvalId,
+      toolCallId
+    });
+    const POLL_MS = 500;
+    const TIMEOUT_MS = 5 * 60 * 1e3;
+    const start = Date.now();
+    while (Date.now() - start < TIMEOUT_MS) {
+      const parts = await storage.part.listBySession(input.sessionId);
+      if (!(parts instanceof Error)) {
+        const updated = parts.items.find(
+          (p) => p.id === partId && "state" in p.part && p.part.state === "approval-responded"
+        );
+        if (updated) {
+          const approval = updated.part.approval;
+          if (approval?.approved) {
+            try {
+              const result2 = await execute();
+              streamWriterRef.current?.({
+                type: "tool-output-available",
+                toolCallId,
+                output: result2
+              });
+              return { result: result2 };
+            } catch (err) {
+              const error = err instanceof Error ? err.message : String(err);
+              streamWriterRef.current?.({
+                type: "tool-output-error",
+                toolCallId,
+                errorText: error
+              });
+              return { error };
+            }
+          }
+          streamWriterRef.current?.({
+            type: "tool-output-denied",
+            toolCallId
+          });
+          return {
+            error: `Tool "${toolName}" denied: ${approval?.reason || "user denied"}`
+          };
+        }
+      }
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+    return { error: "Approval timed out" };
+  };
+  const rawTools = getTools({
+    input,
+    event,
+    sandbox,
+    session,
+    sandboxRecord,
+    apiToolsMetadata,
+    onSubToolCall
+  });
+  if (!session.model) {
+    throw new FatalError("Session model is not set");
+  }
+  const allParts = partsResult.items;
+  const usageSteps = [];
+  let internalStepIndex = 0;
+  const tools = Object.fromEntries(
+    Object.entries(rawTools).map(([name, t]) => [
+      name,
+      {
+        ...t,
+        needsApproval: async (toolInput, opts) => {
+          const res = await rpc({
+            method: "tools.needsApproval",
+            params: {
+              toolName: name,
+              input: toolInput,
+              toolCallId: opts.toolCallId,
+              messages: opts.messages
+            }
+          });
+          if ("error" in res) {
+            throw new Error(
+              `tools.needsApproval RPC failed for ${name}: ${res.error.message}`
+            );
+          }
+          return res.result;
+        }
+      }
+    ])
+  );
+  let skillsRef = [];
+  const result = streamText({
+    // Placeholder to pass validation — prepareStep replaces messages entirely.
+    messages: [{ role: "user", content: "." }],
+    tools,
+    model: session.model,
+    abortSignal: abortController.signal,
+    activeTools: session.activeTools ?? void 0,
+    stopWhen: stepCountIs(1),
+    temperature: session.generation?.temperature,
+    topK: session.generation?.topK,
+    topP: session.generation?.topP,
+    frequencyPenalty: session.generation?.frequencyPenalty,
+    presencePenalty: session.generation?.presencePenalty,
+    maxOutputTokens: session.generation?.maxOutputTokens,
+    headers: session.generation?.headers,
+    experimental_context: {
+      session,
+      sandbox,
+      storage,
+      context: event.context
+    },
+    prepareStep: async ({ model }) => {
+      if (lastPartIndex === 0) {
+        if (sandbox._setupMeta) {
+          const meta = await sandbox._setupMeta;
+          emitStatus({
+            writer: streamWriterRef.current,
+            status: meta.needsSetupRun ? { type: "sandbox-setup-cold" } : { type: "sandbox-setup" },
+            rpc
+          });
+        }
+        if (sandbox._onReady) {
+          await sandbox._onReady;
+        }
+        emitStatus({
+          writer: streamWriterRef.current,
+          status: { type: "loading-skills" },
+          rpc
+        });
+        const skills = await discoverSkillsInSandbox({
+          sandbox,
+          skillsDirs: session.skillsDir || [],
+          debug: true
+        });
+        skillsRef = skills;
+      }
+      const approvedParts = allParts.filter(
+        (p) => p.part && "state" in p.part && p.part.state === "approval-responded" && "approval" in p.part && p.part.approval?.approved === true
+      );
+      if (approvedParts.length > 0) {
+        emitStatus({
+          writer: streamWriterRef.current,
+          status: { type: "processing-approvals" },
+          rpc
+        });
+        const preExecMessages = await convertToModelMessages(
+          assembleUIMessages({
+            messages: messagesResult.items,
+            parts: allParts,
+            until: event.createdAt,
+            includeQueued: true,
+            excludeSubToolParts: true
+          }),
+          { ignoreIncompleteToolCalls: true }
+        );
+        await Promise.all(
+          approvedParts.map(async (ap) => {
+            if (!ap.part.type.startsWith("tool-")) {
+              return;
+            }
+            const part = ap.part;
+            const toolName = part.type.replace("tool-", "");
+            const toolDef = rawTools[toolName];
+            if (toolDef?.execute && part.input !== void 0) {
+              try {
+                const toolOutput = await toolDef.execute(part.input, {
+                  toolCallId: part.toolCallId,
+                  messages: preExecMessages,
+                  abortSignal: abortController.signal,
+                  experimental_context: {
+                    session,
+                    sandbox,
+                    storage,
+                    context: event.context
+                  }
+                });
+                part.state = "output-available";
+                part.output = toolOutput;
+                streamWriterRef.current?.({
+                  type: "tool-output-available",
+                  toolCallId: part.toolCallId,
+                  output: toolOutput
+                });
+              } catch (err) {
+                part.state = "output-error";
+                part.errorText = err instanceof Error ? err.message : String(err);
+                streamWriterRef.current?.({
+                  type: "tool-output-error",
+                  toolCallId: part.toolCallId,
+                  errorText: part.errorText
+                });
+              }
+              await storage.part.set({ ...ap, part });
+            }
+          })
+        );
+      }
+      emitStatus({
+        writer: streamWriterRef.current,
+        status: { type: "thinking" },
+        rpc
+      });
+      const skillsContext = buildSkillsContext(skillsRef);
+      const systemHeader = joinPromptSections(
+        BASE_SYSTEM_PROMPT,
+        session.system
+      );
+      const systemContext = joinPromptSections(skillsContext);
+      const systemMessages = [
+        ...systemHeader.trim() ? [{ role: "system", content: systemHeader }] : [],
+        ...systemContext.trim() ? [{ role: "system", content: systemContext }] : []
+      ];
+      const uiMessages = assembleUIMessages({
+        messages: messagesResult.items,
+        parts: allParts,
+        until: event.createdAt,
+        includeQueued: true,
+        excludeSubToolParts: true
+      });
+      const modelMessages = [
+        ...systemMessages,
+        ...await convertToModelMessages(uiMessages, {
+          ignoreIncompleteToolCalls: true
+        })
+      ];
+      const promptCaching = applyPromptCachingToModelRequest({
+        model: typeof model === "string" ? model : model.modelId,
+        sessionId: input.sessionId,
+        messages: modelMessages
+      });
+      return {
+        messages: promptCaching.messages,
+        providerOptions: promptCaching.providerOptions
+      };
+    },
+    onStepFinish: ({ usage }) => {
+      if (usage) {
+        usageSteps.push({
+          stepIndex: stepIndexOffset + internalStepIndex,
+          model: session.model ?? "unknown",
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          totalTokens: usage.totalTokens ?? 0,
+          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+          cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+          reasoningTokens: usage.outputTokenDetails?.reasoningTokens ?? 0
+        });
+      }
+      internalStepIndex++;
+    }
+  });
+  const stepParts = [];
+  let wasAborted = false;
+  try {
+    const stream = createUIMessageStream({
+      execute: ({ writer }) => {
+        streamWriterRef.current = (event2) => writer.write(event2);
+        writer.merge(
+          result.toUIMessageStream({
+            generateMessageId: () => assistantMessageId,
+            onFinish: ({ messages }) => {
+              let hasApprovals = false;
+              for (const m of messages) {
+                if (m.role === "assistant") {
+                  stepParts.push(...m.parts);
+                  for (const p of m.parts) {
+                    if ("state" in p && p.state === "approval-requested") {
+                      hasApprovals = true;
+                    }
+                  }
+                }
+              }
+              if (hasApprovals) {
+                emitStatus({
+                  writer: streamWriterRef.current,
+                  status: { type: "needs-approval" },
+                  rpc
+                });
+              }
+            }
+          })
+        );
+      }
+    });
+    await stream.pipeTo(writable, { preventClose: true });
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      wasAborted = true;
+    } else {
+      console.error("[streamTextStep] stream error:", err);
+      throw err;
+    }
+  } finally {
+    pollController.abort();
+  }
+  await Promise.all(
+    stepParts.map(async (uiPart) => {
+      const result2 = await storage.part.set({
+        id: `part_${ulid()}`,
+        index: nextPartIndex++,
+        messageId: assistantMessageId,
+        sessionId: input.sessionId,
+        part: uiPart
+      });
+      if (result2 instanceof Error) {
+        throw result2;
+      }
+      return result2;
+    })
+  );
+  if (setStartedPromise) {
+    const setStartedResult = await setStartedPromise;
+    if (setStartedResult instanceof Error) {
+      throw setStartedResult;
+    }
+    for (const m of setStartedResult ?? []) {
+      if (m instanceof Error) {
+        throw m;
+      }
+    }
+  }
+  const pendingApprovals = stepParts.filter(
+    (p) => "state" in p && p.state === "approval-requested" && "approval" in p && !!p.approval?.id
+  ).map((p) => ({
+    approvalId: p.approval.id,
+    toolName: "type" in p ? String(p.type).replace("tool-", "") : "unknown"
+  }));
+  const finalFinishReason = wasAborted ? "stop" : await result.finishReason;
+  return {
+    finishReason: finalFinishReason,
+    lastPartIndex: nextPartIndex,
+    usageSteps,
+    pendingApprovals,
+    maxSteps: session.generation?.maxSteps
+  };
+}
+
+// src/agent-workflow.ts
+var agentMessageHook = defineHook();
+var approvalHook = defineHook();
+async function agentWorkflow({
+  input,
+  event
+}) {
+  "use workflow";
+  const messageHook = agentMessageHook.create({ token: input.sessionId });
+  const iterator = messageHook[Symbol.asyncIterator]();
+  let pendingNext = iterator.next();
+  await onMessage({ event, input }).catch((e) => {
+    if (FatalError2.is(e)) {
+      console.error("Message processing failed permanently:", e.message);
+      return;
+    }
+    throw e;
+  });
+  while (true) {
+    const result = await pendingNext;
+    if (result.done) {
+      console.error("Unexpected: message hook iterator done");
+      break;
+    }
+    await onMessage({ event: result.value, input }).catch((e) => {
+      if (FatalError2.is(e)) {
+        console.error("Message processing failed permanently:", e.message);
+        return;
+      }
+      throw e;
+    });
+    pendingNext = iterator.next();
+  }
+}
+async function onMessage({
+  event,
+  input
+}) {
+  const writable = getWritable({ namespace: event.assistantMessageId });
+  let finishReason;
+  let lastPartIndex = 0;
+  const usageSteps = [];
+  while (finishReason !== "stop") {
+    try {
+      const result = await streamTextStep({
+        assistantMessageId: event.assistantMessageId,
+        writable,
+        input,
+        event,
+        lastPartIndex,
+        stepIndexOffset: usageSteps.length
+      });
+      finishReason = result.finishReason;
+      lastPartIndex = result.lastPartIndex;
+      usageSteps.push(...result.usageSteps);
+      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {
+        break;
+      }
+      if (result.pendingApprovals.length > 0) {
+        await Promise.all(
+          result.pendingApprovals.map((pending) => {
+            const hook = approvalHook.create({ token: pending.approvalId });
+            const iter = hook[Symbol.asyncIterator]();
+            return iter.next();
+          })
+        );
+      }
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  }
+  await completeMessageStep({
+    assistantMessageId: event.assistantMessageId,
+    input,
+    writable,
+    usageSteps
+  });
+}
+
+export {
+  normalizeSkillsDirs,
+  builtInTools,
+  builtinToolNames,
+  resolveApiUrl,
+  assembleUIMessages,
+  computeSessionUsage,
+  agentMessageHook,
+  approvalHook,
+  agentWorkflow
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/agent-workflow.ts", "../src/agent-workflow-steps.ts", "../src/skills/parser.ts", "../src/skills/discover.ts", "../src/tools/index.ts", "../src/tools/javascript.ts", "../src/utils/prompt-cache.ts", "../src/utils/ui.ts", "../src/utils/usage.ts"],
  "sourcesContent": ["import type { FinishReason } from \"ai\";\nimport { defineHook, FatalError, getWritable } from \"workflow\";\nimport { completeMessageStep, streamTextStep } from \"./agent-workflow-steps\";\nimport type { RpcPayload, RpcResult } from \"./client\";\nimport type { StorageConfig } from \"./storage\";\nimport type { StepUsage } from \"./utils/usage\";\n\nexport type AgentInput = {\n  sessionId: string;\n  storageConfig: StorageConfig;\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n};\n\nexport type AgentMessageInput = {\n  assistantMessageId: string;\n  hookToken: string;\n  createdAt: number;\n  context: Record<string, unknown>;\n};\n\nexport type ApprovalResponse = {\n  approved: boolean;\n  reason?: string;\n};\n\nexport const agentMessageHook = defineHook<AgentMessageInput>();\nexport const approvalHook = defineHook<ApprovalResponse>();\n\nexport async function agentWorkflow({\n  input,\n  event,\n}: {\n  input: AgentInput;\n  event: AgentMessageInput;\n}) {\n  \"use workflow\";\n\n  const messageHook = agentMessageHook.create({ token: input.sessionId });\n  const iterator = messageHook[Symbol.asyncIterator]();\n  let pendingNext = iterator.next();\n\n  await onMessage({ event, input }).catch((e) => {\n    if (FatalError.is(e)) {\n      console.error(\"Message processing failed permanently:\", e.message);\n      return;\n    }\n    throw e;\n  });\n\n  while (true) {\n    const result = await pendingNext;\n\n    if (result.done) {\n      console.error(\"Unexpected: message hook iterator done\");\n      break;\n    }\n\n    await onMessage({ event: result.value, input }).catch((e) => {\n      if (FatalError.is(e)) {\n        console.error(\"Message processing failed permanently:\", e.message);\n        return;\n      }\n      throw e;\n    });\n    pendingNext = iterator.next();\n  }\n}\n\nasync function onMessage({\n  event,\n  input,\n}: {\n  event: AgentMessageInput;\n  input: AgentInput;\n}) {\n  const writable = getWritable({ namespace: event.assistantMessageId });\n\n  let finishReason: FinishReason | undefined;\n  let lastPartIndex = 0;\n  const usageSteps: StepUsage[] = [];\n\n  while (finishReason !== \"stop\") {\n    try {\n      const result = await streamTextStep({\n        assistantMessageId: event.assistantMessageId,\n        writable,\n        input,\n        event,\n        lastPartIndex,\n        stepIndexOffset: usageSteps.length,\n      });\n      finishReason = result.finishReason;\n      lastPartIndex = result.lastPartIndex;\n      usageSteps.push(...result.usageSteps);\n\n      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {\n        break;\n      }\n\n      // If tools need approval, suspend workflow until all are resolved\n      if (result.pendingApprovals.length > 0) {\n        await Promise.all(\n          result.pendingApprovals.map((pending) => {\n            const hook = approvalHook.create({ token: pending.approvalId });\n            const iter = hook[Symbol.asyncIterator]();\n            return iter.next();\n          })\n        );\n        // All hooks resolved \u2014 approval responses are now in storage.\n        // Loop continues \u2192 next streamTextStep reads updated parts.\n      }\n    } catch (err) {\n      console.error(err);\n      throw err;\n    }\n  }\n\n  await completeMessageStep({\n    assistantMessageId: event.assistantMessageId,\n    input,\n    writable,\n    usageSteps,\n  });\n}\n", "import {\n  convertToModelMessages,\n  createUIMessageStream,\n  type FinishReason,\n  stepCountIs,\n  streamText,\n  type UIMessage,\n} from \"ai\";\nimport { ulid } from \"ulid\";\nimport { FatalError } from \"workflow\";\nimport type { AgentInput, AgentMessageInput } from \"./agent-workflow\";\nimport type { AgentStatus, RpcPayload, RpcResult } from \"./client\";\nimport { discoverSkillsInSandbox } from \"./skills/discover\";\nimport type { SkillSummary } from \"./skills/types\";\nimport type { SandboxRecord, Storage } from \"./storage\";\nimport { fetchApiToolsMetadata, getTools } from \"./tools\";\nimport type { OnSubToolCall } from \"./tools/javascript\";\nimport { applyPromptCachingToModelRequest } from \"./utils/prompt-cache\";\nimport { assembleUIMessages } from \"./utils/ui\";\nimport { computeUsageSummary, type StepUsage } from \"./utils/usage\";\n\n/**\n * Fire-and-forget status emission. Writes a transient `data-status` chunk\n * to the stream and calls the `hook.status` RPC. Neither blocks the caller.\n */\nfunction emitStatus({\n  writer,\n  status,\n  rpc,\n}: {\n  writer: ((event: unknown) => void) | null;\n  status: AgentStatus;\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n}) {\n  writer?.({ type: \"data-status\", data: status, transient: true });\n  // biome-ignore lint/suspicious/noEmptyBlockStatements: fire-and-forget\n  rpc({ method: \"hook.status\", params: { status } }).catch(() => {});\n}\n\nconst BASE_SYSTEM_PROMPT =\n  \"You are an AI assistant with basic tools to interact with your environment. Explore and work freely.\";\n\nfunction joinPromptSections(\n  ...sections: (string | undefined | null)[]\n): string {\n  return sections.filter((s) => s?.trim()).join(\"\\n\\n\");\n}\n\nconst backgroundProcessPrompt = `## Background Processes\nThese background process instructions are for you to manipulate the processes, do not be to verbose to the user about the response details like \"how to debug the process output\" the user will have an UI.\n\nUse \\`waitUntil: 0\\` for dev servers that should run indefinitely.\nIt is a good practice to check the output log after running processes like dev servers to make sure they started correctly.\n\nTo run a background process:\nBash({ command: \"npm run dev\", waitUntil: 0 })\nReturns immediately with \\`pid\\` and \\`outputFile\\` path.\n\nTo check a process's output:\nBash({ command: \"tail -100 {outputFile}\" })\n\nTo kill a process:\nBash({ command: \"kill {pid}\" })       // Graceful\nBash({ command: \"kill -9 {pid}\" })    // Force\n\nTo list all processes:\nBash({ command: \"ps aux | grep node\" })\n`;\n\nfunction buildSkillsContext(skills: SkillSummary[]): string {\n  if (skills.length === 0) {\n    return \"\";\n  }\n\n  const skillLines = skills\n    .map((s) => `- ${s.name}: ${s.description}\\n  Path: ${s.skillMdPath}`)\n    .join(\"\\n\");\n\n  return `## Available Skills\n${skillLines}\n\n${backgroundProcessPrompt}\n\nYou can use the Read tool to read any skill's SKILL.md file to learn more about it.`;\n}\n\nexport async function completeMessageStep({\n  assistantMessageId,\n  input,\n  writable,\n  usageSteps,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  writable: WritableStream;\n  usageSteps: StepUsage[];\n}) {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const storage = getStorage({ config: input.storageConfig, rpc: input.rpc });\n\n  const message = await storage.message.get(assistantMessageId);\n  if (message instanceof Error) {\n    throw message;\n  }\n  if (!message) {\n    throw new Error(`Message ${assistantMessageId} not found`);\n  }\n\n  const usage =\n    usageSteps.length > 0\n      ? {\n          steps: usageSteps,\n          summary: computeUsageSummary(usageSteps),\n        }\n      : null;\n\n  const result = await storage.message.set({\n    ...message,\n    completedAt: Date.now(),\n    usage,\n  });\n  if (result instanceof Error) {\n    throw result;\n  }\n\n  await writable.close();\n}\n\nconst INTERRUPT_POLL_INTERVAL_MS = 500;\n\nfunction pollForInterrupt({\n  storage,\n  messageId,\n  signal,\n  abortController,\n}: {\n  storage: Storage;\n  messageId: string;\n  signal: AbortSignal;\n  abortController: AbortController;\n}): { firstCheck: Promise<void> } {\n  let resolveFirstCheck: () => void;\n  const firstCheck = new Promise<void>((resolve) => {\n    resolveFirstCheck = resolve;\n  });\n\n  const poll = async () => {\n    let isFirst = true;\n    while (!signal.aborted) {\n      const message = await storage.message.get(messageId);\n      if (message instanceof Error) {\n        if (isFirst) {\n          resolveFirstCheck();\n        }\n        return;\n      }\n      if (message.interruptedAt !== null) {\n        abortController.abort();\n        if (isFirst) {\n          resolveFirstCheck();\n        }\n        return;\n      }\n      if (isFirst) {\n        isFirst = false;\n        resolveFirstCheck();\n      }\n      await new Promise((resolve) =>\n        setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)\n      );\n    }\n  };\n\n  poll();\n  return { firstCheck };\n}\n\nexport async function streamTextStep({\n  assistantMessageId,\n  input,\n  event,\n  writable,\n  lastPartIndex,\n  stepIndexOffset,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  event: AgentMessageInput;\n  writable: WritableStream;\n  lastPartIndex: number;\n  stepIndexOffset: number;\n}): Promise<{\n  finishReason: FinishReason;\n  lastPartIndex: number;\n  usageSteps: StepUsage[];\n  pendingApprovals: { approvalId: string; toolName: string }[];\n  maxSteps: number | undefined;\n}> {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const { getSandbox } = await import(\"./sandbox\");\n\n  const rpc = input.rpc;\n  const storage = getStorage({ config: input.storageConfig, rpc });\n\n  const abortController = new AbortController();\n  const pollController = new AbortController();\n\n  const { firstCheck } = pollForInterrupt({\n    storage,\n    messageId: assistantMessageId,\n    signal: pollController.signal,\n    abortController,\n  });\n\n  const [\n    ,\n    messagesResult,\n    partsResult,\n    { session, sandbox, sandboxRecord },\n    apiToolsMetadata,\n  ] = await Promise.all([\n    firstCheck,\n    storage.message.list(input.sessionId),\n    storage.part.listBySession(input.sessionId),\n    storage.session.get(input.sessionId).then(async (session) => {\n      if (session instanceof Error) {\n        throw session;\n      }\n      const sandboxRecord = session.sandboxId\n        ? await storage.sandbox.get(session.sandboxId)\n        : null;\n      if (sandboxRecord instanceof Error) {\n        throw sandboxRecord;\n      }\n      if (!sandboxRecord) {\n        throw new FatalError(\n          `Sandbox not found for session ${input.sessionId}`\n        );\n      }\n      const sandbox = getSandbox({\n        sandboxRecord,\n        storageConfig: input.storageConfig,\n        storage,\n      });\n\n      return { session, sandbox, sandboxRecord };\n    }),\n    fetchApiToolsMetadata({\n      rpc,\n    }),\n  ]);\n\n  if (abortController.signal.aborted) {\n    pollController.abort();\n    return {\n      finishReason: \"stop\" as FinishReason,\n      lastPartIndex,\n      usageSteps: [],\n      pendingApprovals: [],\n      maxSteps: undefined,\n    };\n  }\n\n  if (messagesResult instanceof Error) {\n    throw messagesResult;\n  }\n  if (partsResult instanceof Error) {\n    throw partsResult;\n  }\n\n  /**\n   * On first iteration, mark all messages in this batch as started.\n   * User messages are also marked as completed (they're done).\n   * The assistant message is only marked as started (streaming in progress).\n   */\n  const setStartedPromise =\n    lastPartIndex === 0\n      ? (async () => {\n          const now = Date.now();\n          const pendingMessages = messagesResult.items.filter(\n            (m) => m.createdAt <= event.createdAt && m.startedAt === null\n          );\n          if (pendingMessages.length > 0) {\n            return await Promise.all(\n              pendingMessages.map((m) =>\n                storage.message.set({\n                  ...m,\n                  startedAt: now,\n                  completedAt: m.role === \"assistant\" ? null : now,\n                })\n              )\n            );\n          }\n        })()\n      : null;\n\n  // Mutable ref so onSubToolCall can write to the stream once available\n  const streamWriterRef: {\n    current: ((event: unknown) => void) | null;\n  } = { current: null };\n\n  const subToolPartIds: string[] = [];\n  // Shared counter for part indices \u2014 sub-tool parts increment this during\n  // the stream, then stepParts continue from where it left off.\n  let nextPartIndex = lastPartIndex;\n\n  const onSubToolCall: OnSubToolCall = async (toolName, toolInput, execute) => {\n    // Check if this tool needs approval via RPC\n    const res = await rpc({\n      method: \"tools.needsApproval\",\n      params: {\n        toolName,\n        input: toolInput,\n        toolCallId: `js_${toolName}_${Date.now()}`,\n        messages: [],\n      },\n    });\n\n    if (\"error\" in res || res.result !== true) {\n      // No approval needed \u2014 just execute\n      try {\n        const result = await execute();\n        return { result };\n      } catch (err) {\n        return { error: err instanceof Error ? err.message : String(err) };\n      }\n    }\n\n    // Approval needed \u2014 surface to user via stream events\n    const approvalId = `js_approval_${ulid()}`;\n    const toolCallId = `js_tc_${ulid()}`;\n    const partId = `part_${ulid()}`;\n    subToolPartIds.push(partId);\n\n    // Store approval-request part\n    await storage.part.set({\n      id: partId,\n      index: nextPartIndex++,\n      messageId: assistantMessageId,\n      sessionId: input.sessionId,\n      part: {\n        type: `tool-${toolName}`,\n        toolCallId,\n        state: \"approval-requested\",\n        input: toolInput,\n        approval: { id: approvalId },\n      } as unknown as UIMessage[\"parts\"][number],\n    });\n\n    // Write stream events for the UI\n    // tool-input-start is required \u2014 the AI SDK client creates the tool part\n    // when it sees this event. Without it, subsequent events are ignored.\n    streamWriterRef.current?.({\n      type: \"tool-input-start\",\n      toolCallId,\n      toolName,\n    });\n    streamWriterRef.current?.({\n      type: \"tool-input-available\",\n      toolCallId,\n      toolName,\n      input: toolInput,\n    });\n    streamWriterRef.current?.({\n      type: \"tool-approval-request\",\n      approvalId,\n      toolCallId,\n    });\n\n    // Poll storage for approval response\n    const POLL_MS = 500;\n    const TIMEOUT_MS = 5 * 60 * 1000;\n    const start = Date.now();\n\n    while (Date.now() - start < TIMEOUT_MS) {\n      const parts = await storage.part.listBySession(input.sessionId);\n      if (!(parts instanceof Error)) {\n        const updated = parts.items.find(\n          (p) =>\n            p.id === partId &&\n            \"state\" in p.part &&\n            (p.part as { state: string }).state === \"approval-responded\"\n        );\n        if (updated) {\n          const approval = (\n            updated.part as {\n              approval?: { approved?: boolean; reason?: string };\n            }\n          ).approval;\n          if (approval?.approved) {\n            try {\n              const result = await execute();\n              streamWriterRef.current?.({\n                type: \"tool-output-available\",\n                toolCallId,\n                output: result,\n              });\n              return { result };\n            } catch (err) {\n              const error = err instanceof Error ? err.message : String(err);\n              streamWriterRef.current?.({\n                type: \"tool-output-error\",\n                toolCallId,\n                errorText: error,\n              });\n              return { error };\n            }\n          }\n          // Denied\n          streamWriterRef.current?.({\n            type: \"tool-output-denied\",\n            toolCallId,\n          });\n          return {\n            error: `Tool \"${toolName}\" denied: ${approval?.reason || \"user denied\"}`,\n          };\n        }\n      }\n      await new Promise((r) => setTimeout(r, POLL_MS));\n    }\n\n    return { error: \"Approval timed out\" };\n  };\n\n  const rawTools = getTools({\n    input,\n    event,\n    sandbox,\n    session,\n    sandboxRecord: sandboxRecord as SandboxRecord,\n    apiToolsMetadata,\n    onSubToolCall,\n  });\n\n  if (!session.model) {\n    throw new FatalError(\"Session model is not set\");\n  }\n\n  const allParts = partsResult.items;\n  const usageSteps: StepUsage[] = [];\n  let internalStepIndex = 0;\n\n  const tools = Object.fromEntries(\n    Object.entries(rawTools).map(([name, t]) => [\n      name,\n      {\n        ...t,\n        needsApproval: async (\n          toolInput: unknown,\n          opts: { toolCallId: string; messages: unknown[] }\n        ) => {\n          const res = await rpc({\n            method: \"tools.needsApproval\",\n            params: {\n              toolName: name,\n              input: toolInput,\n              toolCallId: opts.toolCallId,\n              messages: opts.messages,\n            },\n          });\n          if (\"error\" in res) {\n            throw new Error(\n              `tools.needsApproval RPC failed for ${name}: ${res.error.message}`\n            );\n          }\n          return res.result as boolean;\n        },\n      },\n    ])\n  );\n\n  let skillsRef: SkillSummary[] = [];\n\n  const result = streamText({\n    // Placeholder to pass validation \u2014 prepareStep replaces messages entirely.\n    messages: [{ role: \"user\" as const, content: \".\" }],\n    tools,\n    model: session.model,\n    abortSignal: abortController.signal,\n    activeTools: session.activeTools ?? undefined,\n    stopWhen: stepCountIs(1),\n    temperature: session.generation?.temperature,\n    topK: session.generation?.topK,\n    topP: session.generation?.topP,\n    frequencyPenalty: session.generation?.frequencyPenalty,\n    presencePenalty: session.generation?.presencePenalty,\n    maxOutputTokens: session.generation?.maxOutputTokens,\n    headers: session.generation?.headers,\n    experimental_context: {\n      session,\n      sandbox,\n      storage,\n      context: event.context,\n    },\n    prepareStep: async ({ model }) => {\n      // On the first step, emit sandbox status, await setup, and load skills.\n      // streamWriterRef is set by the createUIMessageStream executor\n      // which runs before prepareStep (after `start` is written).\n      if (lastPartIndex === 0) {\n        if (sandbox._setupMeta) {\n          const meta = await sandbox._setupMeta;\n          emitStatus({\n            writer: streamWriterRef.current,\n            status: meta.needsSetupRun\n              ? { type: \"sandbox-setup-cold\" }\n              : { type: \"sandbox-setup\" },\n            rpc,\n          });\n        }\n        if (sandbox._onReady) {\n          await sandbox._onReady;\n        }\n\n        emitStatus({\n          writer: streamWriterRef.current,\n          status: { type: \"loading-skills\" },\n          rpc,\n        });\n        const skills = await discoverSkillsInSandbox({\n          sandbox,\n          skillsDirs: session.skillsDir || [],\n          debug: true,\n        });\n        skillsRef = skills;\n      }\n\n      // Execute approved tools so the model sees complete tool call + result\n      // pairs. This runs outside the lastPartIndex === 0 gate because\n      // approvals arrive on subsequent messages (lastPartIndex > 0).\n      const approvedParts = allParts.filter(\n        (p) =>\n          p.part &&\n          \"state\" in p.part &&\n          (p.part as { state: string }).state === \"approval-responded\" &&\n          \"approval\" in p.part &&\n          (p.part as { approval?: { approved?: boolean } }).approval\n            ?.approved === true\n      );\n\n      if (approvedParts.length > 0) {\n        emitStatus({\n          writer: streamWriterRef.current,\n          status: { type: \"processing-approvals\" },\n          rpc,\n        });\n\n        // Build context messages for tool execute (incomplete calls filtered out).\n        const preExecMessages = await convertToModelMessages(\n          assembleUIMessages({\n            messages: messagesResult.items,\n            parts: allParts,\n            until: event.createdAt,\n            includeQueued: true,\n            excludeSubToolParts: true,\n          }),\n          { ignoreIncompleteToolCalls: true }\n        );\n\n        await Promise.all(\n          approvedParts.map(async (ap) => {\n            if (!ap.part.type.startsWith(\"tool-\")) {\n              return;\n            }\n            const part = ap.part as Extract<\n              UIMessage[\"parts\"][number],\n              { type: `tool-${string}` }\n            >;\n            const toolName = part.type.replace(\"tool-\", \"\");\n            const toolDef = rawTools[toolName];\n\n            if (toolDef?.execute && part.input !== undefined) {\n              try {\n                const toolOutput = await toolDef.execute(part.input, {\n                  toolCallId: part.toolCallId,\n                  messages: preExecMessages,\n                  abortSignal: abortController.signal,\n                  experimental_context: {\n                    session,\n                    sandbox,\n                    storage,\n                    context: event.context,\n                  },\n                });\n                part.state = \"output-available\";\n                part.output = toolOutput;\n                streamWriterRef.current?.({\n                  type: \"tool-output-available\",\n                  toolCallId: part.toolCallId,\n                  output: toolOutput,\n                });\n              } catch (err) {\n                part.state = \"output-error\";\n                part.errorText =\n                  err instanceof Error ? err.message : String(err);\n                streamWriterRef.current?.({\n                  type: \"tool-output-error\",\n                  toolCallId: part.toolCallId,\n                  errorText: part.errorText,\n                });\n              }\n              await storage.part.set({ ...ap, part });\n            }\n          })\n        );\n      }\n\n      emitStatus({\n        writer: streamWriterRef.current,\n        status: { type: \"thinking\" },\n        rpc,\n      });\n\n      const skillsContext = buildSkillsContext(skillsRef);\n      const systemHeader = joinPromptSections(\n        BASE_SYSTEM_PROMPT,\n        session.system\n      );\n      const systemContext = joinPromptSections(skillsContext);\n      const systemMessages = [\n        ...(systemHeader.trim()\n          ? [{ role: \"system\" as const, content: systemHeader }]\n          : []),\n        ...(systemContext.trim()\n          ? [{ role: \"system\" as const, content: systemContext }]\n          : []),\n      ];\n\n      const uiMessages = assembleUIMessages({\n        messages: messagesResult.items,\n        parts: allParts,\n        until: event.createdAt,\n        includeQueued: true,\n        excludeSubToolParts: true,\n      });\n\n      const modelMessages = [\n        ...systemMessages,\n        ...(await convertToModelMessages(uiMessages, {\n          ignoreIncompleteToolCalls: true,\n        })),\n      ];\n\n      const promptCaching = applyPromptCachingToModelRequest({\n        model: typeof model === \"string\" ? model : model.modelId,\n        sessionId: input.sessionId,\n        messages: modelMessages,\n      });\n\n      return {\n        messages: promptCaching.messages,\n        providerOptions: promptCaching.providerOptions,\n      };\n    },\n    onStepFinish: ({ usage }) => {\n      if (usage) {\n        usageSteps.push({\n          stepIndex: stepIndexOffset + internalStepIndex,\n          model: session.model ?? \"unknown\",\n          inputTokens: usage.inputTokens ?? 0,\n          outputTokens: usage.outputTokens ?? 0,\n          totalTokens: usage.totalTokens ?? 0,\n          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,\n          cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,\n          reasoningTokens: usage.outputTokenDetails?.reasoningTokens ?? 0,\n        });\n      }\n      internalStepIndex++;\n    },\n  });\n\n  const stepParts: UIMessage[\"parts\"] = [];\n  let wasAborted = false;\n\n  try {\n    const stream = createUIMessageStream({\n      execute: ({ writer }) => {\n        streamWriterRef.current = (event: unknown) =>\n          writer.write(event as Parameters<typeof writer.write>[0]);\n\n        // Merge the streamText stream. prepareStep handles sandbox setup,\n        // skills loading, approval execution, and status emission before\n        // the model starts generating.\n        writer.merge(\n          result.toUIMessageStream({\n            generateMessageId: () => assistantMessageId,\n            onFinish: ({ messages }) => {\n              let hasApprovals = false;\n              for (const m of messages) {\n                if (m.role === \"assistant\") {\n                  stepParts.push(...m.parts);\n                  for (const p of m.parts) {\n                    if (\"state\" in p && p.state === \"approval-requested\") {\n                      hasApprovals = true;\n                    }\n                  }\n                }\n              }\n              if (hasApprovals) {\n                emitStatus({\n                  writer: streamWriterRef.current,\n                  status: { type: \"needs-approval\" },\n                  rpc,\n                });\n              }\n            },\n          })\n        );\n      },\n    });\n\n    await stream.pipeTo(writable, { preventClose: true });\n  } catch (err) {\n    if (abortController.signal.aborted) {\n      wasAborted = true;\n    } else {\n      console.error(\"[streamTextStep] stream error:\", err);\n      throw err;\n    }\n  } finally {\n    pollController.abort();\n  }\n\n  await Promise.all(\n    stepParts.map(async (uiPart) => {\n      const result = await storage.part.set({\n        id: `part_${ulid()}`,\n        index: nextPartIndex++,\n        messageId: assistantMessageId,\n        sessionId: input.sessionId,\n        part: uiPart,\n      });\n      if (result instanceof Error) {\n        throw result;\n      }\n      return result;\n    })\n  );\n\n  if (setStartedPromise) {\n    const setStartedResult = await setStartedPromise;\n    if (setStartedResult instanceof Error) {\n      throw setStartedResult;\n    }\n    for (const m of setStartedResult ?? []) {\n      if (m instanceof Error) {\n        throw m;\n      }\n    }\n  }\n\n  const pendingApprovals = stepParts\n    .filter(\n      (p): p is typeof p & { approval: { id: string } } =>\n        \"state\" in p &&\n        p.state === \"approval-requested\" &&\n        \"approval\" in p &&\n        !!(p as { approval?: { id: string } }).approval?.id\n    )\n    .map((p) => ({\n      approvalId: p.approval.id,\n      toolName: \"type\" in p ? String(p.type).replace(\"tool-\", \"\") : \"unknown\",\n    }));\n\n  const finalFinishReason = wasAborted\n    ? (\"stop\" as FinishReason)\n    : await result.finishReason;\n\n  return {\n    finishReason: finalFinishReason,\n    lastPartIndex: nextPartIndex,\n    usageSteps,\n    pendingApprovals,\n    maxSteps: session.generation?.maxSteps,\n  };\n}\n", "import type { SkillsDir } from \"./types\";\n\n/**\n * Parsed frontmatter from a SKILL.md file.\n */\nexport type SkillFrontmatter = {\n  name: string;\n  description: string;\n};\n\n/**\n * Parses YAML frontmatter from a SKILL.md file content.\n * Frontmatter must be at the start of the file, delimited by `---` markers.\n *\n * @example\n * ```markdown\n * ---\n * name: csv\n * description: Analyze CSV data\n * ---\n * # CSV Skill\n * ...\n * ```\n *\n * @returns Parsed name and description, or null if frontmatter is missing/invalid\n */\nexport function parseSkillFrontmatter(\n  content: string\n): SkillFrontmatter | null {\n  const trimmed = content.trim();\n\n  if (!trimmed.startsWith(\"---\")) {\n    return null;\n  }\n\n  const endMarkerIndex = trimmed.indexOf(\"---\", 3);\n  if (endMarkerIndex === -1) {\n    return null;\n  }\n\n  const frontmatterBlock = trimmed.slice(3, endMarkerIndex).trim();\n  const parsed = parseSimpleYaml(frontmatterBlock);\n\n  if (!(parsed.name && parsed.description)) {\n    return null;\n  }\n\n  return {\n    name: String(parsed.name),\n    description: String(parsed.description),\n  };\n}\n\n/**\n * Parses simple YAML key-value pairs (single-line values only).\n * This avoids adding a full YAML parser dependency for basic frontmatter.\n */\nfunction parseSimpleYaml(yaml: string): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  for (const line of yaml.split(\"\\n\")) {\n    const trimmedLine = line.trim();\n    if (!trimmedLine || trimmedLine.startsWith(\"#\")) {\n      continue;\n    }\n\n    const colonIndex = trimmedLine.indexOf(\":\");\n    if (colonIndex === -1) {\n      continue;\n    }\n\n    const key = trimmedLine.slice(0, colonIndex).trim();\n    let value = trimmedLine.slice(colonIndex + 1).trim();\n\n    // Remove surrounding quotes if present\n    if (\n      (value.startsWith('\"') && value.endsWith('\"')) ||\n      (value.startsWith(\"'\") && value.endsWith(\"'\"))\n    ) {\n      value = value.slice(1, -1);\n    }\n\n    if (key) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Normalizes skillsDir to an array of strings.\n */\nexport function normalizeSkillsDirs(skillsDir?: SkillsDir): string[] {\n  if (!skillsDir) {\n    return [];\n  }\n  return Array.isArray(skillsDir) ? skillsDir : [skillsDir];\n}\n", "import type { Sandbox } from \"../sandbox\";\nimport { parseSkillFrontmatter } from \"./parser\";\nimport type { SkillSummary } from \"./types\";\n\n/**\n * Discovers skills from directories inside the sandbox by finding and parsing SKILL.md files.\n * Scans each directory for subdirectories containing SKILL.md, extracts frontmatter metadata,\n * and returns summaries for use in the system prompt.\n *\n * @returns Array of skill summaries (deduplicated by name, first occurrence wins)\n */\nexport async function discoverSkillsInSandbox(opts: {\n  sandbox: Sandbox;\n  skillsDirs: string[];\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDirs, debug } = opts;\n\n  const summaries: SkillSummary[] = [];\n  const seenNames = new Set<string>();\n\n  for (const skillsDir of skillsDirs) {\n    const dirSummaries = await discoverSkillsInDirectory({\n      sandbox,\n      skillsDir,\n      debug,\n    });\n\n    for (const summary of dirSummaries) {\n      if (!seenNames.has(summary.name)) {\n        seenNames.add(summary.name);\n        summaries.push(summary);\n      }\n    }\n  }\n\n  return summaries;\n}\n\nasync function discoverSkillsInDirectory(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDir, debug } = opts;\n  const skillPaths = await findSkillFiles({ sandbox, skillsDir, debug });\n\n  if (skillPaths.length === 0) {\n    return [];\n  }\n\n  const summaries: SkillSummary[] = [];\n\n  for (const skillMdPath of skillPaths) {\n    const summary = await parseSkillFile({ sandbox, skillMdPath, debug });\n    if (summary) {\n      summaries.push(summary);\n    }\n  }\n\n  return summaries;\n}\n\nasync function findSkillFiles(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<string[]> {\n  const { sandbox, skillsDir, debug } = opts;\n\n  const execResult = await sandbox.exec({\n    command: \"find\",\n    args: [skillsDir, \"-name\", \"SKILL.md\", \"-type\", \"f\"],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to scan skills directory \"${skillsDir}\": ${execResult.message}`\n      );\n    }\n    return [];\n  }\n\n  const { stdout, stderr, exitCode } = await execResult.result;\n  if (debug) {\n    console.log(\n      `[discover] find result: exitCode=${exitCode}, stdout=\"${stdout.trim()}\", stderr=\"${stderr.trim()}\"`\n    );\n  }\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(\n        `[discover] Skills directory not found or inaccessible: ${skillsDir}`\n      );\n    }\n    return [];\n  }\n\n  const paths = stdout\n    .trim()\n    .split(\"\\n\")\n    .filter((p) => p.length > 0);\n  if (debug) {\n    console.log(\"[discover] Found skill paths:\", paths);\n  }\n  return paths;\n}\n\nasync function parseSkillFile(opts: {\n  sandbox: Sandbox;\n  skillMdPath: string;\n  debug?: boolean;\n}): Promise<SkillSummary | null> {\n  const { sandbox, skillMdPath, debug } = opts;\n  const execResult = await sandbox.exec({\n    command: \"cat\",\n    args: [skillMdPath],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to read skill file \"${skillMdPath}\": ${execResult.message}`\n      );\n    }\n    return null;\n  }\n\n  const { stdout, exitCode } = await execResult.result;\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);\n    }\n    return null;\n  }\n\n  const parsed = parseSkillFrontmatter(stdout);\n\n  if (!parsed) {\n    if (debug) {\n      console.warn(\n        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`\n      );\n    }\n    return null;\n  }\n\n  return {\n    name: parsed.name,\n    description: parsed.description,\n    skillMdPath,\n  };\n}\n", "import { jsonSchema, type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { AgentInput, AgentMessageInput } from \"../agent-workflow\";\nimport type { RpcPayload, RpcResult } from \"../client\";\nimport type { Sandbox } from \"../sandbox\";\nimport { DEFAULT_WAIT_UNTIL } from \"../sandbox/process-manager\";\nimport type { SandboxRecord, Session, Storage } from \"../storage\";\nimport { createJavaScriptTool, type OnSubToolCall } from \"./javascript\";\n\nconst AGENT_PROTOCOL_VERSION = \"v1\";\n\nfunction formatFileSize(bytes: number): string {\n  if (bytes < 1024) {\n    return `${bytes}`;\n  }\n  if (bytes < 1024 * 1024) {\n    return `${(bytes / 1024).toFixed(1)}K`;\n  }\n  if (bytes < 1024 * 1024 * 1024) {\n    return `${(bytes / (1024 * 1024)).toFixed(1)}M`;\n  }\n  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;\n}\n\ntype InternalToolContext = {\n  input: AgentInput;\n  event: AgentMessageInput;\n  sandbox: Sandbox;\n  session: Session;\n  sandboxRecord: SandboxRecord;\n  apiToolsMetadata: {\n    name: string;\n    description?: string;\n    inputSchema?: unknown;\n  }[];\n  onSubToolCall?: OnSubToolCall;\n};\n\nexport type ToolContext<TContext = Record<string, unknown>> = {\n  session: Session;\n  sandbox: Sandbox;\n  storage: Storage;\n  context: TContext;\n};\n\nexport const builtInTools = {\n  Read: tool({\n    description:\n      \"Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      startLine: z\n        .number()\n        .optional()\n        .describe(\n          \"Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size.\"\n        ),\n      endLine: z\n        .number()\n        .optional()\n        .describe(\n          \"Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size.\"\n        ),\n    }),\n    outputSchema: z.object({\n      content: z.string().describe(\"File content\"),\n      metadata: z.object({\n        totalLines: z.number().describe(\"Total number of lines in the file\"),\n        linesShown: z\n          .number()\n          .describe(\"Number of lines included in this response\"),\n        startLine: z.number().describe(\"First line number shown (1-indexed)\"),\n        endLine: z.number().describe(\"Last line number shown (1-indexed)\"),\n        isPaginated: z\n          .boolean()\n          .describe(\"Whether this is a partial view of the file\"),\n        fileSize: z\n          .string()\n          .describe(\"Human-readable file size (e.g., '2.5K', '1.2M')\"),\n        path: z\n          .string()\n          .describe(\"Path to the file relative to workspace root\"),\n      }),\n    }),\n  }),\n  Grep: tool({\n    description:\n      \"Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.\",\n    inputSchema: z.object({\n      pattern: z\n        .string()\n        .describe(\"Regex pattern to search for (ripgrep syntax)\"),\n      path: z\n        .string()\n        .optional()\n        .describe(\n          \"Path to search in (defaults to workspace root). Can be a file or directory.\"\n        ),\n      fileType: z\n        .string()\n        .optional()\n        .describe(\n          \"File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters.\"\n        ),\n      glob: z\n        .string()\n        .optional()\n        .describe(\n          \"Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')\"\n        ),\n      caseSensitive: z\n        .boolean()\n        .optional()\n        .default(true)\n        .describe(\"Whether search is case-sensitive (default: true)\"),\n      contextLines: z\n        .number()\n        .optional()\n        .describe(\n          \"Number of context lines to show before and after each match\"\n        ),\n      maxCount: z\n        .number()\n        .optional()\n        .describe(\n          \"Maximum number of matches per file (useful for limiting output)\"\n        ),\n      filesWithMatches: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\n          \"Only show file paths that contain matches, not the matching lines themselves\"\n        ),\n    }),\n    outputSchema: z.object({\n      matches: z\n        .string()\n        .describe(\n          \"Search results with file paths, line numbers, and matching content\"\n        ),\n      summary: z.object({\n        matchCount: z.number().describe(\"Number of matches found\"),\n        fileCount: z.number().describe(\"Number of files containing matches\"),\n        searchPath: z.string().describe(\"Path that was searched\"),\n        pattern: z.string().describe(\"Pattern that was searched for\"),\n      }),\n    }),\n  }),\n  List: tool({\n    description:\n      \"Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.\",\n    inputSchema: z.object({\n      path: z\n        .string()\n        .optional()\n        .describe(\"Path to list (defaults to workspace root)\"),\n      depth: z\n        .number()\n        .optional()\n        .describe(\n          \"Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping\"\n        ),\n      includeHidden: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\n          \"Include hidden files and directories (those starting with '.')\"\n        ),\n      filesOnly: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\"Only show files, not directories\"),\n      pattern: z\n        .string()\n        .optional()\n        .describe(\"Glob pattern to filter results (e.g., '*.ts', '*test*')\"),\n    }),\n    outputSchema: z.object({\n      listing: z\n        .string()\n        .describe(\n          \"Directory tree listing showing paths relative to search root\"\n        ),\n      summary: z.object({\n        totalItems: z.number().describe(\"Total number of items found\"),\n        totalFiles: z.number().describe(\"Total number of files found\"),\n        totalDirs: z.number().describe(\"Total number of directories found\"),\n        searchPath: z.string().describe(\"Path that was listed\"),\n        depth: z\n          .number()\n          .optional()\n          .describe(\"Maximum depth used (if specified)\"),\n      }),\n    }),\n  }),\n  Write: tool({\n    description:\n      \"Write content to a file. Creates parent directories automatically. Overwrites existing files.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      content: z.string().describe(\"Content to write to the file\"),\n    }),\n    outputSchema: z.object({\n      success: z.boolean().describe(\"Whether the write succeeded\"),\n      path: z.string().describe(\"Path to the written file\"),\n      bytesWritten: z.number().describe(\"Number of bytes written\"),\n      error: z.string().optional().describe(\"Error message if write failed\"),\n    }),\n  }),\n  Edit: tool({\n    description:\n      \"Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      old_string: z\n        .string()\n        .describe(\"Exact string to find and replace (must be unique in file)\"),\n      new_string: z.string().describe(\"String to replace old_string with\"),\n    }),\n    outputSchema: z.object({\n      success: z.boolean().describe(\"Whether the edit succeeded\"),\n      path: z.string().describe(\"Path to the edited file\"),\n      error: z.string().optional().describe(\"Error message if edit failed\"),\n    }),\n  }),\n  Bash: tool({\n    description:\n      \"Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).\",\n    inputSchema: z.object({\n      command: z.string().describe(\"The shell command to execute\"),\n      waitUntil: z\n        .number()\n        .optional()\n        .describe(\n          `Max ms to wait for completion (default: ${DEFAULT_WAIT_UNTIL}). Use 0 to run in background and return immediately.`\n        ),\n    }),\n    outputSchema: z.object({\n      pid: z\n        .number()\n        .describe(\n          \"System PID (0 for foreground, >0 for background - use to kill)\"\n        ),\n      output: z\n        .string()\n        .describe(\"Command stdout+stderr combined (empty for background)\"),\n      exitCode: z.number().describe(\"Exit code (-1 for background/running)\"),\n      status: z\n        .enum([\"running\", \"completed\", \"failed\"])\n        .describe(\"Process status\"),\n      cwd: z.string().describe(\"Current working directory after command\"),\n      outputFile: z\n        .string()\n        .describe(\"Path to output log (for background processes)\"),\n    }),\n  }),\n  JavaScript: tool({\n    inputSchema: z.object({\n      code: z\n        .string()\n        .describe(\n          \"JavaScript async function body. `ctx` is in scope. Must use `return` to produce output.\"\n        ),\n    }),\n  }),\n} satisfies ToolSet;\n\nexport type BuiltInToolName = keyof typeof builtInTools;\nexport const builtinToolNames = Object.fromEntries(\n  Object.entries(builtInTools).map(([name]) => [name, name])\n) as { [K in BuiltInToolName]: K };\n\nexport function getTools(context: InternalToolContext) {\n  const tools: ToolSet = {\n    [builtinToolNames.Read]: tool({\n      ...builtInTools.Read,\n      execute: async ({ path, startLine, endLine }) => {\n        const filePath = path;\n\n        const result = await context.sandbox.readFile({ path: filePath });\n\n        if (result instanceof Error) {\n          console.error(\"[Read Tool]\", result);\n          throw result;\n        }\n\n        if (result === null) {\n          return {\n            content: `Error: File not found - ${filePath}`,\n            metadata: {\n              totalLines: 0,\n              linesShown: 0,\n              startLine: 0,\n              endLine: 0,\n              isPaginated: false,\n              fileSize: \"0\",\n              path: filePath,\n            },\n          };\n        }\n\n        const fullContent = result.toString(\"utf-8\");\n        const lines = fullContent.split(\"\\n\");\n        // A trailing newline produces an empty last element \u2014 remove it\n        // so line count matches `wc -l` / `awk 'END{print NR}'` behavior.\n        if (lines.length > 0 && lines.at(-1) === \"\") {\n          lines.pop();\n        }\n        const totalLines = lines.length;\n        const fileBytes = Buffer.byteLength(fullContent);\n        const fileSize = formatFileSize(fileBytes);\n\n        // Determine range\n        const PAGE_SIZE = 100;\n        let actualStart: number;\n        let actualEnd: number;\n\n        if (startLine !== undefined && endLine !== undefined) {\n          actualStart = startLine;\n          actualEnd = endLine;\n        } else if (startLine !== undefined) {\n          actualStart = startLine;\n          actualEnd = Math.min(startLine + PAGE_SIZE - 1, totalLines);\n        } else if (endLine !== undefined) {\n          actualStart = 1;\n          actualEnd = endLine;\n        } else if (totalLines > 200) {\n          actualStart = 1;\n          actualEnd = PAGE_SIZE;\n        } else {\n          actualStart = 1;\n          actualEnd = totalLines;\n        }\n\n        // Extract the line range (1-indexed)\n        const slicedLines = lines.slice(actualStart - 1, actualEnd);\n        const content = slicedLines.join(\"\\n\");\n\n        return {\n          metadata: {\n            totalLines,\n            linesShown: Math.max(0, actualEnd - actualStart + 1),\n            startLine: actualStart,\n            endLine: actualEnd,\n            isPaginated: actualEnd < totalLines,\n            fileSize,\n            path: filePath,\n          },\n          content,\n        };\n      },\n    }),\n    [builtinToolNames.Grep]: tool({\n      ...builtInTools.Grep,\n      execute: async ({\n        pattern,\n        path,\n        fileType,\n        glob,\n        caseSensitive,\n        contextLines,\n        maxCount,\n        filesWithMatches,\n      }) => {\n        const searchPath = path ?? \".\";\n\n        const args: string[] = [];\n\n        args.push(\"--line-number\");\n        args.push(\"--heading\");\n        args.push(\"--color\", \"never\");\n\n        if (!caseSensitive) {\n          args.push(\"-i\");\n        }\n\n        if (fileType) {\n          args.push(\"--type\", fileType);\n        }\n\n        if (glob) {\n          args.push(\"--glob\", glob);\n        }\n\n        if (contextLines !== undefined) {\n          args.push(\"-C\", String(contextLines));\n        }\n\n        if (maxCount !== undefined) {\n          args.push(\"--max-count\", String(maxCount));\n        }\n\n        if (filesWithMatches) {\n          args.push(\"--files-with-matches\");\n        }\n\n        args.push(\"--\", pattern, searchPath);\n\n        const result = await context.sandbox.exec({ command: \"rg\", args });\n\n        if (result instanceof Error) {\n          console.error(\"[Grep Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr && !stderr.toLowerCase().includes(\"no matches\")) {\n          console.error(`[Grep Tool] Warning: ${stderr}`);\n        }\n\n        // Truncate output to prevent \"input too long\" errors (50k chars \u2248 12.5k tokens)\n        const MAX_GREP_OUTPUT_CHARS = 50_000;\n        let finalOutput = stdout;\n        let wasTruncated = false;\n        if (finalOutput.length > MAX_GREP_OUTPUT_CHARS) {\n          finalOutput =\n            finalOutput.slice(0, MAX_GREP_OUTPUT_CHARS) +\n            \"\\n\\n[Output truncated - use more specific pattern or path]\";\n          wasTruncated = true;\n        }\n\n        const lines = finalOutput\n          .trim()\n          .split(\"\\n\")\n          .filter((l) => l.length > 0);\n        const fileCount = filesWithMatches\n          ? lines.length\n          : new Set(\n              lines\n                .filter((l) => !l.startsWith(\" \") && l.includes(\":\"))\n                .map((l) => l.split(\":\")[0])\n            ).size;\n\n        return {\n          summary: {\n            matchCount: filesWithMatches\n              ? 0\n              : lines.filter((l) => l.includes(\":\")).length,\n            fileCount,\n            searchPath,\n            pattern,\n            wasTruncated,\n          },\n          matches: finalOutput || \"(no matches found)\",\n        };\n      },\n    }),\n    [builtinToolNames.List]: tool({\n      ...builtInTools.List,\n      execute: async ({ path, depth, includeHidden, filesOnly, pattern }) => {\n        const searchPath = path ?? \".\";\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            SEARCH_PATH=\"$1\"\n            DEPTH=\"$2\"\n            INCLUDE_HIDDEN=\"$3\"\n            FILES_ONLY=\"$4\"\n            PATTERN=\"$5\"\n\n            # Build find command arguments\n            FIND_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && FIND_ARGS=\"$FIND_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && FIND_ARGS=\"$FIND_ARGS ! -path '*/.*'\"\n            [ \"$FILES_ONLY\" = \"true\" ] && FIND_ARGS=\"$FIND_ARGS -type f\"\n            [ -n \"$PATTERN\" ] && FIND_ARGS=\"$FIND_ARGS -name '$PATTERN'\"\n\n            # Get listing\n            LISTING=$(eval \"find '$SEARCH_PATH' $FIND_ARGS\" 2>/dev/null | sort)\n\n            # Get counts\n            COUNT_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && COUNT_ARGS=\"$COUNT_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && COUNT_ARGS=\"$COUNT_ARGS ! -path '*/.*'\"\n\n            FILE_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type f\" 2>/dev/null | wc -l)\n            DIR_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type d\" 2>/dev/null | wc -l)\n\n            # Output: counts first, then listing\n            echo \"$FILE_COUNT|$DIR_COUNT\"\n            echo \"|||LISTING|||\"\n            echo \"$LISTING\" | sed \"s|^$SEARCH_PATH|.|\"\n          `,\n            \"--\",\n            searchPath,\n            depth?.toString() || \"\",\n            includeHidden ? \"true\" : \"false\",\n            filesOnly ? \"true\" : \"false\",\n            pattern || \"\",\n          ],\n        });\n\n        if (result instanceof Error) {\n          console.error(\"[List Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          console.warn(`[List Tool] stderr: ${stderr}`);\n        }\n\n        const [countsLine, ...rest] = stdout.split(\"|||LISTING|||\");\n        const listing = rest.join(\"|||LISTING|||\").trim();\n        const [fileCountStr, dirCountStr] = countsLine.trim().split(\"|\");\n\n        const totalFiles = Number.parseInt(fileCountStr, 10) || 0;\n        const totalDirs = Number.parseInt(dirCountStr, 10) || 0;\n        const lines = listing.split(\"\\n\").filter((l) => l.length > 0);\n\n        return {\n          summary: {\n            totalItems: lines.length,\n            totalFiles,\n            totalDirs,\n            searchPath,\n            depth,\n          },\n          listing,\n        };\n      },\n    }),\n    [builtinToolNames.Write]: tool({\n      ...builtInTools.Write,\n      execute: async ({ path, content }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          if (dir !== \".\") {\n            await context.sandbox.exec({ command: \"mkdir\", args: [\"-p\", dir] });\n          }\n\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content }],\n            destPath: dir,\n          });\n\n          return {\n            success: true,\n            path: filePath,\n            bytesWritten: Buffer.byteLength(content, \"utf8\"),\n          };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return {\n            success: false,\n            path: filePath,\n            bytesWritten: 0,\n            error: errorMsg,\n          };\n        }\n      },\n    }),\n    [builtinToolNames.Edit]: tool({\n      ...builtInTools.Edit,\n      execute: async ({ path, old_string, new_string }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n\n        const result = await context.sandbox.readFile({ path: filePath });\n\n        if (result instanceof Error) {\n          return { success: false, path: filePath, error: result.message };\n        }\n\n        if (result === null) {\n          return {\n            success: false,\n            path: filePath,\n            error: `File not found: ${filePath}`,\n          };\n        }\n\n        const content = result.toString(\"utf-8\");\n        const occurrences = content.split(old_string).length - 1;\n\n        if (occurrences === 0) {\n          return {\n            success: false,\n            path: filePath,\n            error: \"old_string not found in file\",\n          };\n        }\n\n        if (occurrences > 1) {\n          return {\n            success: false,\n            path: filePath,\n            error: `old_string appears ${occurrences} times in file (must be unique). Include more surrounding context to make the match unique.`,\n          };\n        }\n\n        const newContent = content.replace(old_string, new_string);\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content: newContent }],\n            destPath: dir,\n          });\n\n          return { success: true, path: filePath };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return { success: false, path: filePath, error: errorMsg };\n        }\n      },\n    }),\n    [builtinToolNames.Bash]: tool({\n      ...builtInTools.Bash,\n      execute: async ({ command, waitUntil }) => {\n        const { createProcessManager } = await import(\n          \"../sandbox/process-manager\"\n        );\n\n        const processManager = createProcessManager({\n          sandbox: context.sandbox,\n          sessionId: context.input.sessionId,\n        });\n\n        await processManager.init();\n        const result = await processManager.run({ command, waitUntil });\n        return result;\n      },\n    }),\n  };\n\n  if (context.apiToolsMetadata.length > 0) {\n    const apiTools = buildApiTools({\n      rpc: context.input.rpc,\n      metadata: context.apiToolsMetadata,\n      session: context.session,\n      sandboxRecord: context.sandboxRecord,\n      context: context.event.context,\n    });\n    Object.assign(tools, apiTools);\n  }\n\n  tools[builtinToolNames.JavaScript] = createJavaScriptTool({\n    tools,\n    session: context.session,\n    sandbox: context.sandbox,\n    onSubToolCall: context.onSubToolCall,\n  });\n\n  return tools;\n}\n\ntype ApiToolMetadata = {\n  name: string;\n  description?: string;\n  inputSchema?: unknown;\n};\n\nexport async function fetchApiToolsMetadata(opts: {\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n}): Promise<ApiToolMetadata[]> {\n  const { rpc } = opts;\n\n  const result = await rpc({ method: \"tools.list\", params: {} });\n\n  if (\"error\" in result) {\n    console.error(\"[agent] Failed to fetch tools:\", result.error?.message);\n    return [];\n  }\n\n  return (result.result as ApiToolMetadata[]) ?? [];\n}\n\nexport function buildApiTools(opts: {\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n  metadata: ApiToolMetadata[];\n  session: Session;\n  sandboxRecord: SandboxRecord;\n  context: Record<string, unknown>;\n}): ToolSet {\n  const { rpc, metadata, session, sandboxRecord, context } = opts;\n  const tools: ToolSet = {};\n\n  for (const meta of metadata) {\n    tools[meta.name] = tool({\n      description: meta.description ?? `Custom tool: ${meta.name}`,\n      inputSchema: meta.inputSchema\n        ? jsonSchema(meta.inputSchema as Parameters<typeof jsonSchema>[0])\n        : z.object({}),\n      execute: async (input) => {\n        const result = await rpc({\n          method: \"tools.execute\",\n          params: {\n            name: meta.name,\n            input,\n            session,\n            sandboxRecord,\n            context,\n          },\n        });\n\n        if (\"error\" in result) {\n          throw new Error(`Tool execution failed: ${result.error?.message}`);\n        }\n\n        return result.result;\n      },\n    });\n  }\n\n  return tools;\n}\n\nexport function resolveApiUrl(opts: { api: string | undefined }): string {\n  let origin = \"\";\n  let path = `/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;\n\n  if (opts.api) {\n    if (opts.api.startsWith(\"/\")) {\n      path = opts.api;\n    } else {\n      // see if it's full\n      try {\n        const url = new URL(opts.api);\n        origin = url.origin;\n        const fullPath = url.pathname + url.search + url.hash;\n        if (fullPath.startsWith(\"/\") && fullPath !== \"/\") {\n          path = fullPath;\n        }\n      } catch {\n        // noop\n      }\n    }\n  }\n\n  if (!origin) {\n    if (process.env.NODE_ENV === \"development\") {\n      origin = `http://localhost:${\n        process.env.PORT ?? process.env.NEXT_PUBLIC_PORT ?? 3000\n      }`;\n    }\n    const vercelUrl =\n      process.env.VERCEL_URL ?? process.env.NEXT_PUBLIC_VERCEL_URL;\n    if (vercelUrl) {\n      origin = `https://${vercelUrl}`;\n    }\n  }\n\n  if (!origin) {\n    throw new Error(\n      \"[agent] Couldn't determine API origin (no origin detected in `api` option and no VERCEL_URL set)\"\n    );\n  }\n\n  return `${origin}${path}`;\n}\n", "import { type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { Sandbox } from \"../sandbox\";\nimport type { Session } from \"../storage\";\nimport { builtInTools } from \".\";\n\nexport const JAVASCRIPT_TOOL_NAME = \"JavaScript\";\n\nexport type SubToolCallResult = { result?: unknown; error?: string };\nexport type OnSubToolCall = (\n  toolName: string,\n  input: unknown,\n  execute: () => Promise<unknown>\n) => Promise<SubToolCallResult>;\n\nconst REQUEST_MARKER_START = \"__TOOL_REQUEST__\";\nconst REQUEST_MARKER_END = \"__TOOL_REQUEST_END__\";\nconst EXECUTION_TIMEOUT_MS = 5 * 60 * 1000;\n\n/**\n * The runner script is written to the sandbox and executed via Node.js.\n * It reads the model's code from code.js, sets up ctx.tools as RPC proxies\n * (requests sent via stderr markers, responses polled from files), executes\n * the code, and writes the result to stdout as JSON.\n */\nconst RUNNER_SCRIPT = `\nimport { readFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';\nimport { join, dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nconst SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));\nconst TOOL_CALL_TIMEOUT_MS = 300_000;\n\nlet reqCounter = 0;\n\nasync function callTool(name, input) {\n  const id = 'req_' + (++reqCounter) + '_' + Date.now();\n  const responseFile = join(SCRIPT_DIR, id + '.response.json');\n\n  const request = JSON.stringify({ id, tool: name, input });\n  process.stderr.write('${REQUEST_MARKER_START}' + request + '${REQUEST_MARKER_END}' + '\\\\n');\n\n  const start = Date.now();\n  while (!existsSync(responseFile)) {\n    if (Date.now() - start > TOOL_CALL_TIMEOUT_MS) {\n      throw new Error('Tool call ' + name + ' timed out waiting for response');\n    }\n    await new Promise(r => setTimeout(r, 30));\n  }\n\n  let raw;\n  try {\n    raw = readFileSync(responseFile, 'utf8');\n  } catch {\n    await new Promise(r => setTimeout(r, 50));\n    raw = readFileSync(responseFile, 'utf8');\n  }\n\n  const response = JSON.parse(raw);\n  try { unlinkSync(responseFile); } catch {}\n\n  if (response.error) {\n    throw new Error(response.error);\n  }\n  return response.result;\n}\n\nconst code = readFileSync(join(SCRIPT_DIR, 'code.js'), 'utf8');\nconst toolNames = JSON.parse(readFileSync(join(SCRIPT_DIR, 'tools.json'), 'utf8'));\n\nconst ctx = { tools: {} };\nfor (const name of toolNames) {\n  ctx.tools[name] = (input) => callTool(name, input);\n}\n\nconst logs = [];\nconst customConsole = {\n  log: (...args) => logs.push(args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n  error: (...args) => logs.push('[error] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n  warn: (...args) => logs.push('[warn] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n};\n\ntry {\n  const AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;\n  const fn = new AsyncFunction('ctx', 'console', code);\n  const result = await fn(ctx, customConsole);\n\n  const output = { success: true, result: result !== undefined ? result : null };\n  if (logs.length > 0) output.logs = logs;\n  process.stdout.write(JSON.stringify(output));\n} catch (err) {\n  const output = {\n    success: false,\n    error: err instanceof Error ? err.message + '\\\\n' + err.stack : String(err),\n  };\n  if (logs.length > 0) output.logs = logs;\n  process.stdout.write(JSON.stringify(output));\n}\n`;\n\n/**\n * Extracts a plain JSON Schema from whatever format the AI SDK tool uses\n * (Zod schema, AI SDK wrapped schema, or raw JSON Schema).\n */\nexport function extractJsonSchema(\n  schema: unknown\n): Record<string, unknown> | null {\n  if (!schema || typeof schema !== \"object\") {\n    return null;\n  }\n\n  if (\n    \"_def\" in schema &&\n    typeof (schema as { _def: unknown })._def === \"object\"\n  ) {\n    try {\n      return z.toJSONSchema(schema as z.ZodType) as Record<string, unknown>;\n    } catch {\n      return null;\n    }\n  }\n\n  const s = schema as Record<string | symbol, unknown>;\n  if (Symbol.for(\"vercel.ai.schema\") in s && \"jsonSchema\" in s) {\n    return s.jsonSchema as Record<string, unknown>;\n  }\n\n  if (\"type\" in s || \"properties\" in s) {\n    return s as Record<string, unknown>;\n  }\n\n  return null;\n}\n\nexport function jsonSchemaToTs(\n  schema: Record<string, unknown>,\n  indent = 0\n): string {\n  if (!schema) {\n    return \"unknown\";\n  }\n\n  if (schema.enum && Array.isArray(schema.enum)) {\n    return schema.enum.map((v) => JSON.stringify(v)).join(\" | \");\n  }\n\n  if (schema.anyOf && Array.isArray(schema.anyOf)) {\n    return schema.anyOf\n      .map((s: Record<string, unknown>) => jsonSchemaToTs(s, indent))\n      .join(\" | \");\n  }\n  if (schema.oneOf && Array.isArray(schema.oneOf)) {\n    return schema.oneOf\n      .map((s: Record<string, unknown>) => jsonSchemaToTs(s, indent))\n      .join(\" | \");\n  }\n\n  const type = schema.type as string;\n\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n    case \"integer\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"null\":\n      return \"null\";\n    case \"array\": {\n      const items = schema.items\n        ? jsonSchemaToTs(schema.items as Record<string, unknown>, indent)\n        : \"unknown\";\n      return `Array<${items}>`;\n    }\n    case \"object\": {\n      const properties = schema.properties as\n        | Record<string, Record<string, unknown>>\n        | undefined;\n      if (!properties) {\n        return \"Record<string, unknown>\";\n      }\n      const required = new Set((schema.required as string[]) || []);\n      const pad = \"  \".repeat(indent + 1);\n      const closePad = \"  \".repeat(indent);\n      const props = Object.entries(properties).map(([key, value]) => {\n        const opt = required.has(key) ? \"\" : \"?\";\n        return `${pad}${key}${opt}: ${jsonSchemaToTs(value, indent + 1)}`;\n      });\n      return `{\\n${props.join(\";\\n\")};\\n${closePad}}`;\n    }\n    default:\n      return \"unknown\";\n  }\n}\n\nexport function generateContextTypeString(tools: ToolSet): string {\n  const sigs: string[] = [];\n\n  for (const [name, t] of Object.entries(tools)) {\n    const raw = t as Record<string, unknown>;\n    const inputSchema = extractJsonSchema(raw.inputSchema ?? raw.parameters);\n    const outputSchema = extractJsonSchema(raw.outputSchema);\n\n    const inputType = inputSchema ? jsonSchemaToTs(inputSchema, 2) : \"{}\";\n    const outputType = outputSchema\n      ? jsonSchemaToTs(outputSchema, 2)\n      : \"unknown\";\n\n    sigs.push(`    ${name}(input: ${inputType}): Promise<${outputType}>`);\n  }\n\n  return `type Context = {\\n  tools: {\\n${sigs.join(\";\\n\")};\\n  }\\n}`;\n}\n\nasync function executeInSandbox({\n  code,\n  rpcDir,\n  abortController,\n  sandbox,\n  availableTools,\n  onSubToolCall,\n}: {\n  code: string;\n  rpcDir: string;\n  abortController: AbortController;\n  sandbox: Sandbox;\n  availableTools: ToolSet;\n  onSubToolCall?: OnSubToolCall;\n}): Promise<Record<string, unknown>> {\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", rpcDir],\n  });\n  if (mkdirResult instanceof Error) {\n    return { success: false, error: mkdirResult.message };\n  }\n  await mkdirResult.result;\n\n  await sandbox.writeFiles({\n    files: [\n      { path: \"runner.mjs\", content: RUNNER_SCRIPT },\n      { path: \"code.js\", content: code },\n      {\n        path: \"tools.json\",\n        content: JSON.stringify(Object.keys(availableTools)),\n      },\n    ],\n    destPath: rpcDir,\n  });\n\n  const nodeMajor = Number.parseInt(process.versions.node.split(\".\")[0], 10);\n  const permissionFlag =\n    nodeMajor >= 22 ? \"--permission\" : \"--experimental-permission\";\n\n  const execResult = await sandbox.exec({\n    command: \"node\",\n    args: [\n      permissionFlag,\n      `--allow-fs-read=${rpcDir}`,\n      `--allow-fs-write=${rpcDir}`,\n      `${rpcDir}/runner.mjs`,\n    ],\n    signal: abortController.signal,\n  });\n\n  if (execResult instanceof Error) {\n    return { success: false, error: execResult.message };\n  }\n\n  const fatal: { error: Error | null } = { error: null };\n\n  const abort = (error: Error) => {\n    if (!fatal.error) {\n      fatal.error = error;\n      abortController.abort();\n    }\n  };\n\n  const handleToolRequest = async (requestJson: string) => {\n    let parsed: { id: string; tool: string; input: unknown };\n    try {\n      parsed = JSON.parse(requestJson);\n    } catch {\n      return;\n    }\n\n    const { id, tool: toolName, input } = parsed;\n\n    let response: { result?: unknown; error?: string };\n    try {\n      const t = availableTools[toolName];\n      if (!t?.execute) {\n        throw new Error(\n          `Tool ${toolName} not found or has no execute function`\n        );\n      }\n      const exec = t.execute.bind(t);\n      if (onSubToolCall) {\n        response = await onSubToolCall(toolName, input, () =>\n          exec(input, {\n            toolCallId: `js_${toolName}_${Date.now()}`,\n            messages: [],\n          })\n        );\n      } else {\n        const result = await exec(input, {\n          toolCallId: `js_${toolName}_${Date.now()}`,\n          messages: [],\n        });\n        response = { result };\n      }\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      response = { error: msg };\n    }\n\n    try {\n      await sandbox.writeFiles({\n        files: [\n          {\n            path: `${id}.response.json`,\n            content: JSON.stringify(response),\n          },\n        ],\n        destPath: rpcDir,\n      });\n    } catch (err) {\n      /**\n       * If writing the response file fails, the runner will poll forever\n       * waiting for it. Abort the runner process so we don't deadlock.\n       */\n      const msg = err instanceof Error ? err.message : String(err);\n      abort(new Error(`Failed to write RPC response for ${toolName}: ${msg}`));\n    }\n  };\n\n  const toolCallPromises: Promise<void>[] = [];\n  let stderrBuffer = \"\";\n  let nonMarkerStderr = \"\";\n\n  const timeout = setTimeout(() => {\n    abort(\n      new Error(\n        `JavaScript execution timed out after ${EXECUTION_TIMEOUT_MS / 1000}s`\n      )\n    );\n  }, EXECUTION_TIMEOUT_MS);\n\n  try {\n    for await (const entry of execResult.logs()) {\n      if (fatal.error) {\n        break;\n      }\n\n      if (entry.stream === \"stderr\") {\n        stderrBuffer += entry.data;\n\n        while (true) {\n          const startIdx = stderrBuffer.indexOf(REQUEST_MARKER_START);\n          if (startIdx === -1) {\n            break;\n          }\n\n          const beforeMarker = stderrBuffer.slice(0, startIdx);\n          if (beforeMarker.trim()) {\n            nonMarkerStderr += beforeMarker;\n          }\n\n          const contentStart = startIdx + REQUEST_MARKER_START.length;\n          const endIdx = stderrBuffer.indexOf(REQUEST_MARKER_END, contentStart);\n          if (endIdx === -1) {\n            break;\n          }\n\n          const requestJson = stderrBuffer.slice(contentStart, endIdx);\n          stderrBuffer = stderrBuffer.slice(endIdx + REQUEST_MARKER_END.length);\n\n          toolCallPromises.push(handleToolRequest(requestJson));\n        }\n      }\n    }\n  } finally {\n    clearTimeout(timeout);\n  }\n\n  if (stderrBuffer.trim()) {\n    nonMarkerStderr += stderrBuffer;\n  }\n\n  await Promise.allSettled(toolCallPromises);\n\n  if (fatal.error) {\n    execResult.result.catch(() => undefined);\n    return {\n      success: false,\n      error: fatal.error.message,\n      ...(nonMarkerStderr ? { stderr: nonMarkerStderr.slice(0, 2000) } : {}),\n    };\n  }\n\n  const { stdout, stderr, exitCode } = await execResult.result;\n\n  try {\n    return JSON.parse(stdout);\n  } catch {\n    return {\n      success: false,\n      error: `Runner failed (exit ${exitCode}).`,\n      stderr: (nonMarkerStderr + stderr).slice(0, 2000),\n      stdout: stdout.slice(0, 1000),\n    };\n  }\n}\n\nexport function createJavaScriptTool(opts: {\n  tools: ToolSet;\n  session: Session;\n  sandbox: Sandbox;\n  onSubToolCall?: OnSubToolCall;\n}) {\n  const { session, sandbox, onSubToolCall } = opts;\n  const activeSet = session.activeTools ? new Set(session.activeTools) : null;\n  const availableTools: ToolSet = {};\n  for (const [name, t] of Object.entries(opts.tools)) {\n    if (!activeSet || activeSet.has(name)) {\n      availableTools[name] = t;\n    }\n  }\n  const contextType = generateContextTypeString(availableTools);\n\n  return tool({\n    ...builtInTools.JavaScript,\n    description: `Execute JavaScript to orchestrate multiple tool calls in a single step. Use this when you need to run several tools in sequence, transform intermediate results, or parallelize independent operations with Promise.all.\n\nThe code runs as an async function body with \\`ctx\\` in scope:\n\n\\`\\`\\`typescript\n${contextType}\n\\`\\`\\`\n\nExamples:\n- Sequential: \\`const file = await ctx.tools.Read({ path: \"package.json\" }); return JSON.parse(file.content);\\`\n- Parallel: \\`const [a, b] = await Promise.all([ctx.tools.Read({ path: \"a.ts\" }), ctx.tools.Read({ path: \"b.ts\" })]); return { a: a.content, b: b.content };\\`\n- Transform: \\`const grep = await ctx.tools.Grep({ pattern: \"TODO\" }); return grep.matches.split(\"\\\\n\").length;\\`\n\nReturn a value to pass results back. Use console.log() for debug output.`,\n    execute: ({ code }) => {\n      const runId = `run_${Date.now()}_${Math.random()\n        .toString(36)\n        .slice(2, 8)}`;\n      const rpcDir = `.agent/js-rpc/${runId}`;\n      const abortController = new AbortController();\n\n      return executeInSandbox({\n        code,\n        rpcDir,\n        abortController,\n        sandbox,\n        availableTools,\n        onSubToolCall,\n      });\n    },\n  });\n}\n", "import type { JSONValue, ModelMessage } from \"ai\";\n\ntype ProviderOptions = Record<string, Record<string, JSONValue>>;\n\nconst ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST = 4;\n\nconst CLAUDE_LIKE_MODEL_MATCHERS = [\"claude\", \"anthropic\"];\n\nconst CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS: ProviderOptions = {\n  anthropic: {\n    cacheControl: { type: \"ephemeral\" },\n  },\n  openrouter: {\n    cacheControl: { type: \"ephemeral\" },\n  },\n  bedrock: {\n    cachePoint: { type: \"default\" },\n  },\n  openaiCompatible: {\n    cache_control: { type: \"ephemeral\" },\n  },\n  copilot: {\n    copilot_cache_control: { type: \"ephemeral\" },\n  },\n};\n\nfunction getGatewayProvider(model: string): string | null {\n  const slashIndex = model.indexOf(\"/\");\n  if (slashIndex === -1) {\n    return null;\n  }\n  return model.slice(0, slashIndex);\n}\n\nfunction countAnthropicCacheBreakpoints(messages: ModelMessage[]): number {\n  let count = 0;\n  for (const message of messages) {\n    const providerOptions = (message as { providerOptions?: ProviderOptions })\n      .providerOptions;\n    if (providerOptions?.anthropic?.cacheControl) {\n      count += 1;\n    }\n    if (Array.isArray(message.content)) {\n      for (const part of message.content) {\n        const partProviderOptions = (\n          part as { providerOptions?: ProviderOptions }\n        ).providerOptions;\n        if (partProviderOptions?.anthropic?.cacheControl) {\n          count += 1;\n        }\n      }\n    }\n  }\n  return count;\n}\n\nfunction isClaudeLikeModel(model: string): boolean {\n  const lower = model.toLowerCase();\n  return CLAUDE_LIKE_MODEL_MATCHERS.some((m) => lower.includes(m));\n}\n\nfunction mergeProviderOptions(opts: {\n  current: ProviderOptions | undefined;\n  patch: ProviderOptions;\n}): ProviderOptions {\n  const next: ProviderOptions = { ...(opts.current ?? {}) };\n  for (const [key, value] of Object.entries(opts.patch)) {\n    next[key] = { ...(next[key] ?? {}), ...value };\n  }\n  return next;\n}\n\nfunction isCacheableClaudePart(part: unknown): boolean {\n  if (!part || typeof part !== \"object\") {\n    return false;\n  }\n\n  if (\"type\" in part && (part as { type?: unknown }).type === \"text\") {\n    const text = (part as { text?: unknown }).text;\n    if (typeof text === \"string\") {\n      return text.trim().length > 0;\n    }\n  }\n\n  if (\"type\" in part) {\n    const type = (part as { type?: unknown }).type;\n    if (type === \"thinking\" || type === \"reasoning\") {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction hasCacheableContent(message: ModelMessage): boolean {\n  if (typeof message.content === \"string\") {\n    return message.content.trim().length > 0;\n  }\n\n  if (Array.isArray(message.content)) {\n    return message.content.some((part) => isCacheableClaudePart(part));\n  }\n\n  return false;\n}\n\nfunction findLastCacheablePartIndex(content: unknown[]): number | null {\n  for (let i = content.length - 1; i >= 0; i -= 1) {\n    if (isCacheableClaudePart(content[i])) {\n      return i;\n    }\n  }\n  return null;\n}\n\nfunction selectClaudeCachingTargets(messages: ModelMessage[]): number[] {\n  const systemIndices: number[] = [];\n  const finalIndices: number[] = [];\n\n  for (let i = 0; i < messages.length && systemIndices.length < 2; i += 1) {\n    const message = messages[i];\n    if (message.role === \"system\" && hasCacheableContent(message)) {\n      systemIndices.push(i);\n    }\n  }\n\n  for (let i = messages.length - 1; i >= 0 && finalIndices.length < 2; i -= 1) {\n    const message = messages[i];\n    if (message.role !== \"system\" && hasCacheableContent(message)) {\n      finalIndices.push(i);\n    }\n  }\n\n  finalIndices.reverse();\n\n  return [...systemIndices, ...finalIndices];\n}\n\nfunction applyClaudePromptCaching(opts: {\n  messages: ModelMessage[];\n  providerId: string | null;\n  maxBreakpointsPerRequest: number;\n}): ModelMessage[] {\n  const existingBreakpoints = countAnthropicCacheBreakpoints(opts.messages);\n  const remainingBudget = Math.max(\n    0,\n    opts.maxBreakpointsPerRequest - existingBreakpoints\n  );\n\n  if (remainingBudget === 0) {\n    return opts.messages;\n  }\n\n  const targetIndices = selectClaudeCachingTargets(opts.messages).slice(\n    0,\n    remainingBudget\n  );\n  if (targetIndices.length === 0) {\n    return opts.messages;\n  }\n\n  const useMessageLevelOptions =\n    opts.providerId === \"anthropic\" ||\n    Boolean(opts.providerId?.includes(\"bedrock\"));\n\n  const nextMessages = opts.messages.slice();\n\n  for (const messageIndex of targetIndices) {\n    const message = nextMessages[messageIndex];\n\n    const shouldUseContentOptions =\n      !useMessageLevelOptions &&\n      Array.isArray(message.content) &&\n      message.content.length > 0;\n\n    if (shouldUseContentOptions && Array.isArray(message.content)) {\n      const partIndex = findLastCacheablePartIndex(message.content);\n      if (partIndex !== null) {\n        const part = message.content[partIndex];\n        if (part && typeof part === \"object\") {\n          const partProviderOptions = (\n            part as { providerOptions?: ProviderOptions }\n          ).providerOptions;\n\n          const nextContent = message.content.slice();\n          nextContent[partIndex] = {\n            ...(part as Record<string, unknown>),\n            providerOptions: mergeProviderOptions({\n              current: partProviderOptions,\n              patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS,\n            }),\n          } as (typeof message.content)[number];\n\n          nextMessages[messageIndex] = {\n            ...message,\n            content: nextContent,\n          } as ModelMessage;\n          continue;\n        }\n      }\n    }\n\n    const messageProviderOptions = (\n      message as { providerOptions?: ProviderOptions }\n    ).providerOptions;\n\n    nextMessages[messageIndex] = {\n      ...message,\n      providerOptions: mergeProviderOptions({\n        current: messageProviderOptions,\n        patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS,\n      }),\n    };\n  }\n\n  return nextMessages;\n}\n\nexport type PromptCachingResult = {\n  messages: ModelMessage[];\n  providerOptions: ProviderOptions;\n};\n\nexport function applyPromptCachingToModelRequest(opts: {\n  model: string;\n  sessionId: string;\n  messages: ModelMessage[];\n  anthropic?: { maxBreakpointsPerRequest?: number };\n  openai?: { setPromptCacheKey?: boolean };\n}): PromptCachingResult {\n  const provider = getGatewayProvider(opts.model);\n\n  const providerOptions: ProviderOptions = {};\n\n  if (\n    (provider === \"openai\" || provider === \"azure\") &&\n    opts.openai?.setPromptCacheKey !== false\n  ) {\n    providerOptions.openai = { promptCacheKey: opts.sessionId };\n  }\n\n  const maxBreakpointsPerRequest =\n    opts.anthropic?.maxBreakpointsPerRequest ??\n    ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST;\n\n  const cachedMessages = isClaudeLikeModel(opts.model)\n    ? applyClaudePromptCaching({\n        messages: opts.messages,\n        providerId: provider,\n        maxBreakpointsPerRequest,\n      })\n    : opts.messages;\n\n  return {\n    messages: cachedMessages,\n    providerOptions,\n  };\n}\n", "import type { UIMessage } from \"ai\";\nimport type { Message, Part } from \"../storage\";\n\n/** Sub-tool parts (from JavaScript meta-tool) use this toolCallId prefix. */\nfunction isSubToolPart(part: Part): boolean {\n  const p = part.part as { toolCallId?: string };\n  return typeof p?.toolCallId === \"string\" && p.toolCallId.startsWith(\"js_tc_\");\n}\n\nexport function assembleUIMessages(opts: {\n  messages: Message[];\n  parts: Part[];\n  until?: number;\n  includeQueued?: boolean;\n  /** When true, filters out sub-tool parts so the LLM doesn't see them. */\n  excludeSubToolParts?: boolean;\n}): UIMessage[] {\n  let filtered = opts.messages;\n\n  if (opts.until !== undefined) {\n    const until = opts.until;\n    filtered = filtered.filter((m) => m.createdAt <= until);\n  }\n\n  if (!opts.includeQueued) {\n    filtered = filtered.filter((m) => m.startedAt !== null);\n  }\n\n  const parts = opts.excludeSubToolParts\n    ? opts.parts.filter((p) => !isSubToolPart(p))\n    : opts.parts;\n\n  const partsByMessage = new Map<string, Part[]>();\n  for (const part of parts) {\n    const existing = partsByMessage.get(part.messageId) ?? [];\n    existing.push(part);\n    partsByMessage.set(part.messageId, existing);\n  }\n\n  return filtered\n    .map((m) => {\n      const messageParts = partsByMessage.get(m.id) ?? [];\n      messageParts.sort((a, b) => a.index - b.index);\n      return {\n        id: m.id,\n        role: m.role,\n        parts: messageParts.map((p) => p.part),\n      } satisfies UIMessage;\n    })\n    .filter((m) => m.parts.length > 0);\n}\n", "import type { StepUsage, UsageSummary } from \"../storage/rpc\";\n\nexport type { StepUsage, UsageSummary };\n\nfunction sum(items: StepUsage[], key: keyof StepUsage): number {\n  return items.reduce((acc, item) => {\n    const value = item[key];\n    return acc + (typeof value === \"number\" ? value : 0);\n  }, 0);\n}\n\nexport function computeUsageSummary(steps: StepUsage[]): UsageSummary {\n  return {\n    model: steps[0]?.model ?? \"unknown\",\n    inputTokens: sum(steps, \"inputTokens\"),\n    outputTokens: sum(steps, \"outputTokens\"),\n    totalTokens: sum(steps, \"totalTokens\"),\n    cacheReadTokens: sum(steps, \"cacheReadTokens\"),\n    cacheWriteTokens: sum(steps, \"cacheWriteTokens\"),\n    reasoningTokens: sum(steps, \"reasoningTokens\"),\n    stepCount: steps.length,\n  };\n}\n\nexport type SessionUsage = {\n  total: UsageSummary & { messageCount: number };\n  byMessageId: Record<string, UsageSummary | null>;\n};\n\nexport function computeSessionUsage(\n  messages: Array<{\n    id: string;\n    usage: { steps: StepUsage[]; summary: UsageSummary } | null;\n  }>\n): SessionUsage {\n  const byMessageId: Record<string, UsageSummary | null> = {};\n  for (const m of messages) {\n    byMessageId[m.id] = m.usage?.summary ?? null;\n  }\n\n  const summaries = messages\n    .map((m) => m.usage?.summary)\n    .filter((s): s is UsageSummary => s !== undefined);\n\n  const total = {\n    model: summaries[0]?.model ?? \"unknown\",\n    inputTokens: summaries.reduce((acc, s) => acc + s.inputTokens, 0),\n    outputTokens: summaries.reduce((acc, s) => acc + s.outputTokens, 0),\n    totalTokens: summaries.reduce((acc, s) => acc + s.totalTokens, 0),\n    cacheReadTokens: summaries.reduce((acc, s) => acc + s.cacheReadTokens, 0),\n    cacheWriteTokens: summaries.reduce((acc, s) => acc + s.cacheWriteTokens, 0),\n    reasoningTokens: summaries.reduce((acc, s) => acc + s.reasoningTokens, 0),\n    stepCount: summaries.reduce((acc, s) => acc + s.stepCount, 0),\n    messageCount: summaries.length,\n  };\n\n  return { total, byMessageId };\n}\n"],
  "mappings": "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",
  "names": ["FatalError", "tool", "z", "tool", "z", "session", "sandboxRecord", "sandbox", "result", "event", "FatalError"]
}
