experimental-agent 0.1.3 → 0.2.0

package/dist/chunk-OCF5I43X.mjs

@@ -0,0 +1,2367 @@
+import {
+  createLogger
+} from "./chunk-OZZVS6L5.mjs";
+import {
+  DEFAULT_WAIT_UNTIL
+} from "./chunk-FQ67QZOI.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
+var baseLog = createLogger({ subsystem: "skills" });
+async function discoverSkillsInSandbox(opts) {
+  const { sandbox, skillsDirs, sessionId } = opts;
+  const log4 = sessionId ? baseLog.withContext({ sessionId }) : baseLog;
+  const done = log4.time("discoverSkillsInSandbox");
+  const summaries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    const dirDone = log4.time("scan directory", { dir: skillsDir });
+    const dirSummaries = await discoverSkillsInDirectory({
+      sandbox,
+      skillsDir,
+      log: log4
+    });
+    dirDone({ count: dirSummaries.length });
+    for (const summary of dirSummaries) {
+      if (!seenNames.has(summary.name)) {
+        seenNames.add(summary.name);
+        summaries.push(summary);
+      }
+    }
+  }
+  done({ totalSkills: summaries.length });
+  return summaries;
+}
+async function discoverSkillsInDirectory(opts) {
+  const { sandbox, skillsDir, log: log4 } = opts;
+  const skillPaths = await findSkillFiles({ sandbox, skillsDir, log: log4 });
+  if (skillPaths.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  for (const skillMdPath of skillPaths) {
+    const summary = await parseSkillFile({ sandbox, skillMdPath, log: log4 });
+    if (summary) {
+      summaries.push(summary);
+    }
+  }
+  return summaries;
+}
+async function findSkillFiles(opts) {
+  const { sandbox, skillsDir, log: log4 } = opts;
+  const execResult = await sandbox.exec({
+    command: "find",
+    args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
+  });
+  if (execResult instanceof Error) {
+    log4.warn("failed to scan skills directory", {
+      dir: skillsDir,
+      error: execResult.message
+    });
+    return [];
+  }
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    log4.warn("skills directory not found or inaccessible", { dir: skillsDir });
+    return [];
+  }
+  return stdout.trim().split("\n").filter((p) => p.length > 0);
+}
+async function parseSkillFile(opts) {
+  const { sandbox, skillMdPath, log: log4 } = opts;
+  const execResult = await sandbox.exec({
+    command: "cat",
+    args: [skillMdPath]
+  });
+  if (execResult instanceof Error) {
+    log4.warn("failed to read skill file", {
+      path: skillMdPath,
+      error: execResult.message
+    });
+    return null;
+  }
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    log4.warn("could not read skill file", { path: skillMdPath });
+    return null;
+  }
+  const parsed = parseSkillFrontmatter(stdout);
+  if (!parsed) {
+    log4.warn("invalid or missing frontmatter", { path: skillMdPath });
+    return null;
+  }
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    skillMdPath
+  };
+}
+
+// src/tools/index.ts
+import * as pathPosix from "path/posix";
+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 : 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;\`
+- Bash: \`const r = await ctx.tools.Bash({ command: "node -e \\"console.log(JSON.stringify({v:1}))\\"" }); return JSON.parse(r.stdout);\`
+
+Return a value to pass results back. Use console.log() for debug output.
+Important: Each tool returns a structured object matching its output schema \u2014 not a raw string. Access the specific field you need (e.g. Bash's result.stdout, Read's result.content) rather than trying to parse the entire result.`,
+    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 log = createLogger({ subsystem: "tools" });
+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`;
+}
+function isRgNotFoundError(err) {
+  const parts = [err.message];
+  const anyErr = err;
+  if (typeof anyErr.reason === "string") {
+    parts.push(anyErr.reason);
+  }
+  if (anyErr.cause instanceof Error) {
+    parts.push(anyErr.cause.message);
+    const anyCause = anyErr.cause;
+    if (typeof anyCause.text === "string") {
+      parts.push(anyCause.text);
+    }
+  }
+  const msg = parts.join(" ").toLowerCase();
+  return msg.includes("executable file not found") || msg.includes("executable_not_found") || msg.includes("enoent") && msg.includes("rg");
+}
+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({
+      label: z2.string().describe("A label that describes the action being performed"),
+      path: z2.string().describe("Absolute path to the file"),
+      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({
+      label: z2.string().describe("A label that describes the action being performed"),
+      pattern: z2.string().describe("Regex pattern to search for (ripgrep syntax)"),
+      path: z2.string().optional().describe(
+        "Absolute path to search in (defaults to working directory). 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({
+      label: z2.string().describe("A label that describes the action being performed"),
+      path: z2.string().optional().describe("Absolute path to list (defaults to working directory)"),
+      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({
+      label: z2.string().describe("A label that describes the action being performed"),
+      path: z2.string().describe("Absolute path to the file"),
+      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({
+      label: z2.string().describe("A label that describes the action being performed"),
+      path: z2.string().describe("Absolute path to the file"),
+      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. Returns stdout and stderr separately. Use waitUntil to control how long to wait (0 = return immediately, process keeps running). Large outputs are tail-truncated; full output in outputDir.",
+    inputSchema: z2.object({
+      label: z2.string().describe("A label that describes the action being performed"),
+      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 return immediately while the process keeps running.`
+      )
+    }),
+    outputSchema: z2.object({
+      commandId: z2.string().describe("Command ID. Use to reference or kill running processes."),
+      stdout: z2.string().describe(
+        "Command stdout. Tail-truncated if large; full content in outputDir/stdout.txt."
+      ),
+      stderr: z2.string().describe(
+        "Command stderr. Tail-truncated if large; full content in outputDir/stderr.txt."
+      ),
+      exitCode: z2.number().describe("Exit code (-1 if still running)"),
+      status: z2.enum(["running", "completed", "failed"]).describe("Process status"),
+      outputDir: z2.string().describe(
+        "Path to output directory containing stdout.txt, stderr.txt, and metadata.json. Empty if still running."
+      )
+    })
+  }),
+  Skill: tool2({
+    description: "Load a skill's full instructions by name. Call this before following a skill.",
+    inputSchema: z2.object({
+      label: z2.string().describe("A label that describes the action being performed"),
+      name: z2.string().describe("Skill name from the Available Skills list")
+    }),
+    outputSchema: z2.object({
+      name: z2.string(),
+      description: z2.string(),
+      content: z2.string().describe("Full SKILL.md content"),
+      path: z2.string().describe("Path to the skill directory in the sandbox")
+    })
+  }),
+  JavaScript: tool2({
+    inputSchema: z2.object({
+      label: z2.string().describe("A label that describes the action being performed"),
+      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])
+);
+var SKILL_MD_SUFFIX = /\/?SKILL\.md$/;
+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) {
+          log.error("Read failed", { error: result.message });
+          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);
+        let result = await context.sandbox.exec({ command: "rg", args });
+        if (result instanceof Error && isRgNotFoundError(result)) {
+          log.warn("rg not found, installing ripgrep");
+          const installResult = await context.sandbox.exec({
+            command: "bash",
+            args: [
+              "-c",
+              [
+                "command -v rg >/dev/null 2>&1 && exit 0",
+                "dnf install -y ripgrep 2>/dev/null && exit 0",
+                "(apt-get update -qq && apt-get install -y -qq ripgrep) 2>/dev/null && exit 0",
+                "apk add --no-cache ripgrep 2>/dev/null && exit 0",
+                "curl -sL https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-unknown-linux-musl.tar.gz | tar xz -C /tmp && install /tmp/ripgrep-14.1.1-x86_64-unknown-linux-musl/rg /usr/local/bin/rg && rm -rf /tmp/ripgrep-14.1.1-x86_64-unknown-linux-musl"
+              ].join("\n")
+            ],
+            sudo: true
+          });
+          if (!(installResult instanceof Error)) {
+            const installOutput = await installResult.result;
+            if (installOutput.exitCode !== 0) {
+              log.warn("ripgrep install failed", {
+                stderr: installOutput.stderr
+              });
+            }
+          }
+          result = await context.sandbox.exec({ command: "rg", args });
+        }
+        if (result instanceof Error && isRgNotFoundError(result)) {
+          log.warn("rg unavailable, falling back to grep");
+          const grepArgs = ["-rn", "--color=never"];
+          if (!caseSensitive) {
+            grepArgs.push("-i");
+          }
+          if (contextLines !== void 0) {
+            grepArgs.push("-C", String(contextLines));
+          }
+          if (maxCount !== void 0) {
+            grepArgs.push("-m", String(maxCount));
+          }
+          if (filesWithMatches) {
+            grepArgs.push("-l");
+          }
+          if (glob) {
+            grepArgs.push(`--include=${glob}`);
+          }
+          if (fileType) {
+            const includeMap = {
+              ts: ["*.ts", "*.tsx", "*.mts", "*.cts"],
+              js: ["*.js", "*.jsx", "*.mjs", "*.cjs"],
+              py: ["*.py"],
+              rust: ["*.rs"],
+              go: ["*.go"],
+              java: ["*.java"],
+              md: ["*.md"],
+              json: ["*.json"],
+              css: ["*.css"],
+              html: ["*.html"],
+              yaml: ["*.yml", "*.yaml"]
+            };
+            for (const ext of includeMap[fileType] ?? [`*.${fileType}`]) {
+              grepArgs.push(`--include=${ext}`);
+            }
+          }
+          grepArgs.push("--", pattern, searchPath);
+          result = await context.sandbox.exec({
+            command: "grep",
+            args: grepArgs
+          });
+        }
+        if (result instanceof Error) {
+          log.error("Grep failed", { error: result.message });
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr && !stderr.toLowerCase().includes("no matches")) {
+          log.warn("Grep stderr", { 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) {
+          log.error("List failed", { error: result.message });
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr) {
+          log.warn("List 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;
+        const dir = pathPosix.dirname(filePath);
+        const fileName = pathPosix.basename(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;
+        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 = pathPosix.dirname(filePath);
+        const fileName = pathPosix.basename(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-JDUJDYGU.mjs");
+        const processManager = createProcessManager({
+          sandbox: context.sandbox
+        });
+        const result = await processManager.run({ command, waitUntil });
+        const MAX_STDOUT = 5e4;
+        const MAX_STDERR = 1e4;
+        let { stdout, stderr } = result;
+        if (stdout.length > MAX_STDOUT) {
+          stdout = `[truncated \u2014 showing last ${MAX_STDOUT} chars. Full: ${result.outputDir}/stdout.txt]
+
+` + stdout.slice(-MAX_STDOUT);
+        }
+        if (stderr.length > MAX_STDERR) {
+          stderr = `[truncated \u2014 showing last ${MAX_STDERR} chars. Full: ${result.outputDir}/stderr.txt]
+
+` + stderr.slice(-MAX_STDERR);
+        }
+        return { ...result, stdout, stderr };
+      }
+    })
+  };
+  if (context.session.skillsDir?.length) {
+    tools[builtinToolNames.Skill] = tool2({
+      ...builtInTools.Skill,
+      execute: async ({ name }) => {
+        const skills = context.skillsRef.current;
+        const skill = skills.find(
+          (s) => s.name.toLowerCase() === name.toLowerCase()
+        );
+        if (!skill) {
+          throw new Error(
+            `Skill not found: "${name}". Available: ${skills.map((s) => s.name).join(", ")}`
+          );
+        }
+        const result = await context.sandbox.readFile({
+          path: skill.skillMdPath
+        });
+        if (result instanceof Error) {
+          throw result;
+        }
+        if (result === null) {
+          throw new Error(`Skill file not found: ${skill.skillMdPath}`);
+        }
+        const raw = typeof result === "string" ? result : result.toString("utf-8");
+        const endMarker = raw.indexOf("---", 3);
+        const content = endMarker === -1 ? raw : raw.slice(endMarker + 3).trim();
+        const skillDir = skill.skillMdPath.replace(SKILL_MD_SUFFIX, "");
+        return {
+          name: skill.name,
+          description: skill.description,
+          content,
+          path: skillDir
+        };
+      }
+    });
+  }
+  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) {
+    log.error("failed to fetch tools", { error: 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 isStreamingContent(part) {
+  return typeof part === "object" && part !== null && "type" in part && (part.type === "text" || part.type === "reasoning");
+}
+function applyInterruptCutoff({
+  parts,
+  lastPart
+}) {
+  return parts.filter((p) => p.index <= lastPart.index).map((p) => {
+    if (p.index !== lastPart.index) {
+      return p;
+    }
+    if (isStreamingContent(lastPart.part)) {
+      return { ...p, part: lastPart.part };
+    }
+    return p;
+  });
+}
+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) => {
+    let messageParts = partsByMessage.get(m.id) ?? [];
+    messageParts.sort((a, b) => a.index - b.index);
+    if (m.interruptedLastPart != null) {
+      messageParts = applyInterruptCutoff({
+        parts: messageParts,
+        lastPart: m.interruptedLastPart
+      });
+    }
+    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
+var log2 = createLogger({ subsystem: "workflow" });
+function emitStatus({
+  writer,
+  status,
+  rpc
+}) {
+  writer?.({ type: "data-status", data: status, transient: true });
+  rpc({ method: "hook.status", params: { status } }).catch(() => {
+  });
+}
+var STATUS_THROTTLE_MS = 500;
+function createThrottledEmitStatus(rpc) {
+  let timer = null;
+  let pending = null;
+  function throttled({
+    writer,
+    status
+  }) {
+    pending = { writer, status };
+    if (timer !== null) {
+      return;
+    }
+    flush();
+    timer = setTimeout(() => {
+      timer = null;
+      if (pending) {
+        flush();
+      }
+    }, STATUS_THROTTLE_MS);
+  }
+  function flush() {
+    if (!pending) {
+      return;
+    }
+    const { writer, status } = pending;
+    pending = null;
+    emitStatus({ writer, status, rpc });
+  }
+  throttled.dispose = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    flush();
+  };
+  return throttled;
+}
+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 \`commandId\`. The process keeps running in the sandbox.
+
+To kill a process:
+Bash({ command: "ps aux | grep node" })   // Find the PID
+Bash({ command: "kill {pid}" })            // Graceful
+Bash({ command: "kill -9 {pid}" })         // Force
+`;
+function buildSkillsContext(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const skillLines = skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+  return `## Available Skills
+${skillLines}
+
+${backgroundProcessPrompt}
+
+Use the Skill tool to load a skill's full instructions before following it.`;
+}
+async function completeMessageStep({
+  assistantMessageId,
+  input,
+  writable,
+  usageSteps
+}) {
+  "use step";
+  const msgLog = log2.withContext({
+    sessionId: input.sessionId,
+    messageId: assistantMessageId
+  });
+  const { getStorage } = await import("./client-BKA7XBGW.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;
+  }
+  msgLog.info("message completed", {
+    steps: usageSteps.length,
+    totalTokens: usage?.summary.totalTokens
+  });
+  await writable.close();
+}
+var INTERRUPT_POLL_INTERVAL_MS = 250;
+function pollForInterrupt({
+  storage,
+  messageId,
+  signal,
+  abortController
+}) {
+  let resolveFirstCheck;
+  const firstCheck = new Promise((resolve) => {
+    resolveFirstCheck = resolve;
+  });
+  const interruptedLastPartRef = {
+    current: null
+  };
+  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) {
+        log2.info("interrupt detected", { messageId });
+        interruptedLastPartRef.current = message.interruptedLastPart;
+        abortController.abort();
+        if (isFirst) {
+          resolveFirstCheck();
+        }
+        return;
+      }
+      if (isFirst) {
+        isFirst = false;
+        resolveFirstCheck();
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)
+      );
+    }
+  };
+  poll();
+  return { firstCheck, interruptedLastPartRef };
+}
+async function streamTextStep({
+  assistantMessageId,
+  input,
+  event,
+  writable,
+  lastPartIndex,
+  stepIndexOffset,
+  discoveredSkills
+}) {
+  "use step";
+  const { getStorage } = await import("./client-BKA7XBGW.mjs");
+  const { getSandbox } = await import("./sandbox-HRGGTEHF.mjs");
+  const stepLog = log2.withContext({
+    sessionId: input.sessionId,
+    messageId: assistantMessageId
+  });
+  const doneStep = stepLog.time("streamTextStep");
+  const rpc = input.rpc;
+  const throttledEmitStatus = createThrottledEmitStatus(rpc);
+  const storage = getStorage({ config: input.storageConfig, rpc });
+  const pollStorage = getStorage({
+    config: input.storageConfig,
+    rpc: (p) => rpc({ ...p, _quiet: true })
+  });
+  const abortController = new AbortController();
+  const pollController = new AbortController();
+  const { firstCheck, interruptedLastPartRef } = pollForInterrupt({
+    storage: pollStorage,
+    messageId: assistantMessageId,
+    signal: pollController.signal,
+    abortController
+  });
+  const doneLoad = stepLog.time("load session + messages + parts + sandbox");
+  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,
+        rpc
+      });
+      return { session: session2, sandbox: sandbox2, sandboxRecord: sandboxRecord2 };
+    }),
+    fetchApiToolsMetadata({
+      rpc
+    })
+  ]);
+  doneLoad();
+  if (abortController.signal.aborted) {
+    pollController.abort();
+    return {
+      finishReason: "stop",
+      lastPartIndex,
+      usageSteps: [],
+      pendingApprovals: [],
+      maxSteps: void 0,
+      discoveredSkills
+    };
+  }
+  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 && !abortController.signal.aborted) {
+      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" || p.part.state === "output-denied")
+        );
+        if (updated) {
+          const state = updated.part.state;
+          if (state === "output-denied") {
+            const reason = updated.part.approval?.reason;
+            return {
+              error: `Tool "${toolName}" denied: ${reason || "user denied"}`
+            };
+          }
+          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: abortController.signal.aborted ? "interrupted" : "Approval timed out"
+    };
+  };
+  const skillsRef = {
+    current: discoveredSkills ?? []
+  };
+  const rawTools = getTools({
+    input,
+    event,
+    sandbox,
+    session,
+    sandboxRecord,
+    skillsRef,
+    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]) => {
+      const originalExecute = t.execute;
+      const wrappedExecute = originalExecute ? async (...args) => {
+        const done = stepLog.time(`tool:${name}`);
+        try {
+          const result2 = await originalExecute(...args);
+          done();
+          return result2;
+        } catch (e) {
+          done({ error: e instanceof Error ? e.message : String(e) });
+          throw e;
+        }
+      } : void 0;
+      return [
+        name,
+        {
+          ...t,
+          ...wrappedExecute ? { execute: wrappedExecute } : {},
+          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;
+          }
+        }
+      ];
+    })
+  );
+  const result = streamText({
+    // Placeholder to pass validation — prepareStep replaces messages entirely.
+    messages: [{ role: "user", content: "." }],
+    tools,
+    model: session.model,
+    abortSignal: abortController.signal,
+    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) {
+        const isFirstAssistantMessage = !messagesResult.items.some(
+          (m) => m.role === "assistant" && m.id !== assistantMessageId && m.startedAt !== null
+        );
+        const onReady = sandbox._onReady;
+        if (isFirstAssistantMessage && onReady) {
+          throttledEmitStatus({
+            writer: streamWriterRef.current,
+            status: { type: "sandbox-setup" }
+          });
+        }
+        if (!discoveredSkills) {
+          const skillsDirs = session.skillsDir?.length ? session.skillsDir : [];
+          if (skillsDirs.length > 0) {
+            const doneSkills = stepLog.time("discover skills", { skillsDirs });
+            skillsRef.current = await discoverSkillsInSandbox({
+              sandbox,
+              skillsDirs,
+              sessionId: input.sessionId
+            });
+            doneSkills({ count: skillsRef.current.length });
+          }
+        }
+      }
+      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) {
+        stepLog.info("executing approved tools", {
+          count: approvedParts.length
+        });
+        throttledEmitStatus({
+          writer: streamWriterRef.current,
+          status: { type: "processing-approvals" }
+        });
+        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 });
+            }
+          })
+        );
+      }
+      throttledEmitStatus({
+        writer: streamWriterRef.current,
+        status: { type: "thinking" }
+      });
+      const skillsContext = buildSkillsContext(skillsRef.current);
+      const cwdPrompt = `Your working directory is ${sandbox.cwd}. All file paths should be absolute.`;
+      const systemHeader = joinPromptSections(
+        BASE_SYSTEM_PROMPT,
+        cwdPrompt,
+        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
+      });
+      let activeTools = session.activeTools ?? void 0;
+      if (skillsRef.current.length === 0 && activeTools) {
+        activeTools = activeTools.filter(
+          (t) => t !== "Skill"
+        );
+      }
+      return {
+        messages: promptCaching.messages,
+        providerOptions: promptCaching.providerOptions,
+        activeTools
+      };
+    },
+    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) {
+                throttledEmitStatus({
+                  writer: streamWriterRef.current,
+                  status: { type: "needs-approval" }
+                });
+              }
+            }
+          })
+        );
+      }
+    });
+    await stream.pipeTo(writable, {
+      preventClose: true,
+      preventAbort: true
+    });
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      wasAborted = true;
+    } else {
+      throw err;
+    }
+  } finally {
+    pollController.abort();
+    throttledEmitStatus.dispose();
+  }
+  if (abortController.signal.aborted) {
+    wasAborted = true;
+  }
+  const lastPart = interruptedLastPartRef.current;
+  if (wasAborted) {
+    const terminalStates = /* @__PURE__ */ new Set([
+      "output-available",
+      "output-error",
+      "output-denied",
+      "done"
+    ]);
+    for (const part of stepParts) {
+      if ("type" in part && typeof part.type === "string" && part.type.startsWith("tool-") && "state" in part && !terminalStates.has(part.state)) {
+        part.state = "output-error";
+        part.errorText = "interrupted";
+      }
+    }
+  }
+  try {
+    const basePartIndex = nextPartIndex;
+    await Promise.all(
+      stepParts.map(async (uiPart, i) => {
+        const index = basePartIndex + i;
+        if (lastPart != null && index > lastPart.index) {
+          return;
+        }
+        const useClientPart = lastPart != null && index === lastPart.index;
+        const content = useClientPart ? lastPart.part : uiPart;
+        const result2 = await storage.part.set({
+          id: `part_${ulid()}`,
+          index,
+          messageId: assistantMessageId,
+          sessionId: input.sessionId,
+          part: content
+        });
+        if (result2 instanceof Error) {
+          throw result2;
+        }
+        return result2;
+      })
+    );
+    nextPartIndex = lastPart != null ? Math.min(basePartIndex + stepParts.length, lastPart.index + 1) : basePartIndex + stepParts.length;
+    if (setStartedPromise) {
+      const setStartedResult = await setStartedPromise;
+      if (setStartedResult instanceof Error) {
+        throw setStartedResult;
+      }
+      for (const m of setStartedResult ?? []) {
+        if (m instanceof Error) {
+          throw m;
+        }
+      }
+    }
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      wasAborted = true;
+    } else {
+      throw err;
+    }
+  }
+  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 || lastPart != null ? "stop" : await result.finishReason;
+  doneStep({
+    finishReason: finalFinishReason,
+    wasAborted,
+    partsCount: stepParts.length,
+    pendingApprovals: pendingApprovals.length
+  });
+  return {
+    finishReason: finalFinishReason,
+    lastPartIndex: nextPartIndex,
+    usageSteps,
+    pendingApprovals,
+    maxSteps: session.generation?.maxSteps,
+    discoveredSkills: skillsRef.current
+  };
+}
+
+// src/agent-workflow.ts
+var log3 = createLogger({ subsystem: "workflow" });
+var agentMessageHook = defineHook();
+var approvalHook = defineHook();
+async function agentWorkflow({
+  input,
+  event
+}) {
+  "use workflow";
+  const wfLog = log3.withContext({ sessionId: input.sessionId });
+  wfLog.info("workflow started", { messageId: event.assistantMessageId });
+  const messageHook = agentMessageHook.create({ token: input.sessionId });
+  const iterator = messageHook[Symbol.asyncIterator]();
+  let pendingNext = iterator.next();
+  let discoveredSkills = null;
+  await onMessage({ event, input, discoveredSkills }).then((result) => {
+    discoveredSkills = result?.discoveredSkills ?? discoveredSkills;
+  }).catch((e) => {
+    if (FatalError2.is(e)) {
+      wfLog.error("message processing failed permanently", {
+        error: e.message
+      });
+      return;
+    }
+    throw e;
+  });
+  while (true) {
+    const result = await pendingNext;
+    if (result.done) {
+      wfLog.error("unexpected: message hook iterator done");
+      break;
+    }
+    wfLog.info("processing new message", {
+      messageId: result.value.assistantMessageId
+    });
+    await onMessage({ event: result.value, input, discoveredSkills }).then((result2) => {
+      discoveredSkills = result2?.discoveredSkills ?? discoveredSkills;
+    }).catch((e) => {
+      if (FatalError2.is(e)) {
+        wfLog.error("message processing failed permanently", {
+          error: e.message
+        });
+        return;
+      }
+      throw e;
+    });
+    pendingNext = iterator.next();
+  }
+}
+async function onMessage({
+  event,
+  input,
+  discoveredSkills
+}) {
+  const msgLog = log3.withContext({
+    sessionId: input.sessionId,
+    messageId: event.assistantMessageId
+  });
+  const doneMessage = msgLog.time("onMessage");
+  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,
+        discoveredSkills
+      });
+      finishReason = result.finishReason;
+      lastPartIndex = result.lastPartIndex;
+      usageSteps.push(...result.usageSteps);
+      discoveredSkills = result.discoveredSkills;
+      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {
+        msgLog.info("reached maxSteps limit", { maxSteps: result.maxSteps });
+        break;
+      }
+      if (result.pendingApprovals.length > 0) {
+        msgLog.info("waiting for approvals", {
+          count: result.pendingApprovals.length,
+          tools: result.pendingApprovals.map((p) => p.toolName)
+        });
+        await Promise.all(
+          result.pendingApprovals.map((pending) => {
+            const hook = approvalHook.create({ token: pending.approvalId });
+            const iter = hook[Symbol.asyncIterator]();
+            return iter.next();
+          })
+        );
+      }
+    } catch (err) {
+      msgLog.error("streamTextStep failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  }
+  doneMessage({ totalSteps: usageSteps.length });
+  await completeMessageStep({
+    assistantMessageId: event.assistantMessageId,
+    input,
+    writable,
+    usageSteps
+  });
+  return { discoveredSkills };
+}
+
+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 { SkillSummary } from \"./skills/types\";\nimport type { StorageConfig } from \"./storage\";\nimport { createLogger } from \"./utils/logger\";\nimport type { StepUsage } from \"./utils/usage\";\n\nconst log = createLogger({ subsystem: \"workflow\" });\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 wfLog = log.withContext({ sessionId: input.sessionId });\n  wfLog.info(\"workflow started\", { messageId: event.assistantMessageId });\n\n  const messageHook = agentMessageHook.create({ token: input.sessionId });\n  const iterator = messageHook[Symbol.asyncIterator]();\n  let pendingNext = iterator.next();\n  let discoveredSkills: SkillSummary[] | null = null;\n\n  await onMessage({ event, input, discoveredSkills })\n    .then((result) => {\n      discoveredSkills = result?.discoveredSkills ?? discoveredSkills;\n    })\n    .catch((e) => {\n      if (FatalError.is(e)) {\n        wfLog.error(\"message processing failed permanently\", {\n          error: e.message,\n        });\n        return;\n      }\n      throw e;\n    });\n\n  while (true) {\n    const result = await pendingNext;\n\n    if (result.done) {\n      wfLog.error(\"unexpected: message hook iterator done\");\n      break;\n    }\n\n    wfLog.info(\"processing new message\", {\n      messageId: result.value.assistantMessageId,\n    });\n    await onMessage({ event: result.value, input, discoveredSkills })\n      .then((result) => {\n        discoveredSkills = result?.discoveredSkills ?? discoveredSkills;\n      })\n      .catch((e) => {\n        if (FatalError.is(e)) {\n          wfLog.error(\"message processing failed permanently\", {\n            error: e.message,\n          });\n          return;\n        }\n        throw e;\n      });\n    pendingNext = iterator.next();\n  }\n}\n\nasync function onMessage({\n  event,\n  input,\n  discoveredSkills,\n}: {\n  event: AgentMessageInput;\n  input: AgentInput;\n  discoveredSkills: SkillSummary[] | null;\n}): Promise<{ discoveredSkills: SkillSummary[] | null } | null> {\n  const msgLog = log.withContext({\n    sessionId: input.sessionId,\n    messageId: event.assistantMessageId,\n  });\n  const doneMessage = msgLog.time(\"onMessage\");\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        discoveredSkills,\n      });\n      finishReason = result.finishReason;\n      lastPartIndex = result.lastPartIndex;\n      usageSteps.push(...result.usageSteps);\n      discoveredSkills = result.discoveredSkills;\n\n      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {\n        msgLog.info(\"reached maxSteps limit\", { maxSteps: result.maxSteps });\n        break;\n      }\n\n      if (result.pendingApprovals.length > 0) {\n        msgLog.info(\"waiting for approvals\", {\n          count: result.pendingApprovals.length,\n          tools: result.pendingApprovals.map((p) => p.toolName),\n        });\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      }\n    } catch (err) {\n      msgLog.error(\"streamTextStep failed\", {\n        error: err instanceof Error ? err.message : String(err),\n      });\n      throw err;\n    }\n  }\n\n  doneMessage({ totalSteps: usageSteps.length });\n\n  await completeMessageStep({\n    assistantMessageId: event.assistantMessageId,\n    input,\n    writable,\n    usageSteps,\n  });\n\n  return { discoveredSkills };\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 { type BuiltInToolName, fetchApiToolsMetadata, getTools } from \"./tools\";\nimport type { OnSubToolCall } from \"./tools/javascript\";\nimport { createLogger } from \"./utils/logger\";\nimport { applyPromptCachingToModelRequest } from \"./utils/prompt-cache\";\nimport { assembleUIMessages } from \"./utils/ui\";\nimport { computeUsageSummary, type StepUsage } from \"./utils/usage\";\n\nconst log = createLogger({ subsystem: \"workflow\" });\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 STATUS_THROTTLE_MS = 500;\n\n/**\n * Creates a throttled emitStatus that fires immediately on the first call,\n * then suppresses further emissions within an N-ms window. When the window\n * expires, the most recent pending status is flushed so the UI always\n * converges to the correct state. Call `.dispose()` to flush and clean up.\n */\nfunction createThrottledEmitStatus(\n  rpc: (params: RpcPayload) => Promise<RpcResult>\n) {\n  let timer: ReturnType<typeof setTimeout> | null = null;\n  let pending: {\n    writer: ((event: unknown) => void) | null;\n    status: AgentStatus;\n  } | null = null;\n\n  function throttled({\n    writer,\n    status,\n  }: {\n    writer: ((event: unknown) => void) | null;\n    status: AgentStatus;\n  }) {\n    pending = { writer, status };\n    if (timer !== null) {\n      // within throttle window \u2014 queued\n      return;\n    }\n    flush();\n    timer = setTimeout(() => {\n      timer = null;\n      if (pending) {\n        flush();\n      }\n    }, STATUS_THROTTLE_MS);\n  }\n\n  function flush() {\n    if (!pending) {\n      return;\n    }\n    const { writer, status } = pending;\n    pending = null;\n    emitStatus({ writer, status, rpc });\n  }\n\n  throttled.dispose = () => {\n    if (timer !== null) {\n      clearTimeout(timer);\n      timer = null;\n    }\n    flush();\n  };\n\n  return throttled;\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 \\`commandId\\`. The process keeps running in the sandbox.\n\nTo kill a process:\nBash({ command: \"ps aux | grep node\" })   // Find the PID\nBash({ command: \"kill {pid}\" })            // Graceful\nBash({ command: \"kill -9 {pid}\" })         // Force\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    .join(\"\\n\");\n\n  return `## Available Skills\n${skillLines}\n\n${backgroundProcessPrompt}\n\nUse the Skill tool to load a skill's full instructions before following 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 msgLog = log.withContext({\n    sessionId: input.sessionId,\n    messageId: assistantMessageId,\n  });\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  msgLog.info(\"message completed\", {\n    steps: usageSteps.length,\n    totalTokens: usage?.summary.totalTokens,\n  });\n\n  await writable.close();\n}\n\nconst INTERRUPT_POLL_INTERVAL_MS = 250;\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}): {\n  firstCheck: Promise<void>;\n  interruptedLastPartRef: { current: { index: number; part: unknown } | null };\n} {\n  let resolveFirstCheck: () => void;\n  const firstCheck = new Promise<void>((resolve) => {\n    resolveFirstCheck = resolve;\n  });\n  const interruptedLastPartRef = {\n    current: null as { index: number; part: unknown } | null,\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        log.info(\"interrupt detected\", { messageId });\n        interruptedLastPartRef.current = message.interruptedLastPart;\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, interruptedLastPartRef };\n}\n\nexport async function streamTextStep({\n  assistantMessageId,\n  input,\n  event,\n  writable,\n  lastPartIndex,\n  stepIndexOffset,\n  discoveredSkills,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  event: AgentMessageInput;\n  writable: WritableStream;\n  lastPartIndex: number;\n  stepIndexOffset: number;\n  discoveredSkills: SkillSummary[] | null;\n}): Promise<{\n  finishReason: FinishReason;\n  lastPartIndex: number;\n  usageSteps: StepUsage[];\n  pendingApprovals: { approvalId: string; toolName: string }[];\n  maxSteps: number | undefined;\n  discoveredSkills: SkillSummary[] | null;\n}> {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const { getSandbox } = await import(\"./sandbox\");\n\n  const stepLog = log.withContext({\n    sessionId: input.sessionId,\n    messageId: assistantMessageId,\n  });\n  const doneStep = stepLog.time(\"streamTextStep\");\n\n  const rpc = input.rpc;\n  const throttledEmitStatus = createThrottledEmitStatus(rpc);\n  const storage = getStorage({ config: input.storageConfig, rpc });\n  const pollStorage = getStorage({\n    config: input.storageConfig,\n    rpc: (p) => rpc({ ...p, _quiet: true }),\n  });\n\n  const abortController = new AbortController();\n  const pollController = new AbortController();\n\n  const { firstCheck, interruptedLastPartRef } = pollForInterrupt({\n    storage: pollStorage,\n    messageId: assistantMessageId,\n    signal: pollController.signal,\n    abortController,\n  });\n\n  const doneLoad = stepLog.time(\"load session + messages + parts + sandbox\");\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        rpc,\n      });\n\n      return { session, sandbox, sandboxRecord };\n    }),\n    fetchApiToolsMetadata({\n      rpc,\n    }),\n  ]);\n  doneLoad();\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      discoveredSkills,\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 && !abortController.signal.aborted) {\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              (p.part as { state: string }).state === \"output-denied\")\n        );\n        if (updated) {\n          const state = (updated.part as { state: string }).state;\n\n          if (state === \"output-denied\") {\n            const reason = (updated.part as { approval?: { reason?: string } })\n              .approval?.reason;\n            return {\n              error: `Tool \"${toolName}\" denied: ${reason || \"user denied\"}`,\n            };\n          }\n\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 {\n      error: abortController.signal.aborted\n        ? \"interrupted\"\n        : \"Approval timed out\",\n    };\n  };\n\n  const skillsRef: { current: SkillSummary[] } = {\n    current: discoveredSkills ?? [],\n  };\n\n  const rawTools = getTools({\n    input,\n    event,\n    sandbox,\n    session,\n    sandboxRecord: sandboxRecord as SandboxRecord,\n    skillsRef,\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      const originalExecute = t.execute;\n      const wrappedExecute = originalExecute\n        ? async (...args: Parameters<typeof originalExecute>) => {\n            const done = stepLog.time(`tool:${name}`);\n            try {\n              const result = await originalExecute(...args);\n              done();\n              return result;\n            } catch (e) {\n              done({ error: e instanceof Error ? e.message : String(e) });\n              throw e;\n            }\n          }\n        : undefined;\n      return [\n        name,\n        {\n          ...t,\n          ...(wrappedExecute ? { execute: wrappedExecute } : {}),\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\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    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      if (lastPartIndex === 0) {\n        // Only show sandbox status on the first assistant message.\n        // If another assistant message has already started, the sandbox\n        // is warm and doesn't need an indicator.\n        const isFirstAssistantMessage = !messagesResult.items.some(\n          (m) =>\n            m.role === \"assistant\" &&\n            m.id !== assistantMessageId &&\n            m.startedAt !== null\n        );\n        const onReady = sandbox._onReady;\n        if (isFirstAssistantMessage && onReady) {\n          throttledEmitStatus({\n            writer: streamWriterRef.current,\n            status: { type: \"sandbox-setup\" },\n          });\n        }\n\n        if (!discoveredSkills) {\n          const skillsDirs = session.skillsDir?.length ? session.skillsDir : [];\n          if (skillsDirs.length > 0) {\n            const doneSkills = stepLog.time(\"discover skills\", { skillsDirs });\n            skillsRef.current = await discoverSkillsInSandbox({\n              sandbox,\n              skillsDirs,\n              sessionId: input.sessionId,\n            });\n            doneSkills({ count: skillsRef.current.length });\n          }\n        }\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        stepLog.info(\"executing approved tools\", {\n          count: approvedParts.length,\n        });\n        throttledEmitStatus({\n          writer: streamWriterRef.current,\n          status: { type: \"processing-approvals\" },\n        });\n\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      throttledEmitStatus({\n        writer: streamWriterRef.current,\n        status: { type: \"thinking\" },\n      });\n\n      const skillsContext = buildSkillsContext(skillsRef.current);\n      const cwdPrompt = `Your working directory is ${sandbox.cwd}. All file paths should be absolute.`;\n      const systemHeader = joinPromptSections(\n        BASE_SYSTEM_PROMPT,\n        cwdPrompt,\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      let activeTools = session.activeTools ?? undefined;\n      if (skillsRef.current.length === 0 && activeTools) {\n        activeTools = activeTools.filter(\n          (t) => t !== (\"Skill\" satisfies BuiltInToolName)\n        );\n      }\n\n      return {\n        messages: promptCaching.messages,\n        providerOptions: promptCaching.providerOptions,\n        activeTools,\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                throttledEmitStatus({\n                  writer: streamWriterRef.current,\n                  status: { type: \"needs-approval\" },\n                });\n              }\n            },\n          })\n        );\n      },\n    });\n\n    await stream.pipeTo(writable, {\n      preventClose: true,\n      preventAbort: true,\n    });\n  } catch (err) {\n    if (abortController.signal.aborted) {\n      wasAborted = true;\n    } else {\n      throw err;\n    }\n  } finally {\n    pollController.abort();\n    throttledEmitStatus.dispose();\n  }\n\n  if (abortController.signal.aborted) {\n    wasAborted = true;\n  }\n\n  const lastPart = interruptedLastPartRef.current;\n\n  if (wasAborted) {\n    const terminalStates = new Set([\n      \"output-available\",\n      \"output-error\",\n      \"output-denied\",\n      \"done\",\n    ]);\n    for (const part of stepParts) {\n      if (\n        \"type\" in part &&\n        typeof part.type === \"string\" &&\n        part.type.startsWith(\"tool-\") &&\n        \"state\" in part &&\n        !terminalStates.has(part.state as string)\n      ) {\n        (part as { state: string }).state = \"output-error\";\n        (part as { errorText?: string }).errorText = \"interrupted\";\n      }\n    }\n  }\n\n  try {\n    const basePartIndex = nextPartIndex;\n    await Promise.all(\n      stepParts.map(async (uiPart, i) => {\n        const index = basePartIndex + i;\n        if (lastPart != null && index > lastPart.index) {\n          return;\n        }\n        const useClientPart = lastPart != null && index === lastPart.index;\n        const content = useClientPart ? lastPart.part : uiPart;\n        const result = await storage.part.set({\n          id: `part_${ulid()}`,\n          index,\n          messageId: assistantMessageId,\n          sessionId: input.sessionId,\n          part: content as (typeof stepParts)[number],\n        });\n        if (result instanceof Error) {\n          throw result;\n        }\n        return result;\n      })\n    );\n    nextPartIndex =\n      lastPart != null\n        ? Math.min(basePartIndex + stepParts.length, lastPart.index + 1)\n        : basePartIndex + stepParts.length;\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  } catch (err) {\n    if (abortController.signal.aborted) {\n      wasAborted = true;\n    } else {\n      throw err;\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: FinishReason =\n    wasAborted || lastPart != null\n      ? (\"stop\" as FinishReason)\n      : await result.finishReason;\n\n  doneStep({\n    finishReason: finalFinishReason,\n    wasAborted,\n    partsCount: stepParts.length,\n    pendingApprovals: pendingApprovals.length,\n  });\n\n  return {\n    finishReason: finalFinishReason,\n    lastPartIndex: nextPartIndex,\n    usageSteps,\n    pendingApprovals,\n    maxSteps: session.generation?.maxSteps,\n    discoveredSkills: skillsRef.current,\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 { createLogger, type Logger } from \"../utils/logger\";\nimport { parseSkillFrontmatter } from \"./parser\";\nimport type { SkillSummary } from \"./types\";\n\nconst baseLog = createLogger({ subsystem: \"skills\" });\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  sessionId?: string;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDirs, sessionId } = opts;\n  const log = sessionId ? baseLog.withContext({ sessionId }) : baseLog;\n  const done = log.time(\"discoverSkillsInSandbox\");\n\n  const summaries: SkillSummary[] = [];\n  const seenNames = new Set<string>();\n\n  for (const skillsDir of skillsDirs) {\n    const dirDone = log.time(\"scan directory\", { dir: skillsDir });\n    const dirSummaries = await discoverSkillsInDirectory({\n      sandbox,\n      skillsDir,\n      log,\n    });\n    dirDone({ count: dirSummaries.length });\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  done({ totalSkills: summaries.length });\n\n  return summaries;\n}\n\nasync function discoverSkillsInDirectory(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  log: Logger;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDir, log } = opts;\n  const skillPaths = await findSkillFiles({ sandbox, skillsDir, log });\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, log });\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  log: Logger;\n}): Promise<string[]> {\n  const { sandbox, skillsDir, log } = 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    log.warn(\"failed to scan skills directory\", {\n      dir: skillsDir,\n      error: execResult.message,\n    });\n    return [];\n  }\n\n  const { stdout, exitCode } = await execResult.result;\n\n  if (exitCode !== 0) {\n    log.warn(\"skills directory not found or inaccessible\", { dir: skillsDir });\n    return [];\n  }\n\n  return stdout\n    .trim()\n    .split(\"\\n\")\n    .filter((p) => p.length > 0);\n}\n\nasync function parseSkillFile(opts: {\n  sandbox: Sandbox;\n  skillMdPath: string;\n  log: Logger;\n}): Promise<SkillSummary | null> {\n  const { sandbox, skillMdPath, log } = opts;\n  const execResult = await sandbox.exec({\n    command: \"cat\",\n    args: [skillMdPath],\n  });\n\n  if (execResult instanceof Error) {\n    log.warn(\"failed to read skill file\", {\n      path: skillMdPath,\n      error: execResult.message,\n    });\n    return null;\n  }\n\n  const { stdout, exitCode } = await execResult.result;\n\n  if (exitCode !== 0) {\n    log.warn(\"could not read skill file\", { path: skillMdPath });\n    return null;\n  }\n\n  const parsed = parseSkillFrontmatter(stdout);\n\n  if (!parsed) {\n    log.warn(\"invalid or missing frontmatter\", { path: skillMdPath });\n    return null;\n  }\n\n  return {\n    name: parsed.name,\n    description: parsed.description,\n    skillMdPath,\n  };\n}\n", "import * as pathPosix from \"node:path/posix\";\nimport { 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 { SkillSummary } from \"../skills/types\";\nimport type { SandboxRecord, Session, Storage } from \"../storage\";\nimport { createLogger } from \"../utils/logger\";\nimport { createJavaScriptTool, type OnSubToolCall } from \"./javascript\";\n\nconst log = createLogger({ subsystem: \"tools\" });\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  /** Ref populated in prepareStep when skillsDir is set; Skill tool reads from .current at execute time */\n  skillsRef: { current: SkillSummary[] };\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\nfunction isRgNotFoundError(err: Error): boolean {\n  const parts = [err.message];\n\n  const anyErr = err as unknown as Record<string, unknown>;\n  if (typeof anyErr.reason === \"string\") {\n    parts.push(anyErr.reason);\n  }\n  if (anyErr.cause instanceof Error) {\n    parts.push(anyErr.cause.message);\n    const anyCause = anyErr.cause as unknown as Record<string, unknown>;\n    if (typeof anyCause.text === \"string\") {\n      parts.push(anyCause.text);\n    }\n  }\n\n  const msg = parts.join(\" \").toLowerCase();\n  return (\n    msg.includes(\"executable file not found\") ||\n    msg.includes(\"executable_not_found\") ||\n    (msg.includes(\"enoent\") && msg.includes(\"rg\"))\n  );\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      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      path: z.string().describe(\"Absolute path to the file\"),\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      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      pattern: z\n        .string()\n        .describe(\"Regex pattern to search for (ripgrep syntax)\"),\n      path: z\n        .string()\n        .optional()\n        .describe(\n          \"Absolute path to search in (defaults to working directory). 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      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      path: z\n        .string()\n        .optional()\n        .describe(\"Absolute path to list (defaults to working directory)\"),\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      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      path: z.string().describe(\"Absolute path to the file\"),\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      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      path: z.string().describe(\"Absolute path to the file\"),\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. Returns stdout and stderr separately. Use waitUntil to control how long to wait (0 = return immediately, process keeps running). Large outputs are tail-truncated; full output in outputDir.\",\n    inputSchema: z.object({\n      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\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 return immediately while the process keeps running.`\n        ),\n    }),\n    outputSchema: z.object({\n      commandId: z\n        .string()\n        .describe(\"Command ID. Use to reference or kill running processes.\"),\n      stdout: z\n        .string()\n        .describe(\n          \"Command stdout. Tail-truncated if large; full content in outputDir/stdout.txt.\"\n        ),\n      stderr: z\n        .string()\n        .describe(\n          \"Command stderr. Tail-truncated if large; full content in outputDir/stderr.txt.\"\n        ),\n      exitCode: z.number().describe(\"Exit code (-1 if still running)\"),\n      status: z\n        .enum([\"running\", \"completed\", \"failed\"])\n        .describe(\"Process status\"),\n      outputDir: z\n        .string()\n        .describe(\n          \"Path to output directory containing stdout.txt, stderr.txt, and metadata.json. Empty if still running.\"\n        ),\n    }),\n  }),\n  Skill: tool({\n    description:\n      \"Load a skill's full instructions by name. Call this before following a skill.\",\n    inputSchema: z.object({\n      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\n      name: z.string().describe(\"Skill name from the Available Skills list\"),\n    }),\n    outputSchema: z.object({\n      name: z.string(),\n      description: z.string(),\n      content: z.string().describe(\"Full SKILL.md content\"),\n      path: z.string().describe(\"Path to the skill directory in the sandbox\"),\n    }),\n  }),\n  JavaScript: tool({\n    inputSchema: z.object({\n      label: z\n        .string()\n        .describe(\"A label that describes the action being performed\"),\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\nconst SKILL_MD_SUFFIX = /\\/?SKILL\\.md$/;\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          log.error(\"Read failed\", { error: result.message });\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        let result = await context.sandbox.exec({ command: \"rg\", args });\n\n        if (result instanceof Error && isRgNotFoundError(result)) {\n          log.warn(\"rg not found, installing ripgrep\");\n          const installResult = await context.sandbox.exec({\n            command: \"bash\",\n            args: [\n              \"-c\",\n              [\n                \"command -v rg >/dev/null 2>&1 && exit 0\",\n                \"dnf install -y ripgrep 2>/dev/null && exit 0\",\n                \"(apt-get update -qq && apt-get install -y -qq ripgrep) 2>/dev/null && exit 0\",\n                \"apk add --no-cache ripgrep 2>/dev/null && exit 0\",\n                \"curl -sL https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-unknown-linux-musl.tar.gz | tar xz -C /tmp && install /tmp/ripgrep-14.1.1-x86_64-unknown-linux-musl/rg /usr/local/bin/rg && rm -rf /tmp/ripgrep-14.1.1-x86_64-unknown-linux-musl\",\n              ].join(\"\\n\"),\n            ],\n            sudo: true,\n          });\n          if (!(installResult instanceof Error)) {\n            const installOutput = await installResult.result;\n            if (installOutput.exitCode !== 0) {\n              log.warn(\"ripgrep install failed\", {\n                stderr: installOutput.stderr,\n              });\n            }\n          }\n          result = await context.sandbox.exec({ command: \"rg\", args });\n        }\n\n        if (result instanceof Error && isRgNotFoundError(result)) {\n          log.warn(\"rg unavailable, falling back to grep\");\n          const grepArgs = [\"-rn\", \"--color=never\"];\n          if (!caseSensitive) {\n            grepArgs.push(\"-i\");\n          }\n          if (contextLines !== undefined) {\n            grepArgs.push(\"-C\", String(contextLines));\n          }\n          if (maxCount !== undefined) {\n            grepArgs.push(\"-m\", String(maxCount));\n          }\n          if (filesWithMatches) {\n            grepArgs.push(\"-l\");\n          }\n          if (glob) {\n            grepArgs.push(`--include=${glob}`);\n          }\n          if (fileType) {\n            const includeMap: Record<string, string[]> = {\n              ts: [\"*.ts\", \"*.tsx\", \"*.mts\", \"*.cts\"],\n              js: [\"*.js\", \"*.jsx\", \"*.mjs\", \"*.cjs\"],\n              py: [\"*.py\"],\n              rust: [\"*.rs\"],\n              go: [\"*.go\"],\n              java: [\"*.java\"],\n              md: [\"*.md\"],\n              json: [\"*.json\"],\n              css: [\"*.css\"],\n              html: [\"*.html\"],\n              yaml: [\"*.yml\", \"*.yaml\"],\n            };\n            for (const ext of includeMap[fileType] ?? [`*.${fileType}`]) {\n              grepArgs.push(`--include=${ext}`);\n            }\n          }\n          grepArgs.push(\"--\", pattern, searchPath);\n          result = await context.sandbox.exec({\n            command: \"grep\",\n            args: grepArgs,\n          });\n        }\n\n        if (result instanceof Error) {\n          log.error(\"Grep failed\", { error: result.message });\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr && !stderr.toLowerCase().includes(\"no matches\")) {\n          log.warn(\"Grep stderr\", { 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          log.error(\"List failed\", { error: result.message });\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          log.warn(\"List 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;\n        const dir = pathPosix.dirname(filePath);\n        const fileName = pathPosix.basename(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;\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 = pathPosix.dirname(filePath);\n        const fileName = pathPosix.basename(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        });\n\n        const result = await processManager.run({ command, waitUntil });\n\n        const MAX_STDOUT = 50_000;\n        const MAX_STDERR = 10_000;\n\n        let { stdout, stderr } = result;\n        if (stdout.length > MAX_STDOUT) {\n          stdout =\n            `[truncated \u2014 showing last ${MAX_STDOUT} chars. Full: ${result.outputDir}/stdout.txt]\\n\\n` +\n            stdout.slice(-MAX_STDOUT);\n        }\n        if (stderr.length > MAX_STDERR) {\n          stderr =\n            `[truncated \u2014 showing last ${MAX_STDERR} chars. Full: ${result.outputDir}/stderr.txt]\\n\\n` +\n            stderr.slice(-MAX_STDERR);\n        }\n\n        return { ...result, stdout, stderr };\n      },\n    }),\n  };\n\n  if (context.session.skillsDir?.length) {\n    tools[builtinToolNames.Skill] = tool({\n      ...builtInTools.Skill,\n      execute: async ({ name }) => {\n        const skills = context.skillsRef.current;\n        const skill = skills.find(\n          (s) => s.name.toLowerCase() === name.toLowerCase()\n        );\n        if (!skill) {\n          throw new Error(\n            `Skill not found: \"${name}\". Available: ${skills.map((s) => s.name).join(\", \")}`\n          );\n        }\n        const result = await context.sandbox.readFile({\n          path: skill.skillMdPath,\n        });\n        if (result instanceof Error) {\n          throw result;\n        }\n        if (result === null) {\n          throw new Error(`Skill file not found: ${skill.skillMdPath}`);\n        }\n        const raw =\n          typeof result === \"string\" ? result : result.toString(\"utf-8\");\n        const endMarker = raw.indexOf(\"---\", 3);\n        const content =\n          endMarker === -1 ? raw : raw.slice(endMarker + 3).trim();\n        const skillDir = skill.skillMdPath.replace(SKILL_MD_SUFFIX, \"\");\n        return {\n          name: skill.name,\n          description: skill.description,\n          content,\n          path: skillDir,\n        };\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    log.error(\"failed to fetch tools\", { error: 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 : 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- Bash: \\`const r = await ctx.tools.Bash({ command: \"node -e \\\\\"console.log(JSON.stringify({v:1}))\\\\\"\" }); return JSON.parse(r.stdout);\\`\n\nReturn a value to pass results back. Use console.log() for debug output.\nImportant: Each tool returns a structured object matching its output schema \u2014 not a raw string. Access the specific field you need (e.g. Bash's result.stdout, Read's result.content) rather than trying to parse the entire result.`,\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 { ReasoningUIPart, TextUIPart, 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\nfunction isStreamingContent(\n  part: unknown\n): part is TextUIPart | ReasoningUIPart {\n  return (\n    typeof part === \"object\" &&\n    part !== null &&\n    \"type\" in part &&\n    (part.type === \"text\" || part.type === \"reasoning\")\n  );\n}\n\nexport function applyInterruptCutoff({\n  parts,\n  lastPart,\n}: {\n  parts: Part[];\n  lastPart: { index: number; part: unknown };\n}): Part[] {\n  return parts\n    .filter((p) => p.index <= lastPart.index)\n    .map((p) => {\n      if (p.index !== lastPart.index) {\n        return p;\n      }\n      /**\n       * Only replace content for streaming parts (text, reasoning) where the\n       * client's truncated version is more accurate than the server's full\n       * version. For stateful parts (tools), the server's version is\n       * authoritative \u2014 it may have evolved (e.g. approval-requested \u2192\n       * output-denied) after the client snapshot was taken.\n       */\n      if (isStreamingContent(lastPart.part)) {\n        return { ...p, part: lastPart.part } as Part;\n      }\n      return p;\n    });\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      let messageParts = partsByMessage.get(m.id) ?? [];\n      messageParts.sort((a, b) => a.index - b.index);\n\n      if (m.interruptedLastPart != null) {\n        messageParts = applyInterruptCutoff({\n          parts: messageParts,\n          lastPart: m.interruptedLastPart,\n        });\n      }\n\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", "log", "tool", "z", "tool", "z", "log", "session", "sandboxRecord", "sandbox", "result", "event", "log", "FatalError", "result"]
}
