experimental-agent 0.7.1 → 0.8.0-alpha.2

package/dist/chunk-EH4L2CPW.mjs

@@ -0,0 +1,3779 @@
+import {
+  DEFAULT_WAIT_UNTIL
+} from "./chunk-C4VSUEY2.mjs";
+import {
+  kvStorageFallback,
+  localStorage,
+  shouldFallbackToKV2,
+  toStorage
+} from "./chunk-CS2SEUAA.mjs";
+import {
+  createLogger
+} from "./chunk-MSWINCCM.mjs";
+
+// src/errors.ts
+import * as errore from "errore";
+var SessionNotFoundError = class extends errore.createTaggedError({
+  name: "SessionNotFoundError",
+  message: "Session $id not found"
+}) {
+};
+var SessionError = class extends errore.createTaggedError({
+  name: "SessionError",
+  message: "Session $id failed: $reason"
+}) {
+};
+var SandboxNotFoundError = class extends errore.createTaggedError({
+  name: "SandboxNotFoundError",
+  message: "Sandbox $id not found"
+}) {
+};
+var StorageError = class extends errore.createTaggedError({
+  name: "StorageError",
+  message: "$reason"
+}) {
+};
+var StorageConflictError = class extends errore.createTaggedError({
+  name: "StorageConflictError",
+  message: "$reason"
+}) {
+};
+var SandboxError = class extends errore.createTaggedError({
+  name: "SandboxError",
+  message: "$reason"
+}) {
+};
+var MessageNotFoundError = class extends errore.createTaggedError({
+  name: "MessageNotFoundError",
+  message: "Message $id not found"
+}) {
+};
+
+// src/tools/tool.ts
+import {
+  tool as aiTool
+} from "ai";
+function tool(def) {
+  const { execute, contextSchema, stateSchema, ...rest } = def;
+  const wrappedExecute = execute ? (
+    // biome-ignore lint/suspicious/noExplicitAny: input type erased at runtime
+    (input, options) => {
+      const ctx = options.experimental_context;
+      const context = contextSchema ? contextSchema.parse(ctx.context) : ctx.context;
+      if (stateSchema) {
+        stateSchema.parse(ctx.state);
+      }
+      const state = ctx.state;
+      return execute(input, {
+        toolCallId: options.toolCallId,
+        abortSignal: options.abortSignal,
+        context,
+        state,
+        sessionId: ctx.sessionId,
+        messages: ctx.messages,
+        sandbox: ctx.sandbox
+      });
+    }
+  ) : void 0;
+  return wrappedExecute ? aiTool({ ...rest, execute: wrappedExecute }) : (
+    // biome-ignore lint/suspicious/noExplicitAny: no-execute path needs cast
+    aiTool(rest)
+  );
+}
+
+// src/tools/index.ts
+import {
+  tool as tool3
+} from "ai";
+import { ulid as ulid2 } from "ulid";
+import { z as z2 } from "zod";
+
+// src/session/send.ts
+import { all } from "better-all";
+import * as errore2 from "errore";
+import { ulid } from "ulid";
+
+// src/session/ai-loop/stream-text.ts
+import {
+  convertToModelMessages,
+  createUIMessageStream,
+  stepCountIs,
+  streamText as streamTextAi
+} from "ai";
+
+// 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 normalizeSkills(skills) {
+  if (!skills || skills.length === 0) {
+    return [];
+  }
+  return skills.map((skill) => {
+    if (typeof skill !== "object" || skill === null) {
+      throw new Error(
+        "Invalid skills entry: expected an object with a `type` field."
+      );
+    }
+    if ("type" in skill && skill.type) {
+      return skill;
+    }
+    throw new Error("Invalid skills entry: expected `type`.");
+  });
+}
+
+// src/skills/discover.ts
+async function discoverSkillsInSandbox(opts) {
+  const { agent: agent2, sandbox, skillsDirs, sessionId } = opts;
+  const baseLog = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "skills"
+  });
+  const log2 = sessionId ? baseLog.withContext({ sessionId }) : baseLog;
+  const done = log2.time("discoverSkillsInSandbox");
+  const summaries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    const dirDone = log2.time("scan directory", { dir: skillsDir });
+    const dirSummaries = await discoverSkillsInDirectory({
+      sandbox,
+      skillsDir,
+      log: log2
+    });
+    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: log2 } = opts;
+  const skillPaths = await findSkillFiles({ sandbox, skillsDir, log: log2 });
+  if (skillPaths.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  for (const skillMdPath of skillPaths) {
+    const summary = await parseSkillFile({ sandbox, skillMdPath, log: log2 });
+    if (summary) {
+      summaries.push(summary);
+    }
+  }
+  return summaries;
+}
+async function findSkillFiles(opts) {
+  const { sandbox, skillsDir, log: log2 } = opts;
+  const execResult = await sandbox.exec({
+    command: "find",
+    args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
+  });
+  if (execResult instanceof Error) {
+    log2.warn("failed to scan skills directory", {
+      dir: skillsDir,
+      error: execResult.message
+    });
+    return [];
+  }
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    log2.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: log2 } = opts;
+  const execResult = await sandbox.exec({
+    command: "cat",
+    args: [skillMdPath]
+  });
+  if (execResult instanceof Error) {
+    log2.warn("failed to read skill file", {
+      path: skillMdPath,
+      error: execResult.message
+    });
+    return null;
+  }
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    log2.warn("could not read skill file", { path: skillMdPath });
+    return null;
+  }
+  const parsed = parseSkillFrontmatter(stdout);
+  if (!parsed) {
+    log2.warn("invalid or missing frontmatter", { path: skillMdPath });
+    return null;
+  }
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    skillMdPath
+  };
+}
+
+// src/skills/resolve-host.ts
+async function collectFiles(opts) {
+  const { readdir, readFile: readFile2, stat } = await import("fs/promises");
+  const { resolve: resolve2, posix: pathPosix } = await import("path");
+  const fileStat = await stat(opts.absolutePath);
+  if (fileStat.isFile()) {
+    const content = await readFile2(opts.absolutePath);
+    return [{ path: opts.relativePrefix ?? "SKILL.md", content }];
+  }
+  if (!fileStat.isDirectory()) {
+    return [];
+  }
+  const entries = await readdir(opts.absolutePath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const nextAbs = resolve2(opts.absolutePath, entry.name);
+    const nextRel = opts.relativePrefix ? pathPosix.join(opts.relativePrefix, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      files.push(
+        ...await collectFiles({
+          absolutePath: nextAbs,
+          relativePrefix: nextRel
+        })
+      );
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push({
+        path: nextRel,
+        content: await readFile2(nextAbs)
+      });
+    }
+  }
+  return files;
+}
+async function stableDirName(inputPath) {
+  const { createHash } = await import("crypto");
+  const hash = createHash("sha1").update(inputPath).digest("hex").slice(0, 10);
+  return `host-${hash}`;
+}
+async function resolveHostSkill(opts) {
+  const { resolve: resolve2, posix: pathPosix } = await import("path");
+  const hostPath = resolve2(process.cwd(), opts.skill.path);
+  const files = await collectFiles({ absolutePath: hostPath });
+  const dirName = await stableDirName(hostPath);
+  const destPath = pathPosix.join(".agent", "skills", ".materialized", dirName);
+  if (files.length === 0) {
+    return destPath;
+  }
+  await opts.sandbox.writeFiles({
+    files,
+    destPath
+  });
+  return destPath;
+}
+
+// src/skills/resolve-inline.ts
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+async function stableInlineDirName(name) {
+  const { createHash } = await import("crypto");
+  const slug = slugify(name) || "inline-skill";
+  const hash = createHash("sha1").update(name).digest("hex").slice(0, 8);
+  return `${slug}-${hash}`;
+}
+function buildSkillMarkdown(skill) {
+  return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.instructions.trim()}
+`;
+}
+async function resolveInlineSkill(opts) {
+  const { posix: pathPosix } = await import("path");
+  const dirName = await stableInlineDirName(opts.skill.name);
+  const destPath = pathPosix.join(".agent", "skills", ".materialized", dirName);
+  await opts.sandbox.writeFiles({
+    destPath,
+    files: [
+      {
+        path: "SKILL.md",
+        content: buildSkillMarkdown(opts.skill)
+      }
+    ]
+  });
+  return destPath;
+}
+
+// src/skills/resolve-remote.ts
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function stableRepoDirName(skill) {
+  const { createHash } = await import("crypto");
+  const hashInput = `${skill.repo}::${skill.ref ?? "HEAD"}`;
+  const hash = createHash("sha1").update(hashInput).digest("hex").slice(0, 12);
+  return `git-${hash}`;
+}
+async function resolveRemoteSkill(opts) {
+  const { posix: pathPosix } = await import("path");
+  const dirName = await stableRepoDirName(opts.skill);
+  const cloneDir = pathPosix.join(".agent", "skills", ".materialized", dirName);
+  const quotedDir = shellQuote(cloneDir);
+  const quotedRepo = shellQuote(opts.skill.repo);
+  const quotedRef = shellQuote(opts.skill.ref ?? "HEAD");
+  const syncCommand = [
+    "set -euo pipefail",
+    `if [ ! -d ${quotedDir}/.git ]; then`,
+    `  rm -rf ${quotedDir}`,
+    `  mkdir -p ${quotedDir}`,
+    `  git clone --depth 1 ${quotedRepo} ${quotedDir}`,
+    "fi",
+    `if [ ${quotedRef} != 'HEAD' ]; then`,
+    `  git -C ${quotedDir} fetch --depth 1 origin ${quotedRef}`,
+    `  git -C ${quotedDir} checkout FETCH_HEAD`,
+    "fi"
+  ].join("\n");
+  const execResult = await opts.sandbox.exec({
+    command: "bash",
+    args: ["-lc", syncCommand]
+  });
+  const { exitCode, stderr } = await execResult.result;
+  if (exitCode !== 0) {
+    throw new Error(
+      `Failed to materialize git skill from ${opts.skill.repo}: ${stderr || "unknown error"}`
+    );
+  }
+  let resolvedDir = cloneDir;
+  if (opts.skill.path) {
+    resolvedDir = pathPosix.join(resolvedDir, opts.skill.path);
+  }
+  if (opts.skill.name) {
+    resolvedDir = pathPosix.join(resolvedDir, opts.skill.name);
+  }
+  return resolvedDir;
+}
+
+// src/skills/resolve.ts
+async function resolveSkillInputsToSandboxDirs(opts) {
+  const baseLog = createLogger({
+    config: { ...opts.agent.options.logging, name: opts.agent.name },
+    subsystem: "skills"
+  });
+  const log2 = opts.sessionId ? baseLog.withContext({ sessionId: opts.sessionId }) : baseLog;
+  const entries = normalizeSkills(opts.skills);
+  const resolved = [];
+  for (const entry of entries) {
+    if (entry.type === "sandbox") {
+      resolved.push(entry.path);
+      continue;
+    }
+    if (entry.type === "host") {
+      resolved.push(
+        await resolveHostSkill({
+          sandbox: opts.sandbox,
+          skill: entry
+        })
+      );
+      continue;
+    }
+    if (entry.type === "git") {
+      resolved.push(
+        await resolveRemoteSkill({
+          sandbox: opts.sandbox,
+          skill: entry
+        })
+      );
+      continue;
+    }
+    if (entry.type === "inline") {
+      resolved.push(
+        await resolveInlineSkill({
+          sandbox: opts.sandbox,
+          skill: entry
+        })
+      );
+      continue;
+    }
+    log2.warn("unknown skill source entry encountered", { entry });
+  }
+  return resolved;
+}
+
+// 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);
+  }
+  filtered = [...filtered].sort((a, b) => a.createdAt - b.createdAt);
+  const parts = opts.excludeSubToolParts ? opts.parts.filter((p) => !isSubToolPart(p)) : opts.parts;
+  const partsByMessage = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    const messageId = String(part.messageId);
+    const existing = partsByMessage.get(messageId) ?? [];
+    existing.push(part);
+    partsByMessage.set(messageId, existing);
+  }
+  return filtered.map((m) => {
+    const messageId = String(m.id);
+    let messageParts = partsByMessage.get(messageId) ?? [];
+    messageParts.sort((a, b) => a.index - b.index);
+    if (m.interruptedLastPart != null) {
+      messageParts = applyInterruptCutoff({
+        parts: messageParts,
+        lastPart: m.interruptedLastPart
+      });
+    }
+    return {
+      id: messageId,
+      role: m.role,
+      parts: messageParts.map((p) => p.part),
+      ...m.metadata != null ? { metadata: m.metadata } : {}
+    };
+  }).filter((m) => m.parts.length > 0);
+}
+
+// src/session/ai-loop/stream-text.ts
+var INTERRUPT_POLL_INTERVAL_MS = 250;
+function pollForInterrupt({
+  agent: agent2,
+  messageId,
+  signal,
+  abortController
+}) {
+  let resolveFirstCheck;
+  const firstCheck = new Promise((resolve2) => {
+    resolveFirstCheck = resolve2;
+  });
+  const interruptedLastPartRef = {
+    current: null
+  };
+  const log2 = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "ai-loop"
+  });
+  const poll = async () => {
+    let isFirst = true;
+    while (!signal.aborted) {
+      const message = await agent2.storage.message.get(messageId);
+      if (!message) {
+        if (isFirst) {
+          resolveFirstCheck();
+          return;
+        }
+        throw new Error(`Message ${messageId} not found`);
+      }
+      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(
+        (resolve2) => setTimeout(resolve2, INTERRUPT_POLL_INTERVAL_MS)
+      );
+    }
+  };
+  poll();
+  return { firstCheck, interruptedLastPartRef };
+}
+async function streamText({
+  stepThroughput,
+  assistantMessageId,
+  agent: agent2,
+  sessionId,
+  context,
+  state,
+  createdAt,
+  writable,
+  lastPartIndex,
+  stepIndexOffset,
+  discoveredSkills
+}) {
+  const log2 = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "ai-loop"
+  });
+  const stepLog = log2.withContext({
+    sessionId,
+    messageId: assistantMessageId
+  });
+  const doneStep = stepLog.time("streamText");
+  const throttledEmitStatus = createThrottledEmitStatus(agent2);
+  const abortController = new AbortController();
+  const pollController = new AbortController();
+  const { firstCheck, interruptedLastPartRef } = pollForInterrupt({
+    agent: agent2,
+    messageId: assistantMessageId,
+    signal: pollController.signal,
+    abortController
+  });
+  const doneLoad = stepLog.time("load session + messages + parts + sandbox");
+  const [, messagesResult, partsResult, { sandbox, sandboxRecord }] = await Promise.all([
+    firstCheck,
+    agent2.storage.message.listBySession(sessionId),
+    agent2.storage.part.listBySession(sessionId),
+    agent2.storage.session.get(sessionId).then(async (session) => {
+      if (!session) {
+        throw new SessionNotFoundError({ id: sessionId });
+      }
+      const sandboxId = session.sandboxId ?? session.id;
+      const sandbox2 = agent2.sandbox(sandboxId);
+      const sandboxRecord2 = await agent2.storage.sandbox.get(sandboxId);
+      return { sandbox: sandbox2, sandboxRecord: sandboxRecord2 };
+    })
+  ]);
+  doneLoad();
+  if (abortController.signal.aborted) {
+    pollController.abort();
+    return {
+      finishReason: "stop",
+      lastPartIndex,
+      usageSteps: [],
+      pendingApprovals: [],
+      maxSteps: void 0,
+      discoveredSkills,
+      context
+    };
+  }
+  const setStartedPromise = lastPartIndex === 0 ? (async () => {
+    const now = Date.now();
+    const pendingMessages = messagesResult.filter(
+      (m) => m.createdAt <= createdAt && m.startedAt === null
+    );
+    if (pendingMessages.length > 0) {
+      return await Promise.all(
+        pendingMessages.map(
+          (m) => agent2.storage.message.update(m.id, {
+            startedAt: now,
+            completedAt: m.role === "assistant" ? null : now
+          })
+        )
+      );
+    }
+  })() : null;
+  const allParts = [...partsResult];
+  const nextPartIndexRef = {
+    current: Math.max(
+      lastPartIndex,
+      ...allParts.filter((p) => p.messageId === assistantMessageId).map((p) => p.index + 1),
+      0
+    )
+  };
+  const skillsRef = {
+    current: discoveredSkills ?? []
+  };
+  let uiMessages = assembleUIMessages({
+    messages: messagesResult,
+    parts: allParts,
+    until: createdAt,
+    includeQueued: true,
+    excludeSubToolParts: true
+  });
+  const resolvableArgs = {
+    context,
+    state,
+    sessionId,
+    sandbox,
+    get messages() {
+      return uiMessages;
+    }
+  };
+  if (lastPartIndex === 0 && !discoveredSkills) {
+    const resolvedSkills = await resolveOption(
+      agent2.options.skills,
+      resolvableArgs
+    );
+    const skillsDirs = resolvedSkills?.length ? await resolveSkillInputsToSandboxDirs({
+      agent: agent2,
+      sandbox,
+      skills: resolvedSkills,
+      sessionId
+    }) : [];
+    if (skillsDirs.length > 0) {
+      const doneSkills = stepLog.time("discover skills", { skillsDirs });
+      skillsRef.current = await discoverSkillsInSandbox({
+        agent: agent2,
+        sandbox,
+        skillsDirs,
+        sessionId
+      });
+      doneSkills({ count: skillsRef.current.length });
+    }
+  }
+  const usageSteps = [];
+  let internalStepIndex = 0;
+  let loopFinishReason = "unknown";
+  let wasAborted = false;
+  const allPendingApprovals = [];
+  let currentMaxSteps;
+  try {
+    for (let iteration = 0; iteration < stepThroughput; iteration++) {
+      const resolvedModel = await resolveOption(
+        agent2.options.model,
+        resolvableArgs
+      );
+      const resolvedGeneration = await resolveOption(
+        agent2.options.generation,
+        resolvableArgs
+      );
+      const resolvedActiveTools = await resolveOption(
+        agent2.options.activeTools,
+        resolvableArgs
+      );
+      currentMaxSteps = resolvedGeneration?.maxSteps;
+      if (!resolvedModel) {
+        throw new Error("Agent model is not set");
+      }
+      const stepParts = [];
+      let streamTextFinishReason;
+      try {
+        const stream2 = createUIMessageStream({
+          execute: async ({ writer }) => {
+            const { rawTools, toolsWithNeedsApproval, toolContext } = getTools({
+              agent: agent2,
+              sandbox,
+              skillsRef,
+              writer,
+              abortController,
+              nextPartIndexRef,
+              assistantMessageId,
+              sessionId,
+              stepLog,
+              context,
+              state,
+              messages: uiMessages,
+              activeTools: resolvedActiveTools
+            });
+            if (iteration === 0) {
+              await processApprovals({
+                allParts,
+                messagesResult,
+                createdAt,
+                rawTools,
+                abortController,
+                toolContext,
+                agent: agent2,
+                stepLog,
+                throttledEmitStatus,
+                writer
+              });
+            }
+            throttledEmitStatus({
+              writer,
+              status: { type: "thinking" }
+            });
+            const iterResult = streamTextAi({
+              messages: [{ role: "user", content: "." }],
+              tools: toolsWithNeedsApproval,
+              model: resolvedModel,
+              abortSignal: abortController.signal,
+              stopWhen: stepCountIs(1),
+              temperature: resolvedGeneration?.temperature,
+              topK: resolvedGeneration?.topK,
+              topP: resolvedGeneration?.topP,
+              frequencyPenalty: resolvedGeneration?.frequencyPenalty,
+              presencePenalty: resolvedGeneration?.presencePenalty,
+              maxOutputTokens: resolvedGeneration?.maxOutputTokens,
+              headers: resolvedGeneration?.headers,
+              experimental_context: {
+                context,
+                state,
+                sessionId,
+                sandbox,
+                messages: uiMessages
+              },
+              prepareStep: async ({ model }) => {
+                const skillsContext = buildSkillsContext(skillsRef.current);
+                const cwdPrompt = sandboxRecord?.setup?.cwd ? `Your working directory is ${sandboxRecord.setup.cwd}. All file paths should be absolute.` : "All file paths must be absolute.";
+                const resolvedSystem = await resolveSystem(
+                  agent2.options.system,
+                  resolvableArgs
+                );
+                const systemHeader = joinPromptSections(
+                  BASE_SYSTEM_PROMPT,
+                  cwdPrompt,
+                  resolvedSystem
+                );
+                const systemContext = joinPromptSections(
+                  skillsContext,
+                  cwdPrompt
+                );
+                const convertedMessages = await convertToModelMessages(
+                  uiMessages,
+                  { ignoreIncompleteToolCalls: true }
+                );
+                const modelMessages = [
+                  ...systemHeader.trim() ? [{ role: "system", content: systemHeader }] : [],
+                  ...systemContext.trim() ? [{ role: "system", content: systemContext }] : [],
+                  ...convertedMessages
+                ];
+                const promptCaching = applyPromptCachingToModelRequest({
+                  model: typeof model === "string" ? model : model.modelId,
+                  sessionId,
+                  messages: modelMessages
+                });
+                let activeTools = resolvedActiveTools ?? void 0;
+                if (skillsRef.current.length === 0 && activeTools) {
+                  activeTools = activeTools.filter(
+                    (t) => t !== "Skill"
+                  );
+                }
+                return {
+                  messages: promptCaching.messages,
+                  providerOptions: mergeProviderOptions({
+                    current: resolvedGeneration?.providerOptions,
+                    patch: promptCaching.providerOptions
+                  }),
+                  activeTools
+                };
+              },
+              onStepFinish: ({ usage: usage2 }) => {
+                if (usage2) {
+                  usageSteps.push({
+                    stepIndex: stepIndexOffset + internalStepIndex,
+                    model: resolvedModel ?? "unknown",
+                    inputTokens: usage2.inputTokens ?? 0,
+                    outputTokens: usage2.outputTokens ?? 0,
+                    totalTokens: usage2.totalTokens ?? 0,
+                    cacheReadTokens: usage2.inputTokenDetails?.cacheReadTokens ?? 0,
+                    cacheWriteTokens: usage2.inputTokenDetails?.cacheWriteTokens ?? 0,
+                    reasoningTokens: usage2.outputTokenDetails?.reasoningTokens ?? 0
+                  });
+                }
+                internalStepIndex++;
+              }
+            });
+            writer.merge(
+              iterResult.toUIMessageStream({
+                generateMessageId: () => assistantMessageId,
+                onFinish: ({ messages }) => {
+                  for (const m of messages) {
+                    if (m.role === "assistant") {
+                      stepParts.push(...m.parts);
+                    }
+                  }
+                }
+              })
+            );
+            streamTextFinishReason = await iterResult.finishReason;
+          }
+        });
+        await stream2.pipeTo(writable, {
+          preventClose: true,
+          preventAbort: true
+        });
+      } catch (err) {
+        if (abortController.signal.aborted) {
+          wasAborted = true;
+        } else {
+          throw err;
+        }
+      }
+      if (abortController.signal.aborted) {
+        wasAborted = true;
+      }
+      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";
+          }
+        }
+      }
+      const lastPart = interruptedLastPartRef.current;
+      const newPartRecords = stepParts.map((uiPart, i) => {
+        const index = nextPartIndexRef.current + i;
+        if (lastPart != null && index > lastPart.index) {
+          return null;
+        }
+        const useClientPart = lastPart != null && index === lastPart.index;
+        const content = useClientPart ? lastPart.part : uiPart;
+        const partId = "approval" in content && content.approval?.id ? approvalPartId(content.approval.id) : `part_${assistantMessageId}_${index}`;
+        return {
+          id: partId,
+          index,
+          messageId: assistantMessageId,
+          sessionId,
+          part: content
+        };
+      }).filter((r) => r !== null);
+      const persistPromise = Promise.all([
+        ...newPartRecords.map(
+          (record) => agent2.storage.part.set(record.id, record)
+        ),
+        agent2.storage.session.update(sessionId, { state })
+      ]);
+      nextPartIndexRef.current = lastPart != null ? Math.min(
+        nextPartIndexRef.current + stepParts.length,
+        lastPart.index + 1
+      ) : nextPartIndexRef.current + stepParts.length;
+      const iterPendingApprovals = 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"
+      }));
+      loopFinishReason = wasAborted ? "stop" : streamTextFinishReason ?? "unknown";
+      const shouldBreak = iterPendingApprovals.length > 0 || loopFinishReason === "stop" || wasAborted || lastPart != null || currentMaxSteps != null && stepIndexOffset + usageSteps.length >= currentMaxSteps || iteration >= stepThroughput - 1;
+      if (shouldBreak) {
+        await persistPromise;
+        allParts.push(...newPartRecords);
+        allPendingApprovals.push(...iterPendingApprovals);
+        break;
+      }
+      await persistPromise;
+      allParts.push(...newPartRecords);
+      uiMessages = assembleUIMessages({
+        messages: messagesResult,
+        parts: allParts,
+        until: createdAt,
+        includeQueued: true,
+        excludeSubToolParts: true
+      });
+    }
+  } finally {
+    pollController.abort();
+    throttledEmitStatus.dispose();
+  }
+  if (setStartedPromise) {
+    await setStartedPromise;
+  }
+  doneStep({
+    finishReason: loopFinishReason,
+    wasAborted,
+    iterations: internalStepIndex,
+    pendingApprovals: allPendingApprovals.length
+  });
+  return {
+    finishReason: loopFinishReason,
+    lastPartIndex: nextPartIndexRef.current,
+    usageSteps,
+    pendingApprovals: allPendingApprovals,
+    maxSteps: currentMaxSteps,
+    discoveredSkills: skillsRef.current,
+    context
+  };
+}
+async function streamTextStep(...args) {
+  "use step";
+  return await streamText(...args);
+}
+async function processApprovals({
+  allParts,
+  messagesResult,
+  createdAt,
+  rawTools,
+  abortController,
+  toolContext,
+  agent: agent2,
+  stepLog,
+  throttledEmitStatus,
+  writer
+}) {
+  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,
+      status: { type: "processing-approvals" }
+    });
+    const preExecMessages = await convertToModelMessages(
+      assembleUIMessages({
+        messages: messagesResult,
+        parts: allParts,
+        until: 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: toolContext
+            });
+            part.state = "output-available";
+            part.output = toolOutput;
+            writer.write({
+              type: "tool-output-available",
+              toolCallId: part.toolCallId,
+              output: toolOutput
+            });
+          } catch (err) {
+            part.state = "output-error";
+            part.errorText = err instanceof Error ? err.message : String(err);
+            writer.write({
+              type: "tool-output-error",
+              toolCallId: part.toolCallId,
+              errorText: part.errorText
+            });
+          }
+          await agent2.storage.part.set(ap.id, { ...ap, part });
+        }
+      })
+    );
+  }
+  const pendingApprovalParts = allParts.filter(
+    (p) => p.part.state === "approval-requested"
+  );
+  if (pendingApprovalParts.length > 0) {
+    await Promise.all(
+      pendingApprovalParts.map(async (p) => {
+        const denied = {
+          ...p,
+          part: {
+            ...p.part,
+            state: "output-denied",
+            approval: {
+              ...p.part.approval ?? {},
+              approved: false,
+              reason: "auto-denied: new message sent"
+            }
+          }
+        };
+        Object.assign(p, denied);
+        await agent2.storage.part.set(p.id, denied);
+      })
+    );
+  }
+}
+function emitStatus({
+  writer,
+  status,
+  agent: agent2
+}) {
+  writer.write({ type: "data-status", data: status, transient: true });
+  agent2.hooks?.status?.(status);
+}
+var STATUS_THROTTLE_MS = 500;
+function createThrottledEmitStatus(agent2) {
+  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, agent: agent2 });
+  }
+  throttled.dispose = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    flush();
+  };
+  return throttled;
+}
+async function resolveOption(value, args) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "function") {
+    return await value(args);
+  }
+  return value;
+}
+async function resolveSystem(input, args) {
+  const result = await resolveOption(input, args);
+  if (!result) {
+    return null;
+  }
+  return Array.isArray(result) ? result.filter(Boolean).join("\n") : result;
+}
+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.`;
+}
+
+// src/session/interrupt.ts
+async function interrupt(sessionContext, opts) {
+  "use step";
+  const messages = await sessionContext.agent.storage.message.listBySession(
+    sessionContext.sessionId
+  );
+  const now = Date.now();
+  let pendingAssistantMessages = messages.filter(
+    (m) => m.role === "assistant" && m.completedAt === null && m.interruptedAt === null
+  );
+  if (pendingAssistantMessages.length === 0) {
+    const MAX_RETROACTIVE_MS = 5e3;
+    const latest = messages.filter(
+      (m) => m.role === "assistant" && m.interruptedAt === null && m.completedAt !== null && now - m.completedAt < MAX_RETROACTIVE_MS
+    ).sort((a, b) => b.createdAt - a.createdAt).at(0);
+    if (latest) {
+      pendingAssistantMessages = [latest];
+    }
+  }
+  await Promise.all(
+    pendingAssistantMessages.map(
+      (m) => sessionContext.agent.storage.message.set(m.id, {
+        ...m,
+        interruptedAt: now,
+        interruptedLastPart: opts?.lastPart ?? null
+      })
+    )
+  );
+  const messageIds = new Set(pendingAssistantMessages.map((m) => m.id));
+  if (messageIds.size === 0) {
+    return;
+  }
+  const allParts = await sessionContext.agent.storage.part.listBySession(
+    sessionContext.sessionId
+  );
+  for (const p of allParts) {
+    if (!messageIds.has(p.messageId)) {
+      continue;
+    }
+    if (p.part && "state" in p.part && p.part.state === "approval-requested" && "approval" in p.part) {
+      const approval = p.part.approval;
+      if (approval?.id) {
+        await sessionContext.agent.storage.part.set(p.id, {
+          ...p,
+          part: {
+            ...p.part,
+            state: "output-denied",
+            approval: {
+              ...approval,
+              approved: false,
+              reason: "interrupted"
+            }
+          }
+        });
+      }
+    }
+  }
+}
+
+// src/session/send.ts
+var DEFAULT_STEP_THROUGHPUT = 100;
+var ACTIVE_RUNS_KEY = /* @__PURE__ */ Symbol.for("experimental-agent:activeRuns");
+function getActiveRuns() {
+  const g = globalThis;
+  if (!g[ACTIVE_RUNS_KEY]) {
+    g[ACTIVE_RUNS_KEY] = /* @__PURE__ */ new Map();
+  }
+  return g[ACTIVE_RUNS_KEY];
+}
+async function send(sessionContext, input, opts) {
+  if (opts?.interruptIfStreaming) {
+    const lastPart = typeof opts.interruptIfStreaming === "object" ? opts.interruptIfStreaming.lastPart : void 0;
+    await interrupt(sessionContext, { lastPart });
+  }
+  const {
+    workflowRunId,
+    workflowWritable,
+    existingPartCount,
+    assistantMessageId,
+    assistantMessageCreatedAt,
+    state
+  } = await errore2.tryAsync({
+    try: () => initSessionStep({
+      sessionContext,
+      sessionId: sessionContext.sessionId,
+      sandboxId: opts?.sandboxId,
+      initialState: opts?.initialState,
+      input
+    }),
+    catch: (e) => {
+      if (e instanceof Error) {
+        throw e;
+      }
+      throw new SendError({
+        id: sessionContext.sessionId,
+        reason: String(e),
+        cause: e
+      });
+    }
+  });
+  const loopOpts = {
+    sessionContext,
+    assistantMessageId,
+    createdAt: assistantMessageCreatedAt,
+    context: opts?.context ?? {},
+    state,
+    lastPartIndex: existingPartCount,
+    workflowRunId
+  };
+  if (workflowWritable) {
+    await runLoop({ ...loopOpts, writable: workflowWritable });
+    return { assistantMessageId, done: true };
+  }
+  const chunks = [];
+  let notifyChunk;
+  let onChunk = new Promise((r) => {
+    notifyChunk = r;
+  });
+  const writable = new WritableStream({
+    write(chunk) {
+      chunks.push(chunk);
+      const prev = notifyChunk;
+      onChunk = new Promise((r) => {
+        notifyChunk = r;
+      });
+      prev();
+    }
+  });
+  const done = runLoop({ ...loopOpts, writable });
+  const activeRun = {
+    chunks,
+    writable,
+    done,
+    get onChunk() {
+      return onChunk;
+    }
+  };
+  const activeRuns = getActiveRuns();
+  activeRuns.set(assistantMessageId, activeRun);
+  done.finally(() => activeRuns.delete(assistantMessageId));
+  return { assistantMessageId, done: done.then(() => true) };
+}
+async function runLoop({
+  workflowRunId,
+  sessionContext,
+  assistantMessageId,
+  createdAt,
+  context: initialContext,
+  state,
+  writable,
+  lastPartIndex: initialPartIndex
+}) {
+  const agent2 = sessionContext.agent;
+  const log2 = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "ai-loop"
+  });
+  const msgLog = log2.withContext({
+    sessionId: sessionContext.sessionId,
+    messageId: assistantMessageId
+  });
+  const doneMessage = msgLog.time("onMessage");
+  let finishReason;
+  let lastPartIndex = initialPartIndex;
+  const usageSteps = [];
+  let discoveredSkills = null;
+  let context = initialContext;
+  try {
+    while (finishReason !== "stop") {
+      const streamTextFn = workflowRunId ? streamTextStep : streamText;
+      const throughput = workflowRunId ? 5 : DEFAULT_STEP_THROUGHPUT;
+      const result = await streamTextFn({
+        stepThroughput: throughput,
+        assistantMessageId,
+        agent: agent2,
+        sessionId: sessionContext.sessionId,
+        context,
+        state,
+        createdAt,
+        writable,
+        lastPartIndex,
+        stepIndexOffset: usageSteps.length,
+        discoveredSkills
+      });
+      finishReason = result.finishReason;
+      lastPartIndex = result.lastPartIndex;
+      usageSteps.push(...result.usageSteps);
+      discoveredSkills = result.discoveredSkills;
+      context = result.context;
+      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {
+        msgLog.info("reached maxSteps limit", { maxSteps: result.maxSteps });
+        break;
+      }
+      if (result.pendingApprovals.length > 0) {
+        msgLog.info("pending approvals, stopping loop", {
+          count: result.pendingApprovals.length,
+          tools: result.pendingApprovals.map((p) => p.toolName)
+        });
+        break;
+      }
+    }
+    doneMessage({ totalSteps: usageSteps.length });
+  } catch (err) {
+    msgLog.error("AI loop failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  } finally {
+    await completeMessageStep({
+      assistantMessageId,
+      sessionContext,
+      writable,
+      usageSteps
+    });
+  }
+}
+async function initSessionStep({
+  sessionContext,
+  sessionId,
+  sandboxId,
+  initialState,
+  input
+}) {
+  "use step";
+  let workflowRunId;
+  let workflowWritable;
+  try {
+    const { getWorkflowMetadata, getWritable } = await import("workflow");
+    workflowRunId = getWorkflowMetadata().workflowRunId;
+    workflowWritable = getWritable();
+  } catch {
+  }
+  const newMessages = [];
+  const newParts = [];
+  const newApprovals = [];
+  if (Array.isArray(input)) {
+    for (const i of input) {
+      const { message, parts, approvals } = toMessageAndParts({
+        sessionId: sessionContext.sessionId,
+        input: i,
+        defaultRole: "user"
+      });
+      if (message) {
+        newMessages.push(message);
+      }
+      newParts.push(...parts);
+      newApprovals.push(...approvals);
+    }
+  } else {
+    const { message, parts, approvals } = toMessageAndParts({
+      input,
+      sessionId: sessionContext.sessionId,
+      defaultRole: "user"
+    });
+    if (message) {
+      newMessages.push(message);
+    }
+    newParts.push(...parts);
+    newApprovals.push(...approvals);
+  }
+  const lastNewMessage = newMessages.at(-1);
+  const reuseAssistant = lastNewMessage?.role === "assistant";
+  const assistantMessageId = reuseAssistant ? lastNewMessage.id : `message_${ulid()}`;
+  const baseTime = Date.now();
+  const assistantMessageCreatedAt = baseTime + newMessages.length;
+  if (!reuseAssistant) {
+    newMessages.push({
+      id: assistantMessageId,
+      sessionId: sessionContext.sessionId,
+      role: "assistant",
+      createdAt: assistantMessageCreatedAt,
+      startedAt: null,
+      completedAt: null,
+      interruptedAt: null,
+      interruptedLastPart: null,
+      usage: null,
+      workflowRunId: null,
+      metadata: null
+    });
+  }
+  const existingPartCount = reuseAssistant ? newParts.filter((p) => p.messageId === assistantMessageId).length : 0;
+  let session = await sessionContext.agent.storage.session.get(sessionId);
+  const now = Date.now();
+  if (!session) {
+    session = {
+      id: sessionId,
+      sandboxId: sandboxId ?? null,
+      lastMessageId: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    await sessionContext.agent.storage.session.set(session.id, session);
+  } else if (sandboxId && sandboxId !== session.sandboxId) {
+    session = { ...session, sandboxId, updatedAt: now };
+    await sessionContext.agent.storage.session.update(session.id, {
+      sandboxId
+    });
+  }
+  await all({
+    async saveMessages() {
+      await Promise.all(
+        newMessages.map(async (m, i) => {
+          const existing = await sessionContext.agent.storage.message.get(m.id);
+          if (existing) {
+            return;
+          }
+          await sessionContext.agent.storage.message.set(m.id, {
+            ...m,
+            createdAt: baseTime + i,
+            workflowRunId: m.id === assistantMessageId ? workflowRunId ?? null : m.workflowRunId
+          });
+        })
+      );
+    },
+    async saveParts() {
+      await Promise.all(
+        newParts.map(
+          async (p) => sessionContext.agent.storage.part.set(p.id, p)
+        )
+      );
+    },
+    async resolveApprovals() {
+      await Promise.all(
+        newApprovals.map(async (a) => {
+          const partId = approvalPartId(a.approvalId);
+          const part = await sessionContext.agent.storage.part.get(partId);
+          if (!part) {
+            throw new ApprovalNotFoundError({
+              id: sessionContext.sessionId,
+              approvalId: a.approvalId
+            });
+          }
+          await sessionContext.agent.storage.part.set(partId, {
+            ...part,
+            part: {
+              ...part.part,
+              state: a.approved ? "approval-responded" : "output-denied",
+              approval: {
+                id: a.approvalId,
+                approved: a.approved,
+                reason: a.reason
+              }
+            }
+          });
+        })
+      );
+    },
+    async updateSession() {
+      await sessionContext.agent.storage.session.set(session.id, {
+        ...session,
+        lastMessageId: assistantMessageId,
+        updatedAt: Date.now()
+      });
+    }
+  });
+  const state = session.state ? { ...session.state } : { ...initialState ?? {} };
+  return {
+    workflowRunId,
+    workflowWritable,
+    existingPartCount,
+    assistantMessageId,
+    assistantMessageCreatedAt,
+    state
+  };
+}
+async function completeMessageStep({
+  assistantMessageId,
+  sessionContext,
+  writable,
+  usageSteps
+}) {
+  "use step";
+  const log2 = createLogger({
+    config: {
+      ...sessionContext.agent.options.logging,
+      name: sessionContext.agent.name
+    },
+    subsystem: "ai-loop"
+  });
+  const msgLog = log2.withContext({
+    sessionId: sessionContext.sessionId,
+    messageId: assistantMessageId
+  });
+  const usage2 = usageSteps.length > 0 ? {
+    steps: usageSteps,
+    summary: {
+      model: usageSteps[0]?.model ?? "unknown",
+      inputTokens: usageSteps.reduce((a, s) => a + s.inputTokens, 0),
+      outputTokens: usageSteps.reduce((a, s) => a + s.outputTokens, 0),
+      totalTokens: usageSteps.reduce((a, s) => a + s.totalTokens, 0),
+      cacheReadTokens: usageSteps.reduce(
+        (a, s) => a + s.cacheReadTokens,
+        0
+      ),
+      cacheWriteTokens: usageSteps.reduce(
+        (a, s) => a + s.cacheWriteTokens,
+        0
+      ),
+      reasoningTokens: usageSteps.reduce(
+        (a, s) => a + s.reasoningTokens,
+        0
+      ),
+      stepCount: usageSteps.length
+    }
+  } : null;
+  await Promise.all([
+    sessionContext.agent.storage.message.update(assistantMessageId, {
+      completedAt: Date.now(),
+      usage: usage2
+    }),
+    writable.close().catch(() => void 0)
+  ]);
+  msgLog.info("message completed", {
+    steps: usageSteps.length,
+    totalTokens: usage2?.summary.totalTokens
+  });
+}
+function approvalPartId(approvalId) {
+  return `part_${approvalId}`;
+}
+function replayActiveRun(active, startIndex = 0) {
+  let cursor = startIndex;
+  let cancelled = false;
+  return new ReadableStream({
+    async pull(controller) {
+      while (cursor < active.chunks.length) {
+        controller.enqueue(active.chunks[cursor++]);
+      }
+      while (!cancelled && cursor >= active.chunks.length) {
+        const result = await Promise.race([
+          active.onChunk.then(() => "chunk"),
+          active.done.then(() => "done")
+        ]);
+        while (cursor < active.chunks.length) {
+          controller.enqueue(active.chunks[cursor++]);
+        }
+        if (result === "done") {
+          controller.close();
+          return;
+        }
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+}
+function toMessageAndParts({
+  sessionId,
+  id,
+  input,
+  defaultRole
+}) {
+  let messageId = id ?? `message_${ulid()}`;
+  if (typeof input === "string") {
+    const now2 = Date.now();
+    return {
+      approvals: [],
+      message: {
+        id: messageId,
+        sessionId,
+        role: defaultRole,
+        createdAt: now2,
+        startedAt: null,
+        completedAt: null,
+        interruptedAt: null,
+        interruptedLastPart: null,
+        usage: null,
+        workflowRunId: null,
+        metadata: null
+      },
+      parts: [
+        {
+          sessionId,
+          messageId,
+          id: `part_${messageId}_0`,
+          index: 0,
+          part: { type: "text", text: input }
+        }
+      ]
+    };
+  }
+  if ("type" in input && input.type === "approval") {
+    return {
+      message: void 0,
+      parts: [],
+      approvals: [input.approval]
+    };
+  }
+  const msg = "type" in input && input.type === "message" ? input.message : input;
+  if ("id" in msg && msg.id) {
+    messageId = msg.id;
+  }
+  const now = Date.now();
+  const metadata = "metadata" in msg && msg.metadata != null ? msg.metadata : null;
+  return {
+    approvals: [],
+    message: {
+      sessionId,
+      id: messageId,
+      createdAt: now,
+      startedAt: null,
+      completedAt: null,
+      interruptedAt: null,
+      interruptedLastPart: null,
+      usage: null,
+      workflowRunId: null,
+      role: msg.role ?? defaultRole,
+      metadata
+    },
+    parts: msg.parts.map((part, index) => {
+      const ap = part;
+      const id2 = ap.approval?.id ? approvalPartId(ap.approval.id) : `part_${messageId}_${index}`;
+      return { sessionId, messageId, id: id2, index, part };
+    })
+  };
+}
+var SendError = class extends errore2.createTaggedError({
+  name: "SendError",
+  message: "Send failed for session $id: $reason"
+}) {
+};
+var ApprovalNotFoundError = class extends errore2.createTaggedError({
+  name: "ApprovalNotFoundError",
+  message: "Approval $approvalId not found in session $id"
+}) {
+};
+
+// src/tools/javascript.ts
+import { tool as tool2 } 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,
+  toolContext
+}) {
+  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 exec2 = t.execute.bind(t);
+      const execOptions = {
+        toolCallId: `js_${toolName}_${Date.now()}`,
+        messages: [],
+        experimental_context: toolContext
+      };
+      if (onSubToolCall) {
+        response = await onSubToolCall(
+          toolName,
+          input,
+          () => exec2(input, execOptions)
+        );
+      } else {
+        const result = await exec2(input, execOptions);
+        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 { sandbox, onSubToolCall } = opts;
+  const activeSet = opts.activeTools ? new Set(opts.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 tool2({
+    ...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,
+        toolContext: opts.toolContext
+      });
+    }
+  });
+}
+
+// src/tools/needs-approval.ts
+var builtinNeedsApproval = {};
+async function checkNeedsApproval({
+  agent: agent2,
+  toolName,
+  input,
+  toolCallId,
+  messages
+}) {
+  const toolDef = agent2.options.tools?.[toolName];
+  if (toolDef?.needsApproval != null) {
+    if (typeof toolDef.needsApproval === "boolean") {
+      return toolDef.needsApproval;
+    }
+    return await toolDef.needsApproval(input, {
+      toolCallId,
+      messages,
+      experimental_context: void 0
+    });
+  }
+  const agentEntry = agent2.options.needsApproval?.[toolName];
+  if (agentEntry != null) {
+    if (typeof agentEntry === "boolean") {
+      return agentEntry;
+    }
+    return await agentEntry(input, {
+      toolCallId,
+      messages,
+      experimental_context: void 0
+    });
+  }
+  return builtinNeedsApproval[toolName] ?? false;
+}
+
+// src/tools/index.ts
+var log = createLogger({ config: { name: "tools" }, subsystem: "tools" });
+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: tool3({
+    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("Absolute path to the file")
+      })
+    })
+  }),
+  Grep: tool3({
+    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: tool3({
+    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: tool3({
+    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: tool3({
+    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: tool3({
+    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: tool3({
+    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: tool3({
+    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({
+  agent: agent2,
+  sandbox,
+  skillsRef,
+  writer,
+  abortController,
+  nextPartIndexRef,
+  assistantMessageId,
+  sessionId,
+  stepLog,
+  context,
+  state,
+  messages,
+  activeTools
+}) {
+  const rawTools = {
+    [builtinToolNames.Read]: tool3({
+      ...builtInTools.Read,
+      execute: async ({ path, startLine, endLine }) => {
+        const filePath = path;
+        const result = await 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]: tool3({
+      ...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 sandbox.exec({ command: "rg", args });
+        if (result instanceof Error && isRgNotFoundError(result)) {
+          log.warn("rg not found, installing ripgrep");
+          const installResult = await 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 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 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]: tool3({
+      ...builtInTools.List,
+      execute: async ({ path, depth, includeHidden, filesOnly, pattern }) => {
+        const searchPath = path ?? ".";
+        const result = await 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]: tool3({
+      ...builtInTools.Write,
+      execute: async ({ path, content }) => {
+        const filePath = path;
+        try {
+          await sandbox.writeFiles({
+            files: [{ path: filePath, content }],
+            destPath: "."
+          });
+          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]: tool3({
+      ...builtInTools.Edit,
+      execute: async ({ path, old_string, new_string }) => {
+        const filePath = path;
+        const result = await 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);
+        try {
+          await sandbox.writeFiles({
+            files: [{ path: filePath, content: newContent }],
+            destPath: "."
+          });
+          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]: tool3({
+      ...builtInTools.Bash,
+      execute: async ({ command, waitUntil }) => {
+        const { createProcessManager } = await import("./process-manager-WQHAIVRB.mjs");
+        const processManager = createProcessManager({ 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 };
+      }
+    })
+  };
+  for (const [name, t] of Object.entries(agent2.options.tools ?? {})) {
+    rawTools[name] = t;
+  }
+  if (skillsRef.current.length > 0) {
+    rawTools[builtinToolNames.Skill] = tool3({
+      ...builtInTools.Skill,
+      execute: async ({ name }) => {
+        const skills = 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 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
+        };
+      }
+    });
+  }
+  const onSubToolCall = async (toolName, toolInput, execute) => {
+    const needsApproval = await checkNeedsApproval({
+      agent: agent2,
+      toolName,
+      input: toolInput,
+      toolCallId: `js_${toolName}_${Date.now()}`,
+      messages: []
+    });
+    if (!needsApproval) {
+      try {
+        const result = await execute();
+        return { result };
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+    const approvalId = `js_approval_${ulid2()}`;
+    const toolCallId = `js_tc_${ulid2()}`;
+    const partId = approvalPartId(approvalId);
+    await agent2.storage.part.set(partId, {
+      id: partId,
+      index: nextPartIndexRef.current++,
+      messageId: assistantMessageId,
+      sessionId,
+      part: {
+        type: `tool-${toolName}`,
+        toolCallId,
+        state: "approval-requested",
+        input: toolInput,
+        approval: { id: approvalId }
+      }
+    });
+    writer.write({
+      type: "tool-input-start",
+      toolCallId,
+      toolName
+    });
+    writer.write({
+      type: "tool-input-available",
+      toolCallId,
+      toolName,
+      input: toolInput
+    });
+    writer.write({
+      type: "tool-approval-request",
+      approvalId,
+      toolCallId
+    });
+    const POLL_MS = 500;
+    const TIMEOUT_MS = 5 * 60 * 1e3;
+    const start2 = Date.now();
+    while (Date.now() - start2 < TIMEOUT_MS && !abortController.signal.aborted) {
+      const updated = await agent2.storage.part.get(partId);
+      if (updated && "state" in updated.part && (updated.part.state === "approval-responded" || updated.part.state === "output-denied")) {
+        const state2 = updated.part.state;
+        if (state2 === "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 result = await execute();
+            writer.write({
+              type: "tool-output-available",
+              toolCallId,
+              output: result
+            });
+            return { result };
+          } catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            writer.write({
+              type: "tool-output-error",
+              toolCallId,
+              errorText: error
+            });
+            return { error };
+          }
+        }
+        writer.write({
+          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 toolContext = {
+    context,
+    state,
+    sessionId,
+    sandbox,
+    messages
+  };
+  rawTools[builtinToolNames.JavaScript] = createJavaScriptTool({
+    tools: rawTools,
+    sandbox,
+    activeTools,
+    onSubToolCall,
+    toolContext
+  });
+  const toolsWithNeedsApproval = Object.fromEntries(
+    Object.entries(rawTools).map(([name, t]) => {
+      const originalExecute = t.execute;
+      const wrappedExecute = originalExecute ? async (...args) => {
+        const done = stepLog.time(`tool:${name}`);
+        try {
+          let toolInput = args[0];
+          if (agent2.hooks["tool.before"]) {
+            const beforeResult = await agent2.hooks["tool.before"]({
+              name,
+              input: toolInput,
+              context: toolContext
+            });
+            if (beforeResult?.input !== void 0) {
+              toolInput = beforeResult.input;
+              args[0] = toolInput;
+            }
+          }
+          let result = await originalExecute(...args);
+          if (agent2.hooks["tool.after"]) {
+            const afterResult = await agent2.hooks["tool.after"]({
+              name,
+              input: toolInput,
+              result,
+              context: toolContext
+            });
+            if (afterResult?.result !== void 0) {
+              result = afterResult.result;
+            }
+          }
+          done();
+          return result;
+        } 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) => {
+            return await checkNeedsApproval({
+              agent: agent2,
+              toolName: name,
+              input: toolInput,
+              toolCallId: opts.toolCallId,
+              messages: opts.messages
+            });
+          }
+        }
+      ];
+    })
+  );
+  return { rawTools, toolsWithNeedsApproval, toolContext };
+}
+
+// src/agent/registry.ts
+import * as errore3 from "errore";
+import { z as z3 } from "zod";
+var AgentStatus = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("sandbox-setup") }),
+  z3.object({ type: z3.literal("sandbox-setup-cold") }),
+  z3.object({ type: z3.literal("loading-skills") }),
+  z3.object({ type: z3.literal("processing-approvals") }),
+  z3.object({ type: z3.literal("needs-approval") }),
+  z3.object({ type: z3.literal("thinking") }),
+  z3.object({ type: z3.literal("custom"), status: z3.string() })
+]);
+var AgentNotFoundError = class extends errore3.createTaggedError({
+  name: "AgentNotFoundError",
+  message: `Agent "$agentName" not found in registry.
+
+hint: agent() must be called before workflow steps execute.
+      Valid locations: module scope, or inside a "use workflow" body.
+
+  // Module scope (static agents)
+  export const myAgent = agent("$agentName", { ... });
+
+  // Workflow body (dynamic agents)
+  async function myWorkflow({ input }) {
+    "use workflow";
+    const myAgent = agent("$agentName", { ... });
+    ...
+  }`
+}) {
+};
+var AGENT_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("experimental-agent-registry");
+function getAgentRegistry() {
+  const g = globalThis;
+  let registry = g[AGENT_REGISTRY_KEY];
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    g[AGENT_REGISTRY_KEY] = registry;
+  }
+  return registry;
+}
+function registerAgent(name, agent2) {
+  getAgentRegistry().set(name, agent2);
+}
+function getAgent(name, required) {
+  const agent2 = getAgentRegistry().get(name);
+  if (required && !agent2) {
+    throw new AgentNotFoundError({ agentName: name });
+  }
+  return agent2;
+}
+
+// src/agent/client.ts
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+
+// src/sandbox/handle.ts
+import { ulid as ulid3 } from "ulid";
+
+// src/agent/is-vercel.ts
+var isVercel = async () => {
+  try {
+    const { getVercelOidcToken } = await import("@vercel/oidc");
+    return Boolean(await getVercelOidcToken());
+  } catch {
+    return false;
+  }
+};
+
+// src/sandbox/setup.ts
+var POLL_INTERVAL_MS = 50;
+var POLL_TIMEOUT_MS = 5 * 60 * 1e3;
+function isSingleBinding(sandbox) {
+  return !Array.isArray(sandbox);
+}
+async function getDefaultBinding() {
+  if (await isVercel()) {
+    const { vercelSandbox } = await import("./vercel-7TYF67KD.mjs");
+    return vercelSandbox();
+  }
+  if (await isDockerAvailable()) {
+    const { dockerSandbox } = await import("./docker-OBUQX5ZI.mjs");
+    return dockerSandbox();
+  }
+  const { localSandbox } = await import("./local-4C3V4EFS.mjs");
+  return localSandbox();
+}
+async function isDockerAvailable() {
+  try {
+    const { execSync } = await import("child_process");
+    execSync("docker sandbox --help", { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBinding(sandbox, type) {
+  if (!sandbox) {
+    const binding = await getDefaultBinding();
+    return { binding, bindingName: binding.type };
+  }
+  if (isSingleBinding(sandbox)) {
+    return { binding: sandbox, bindingName: sandbox.type };
+  }
+  if (type) {
+    const match = sandbox.find((b) => b.type === type);
+    if (!match) {
+      throw new SandboxError({
+        reason: `Unknown binding type: "${type}". Available: ${sandbox.map((b) => b.type).join(", ")}`
+      });
+    }
+    return { binding: match, bindingName: match.type };
+  }
+  if (sandbox.length === 0) {
+    throw new SandboxError({ reason: "No sandbox bindings configured" });
+  }
+  return { binding: sandbox[0], bindingName: sandbox[0].type };
+}
+async function resolveSandboxId(ctx) {
+  if (ctx.sandboxId) {
+    return ctx.sandboxId;
+  }
+  if (!ctx._sessionId) {
+    throw new Error(
+      "SandboxContext has no sandboxId and no sessionId to resolve from"
+    );
+  }
+  const record = await ctx.agent.storage.session.get(ctx._sessionId);
+  ctx.sandboxId = record?.sandboxId ?? ctx._sessionId;
+  return ctx.sandboxId;
+}
+async function setup(ctx, opts) {
+  "use step";
+  const sandboxId = await resolveSandboxId(ctx);
+  if (ctx._pendingSetup) {
+    return { done: ctx._pendingSetup };
+  }
+  const agent2 = ctx.agent;
+  const log2 = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "sandbox:setup",
+    context: { sandboxId }
+  });
+  const doneResolveBinding = log2.time("resolve binding", {
+    requestedType: opts?.type
+  });
+  const { binding, bindingName } = await resolveBinding(
+    agent2.options.sandbox,
+    opts?.type
+  );
+  doneResolveBinding();
+  if (opts?.cwd) {
+    ctx._cwd = opts.cwd;
+  }
+  const setupLog = log2.withContext({
+    binding: bindingName,
+    version: opts?.version ?? binding.defaults?.version
+  });
+  let resolveBlockingPromise = (value) => value;
+  let rejectBlockingPromise = (_reason) => {
+  };
+  const blockingPromise = new Promise((resolve2, reject) => {
+    resolveBlockingPromise = resolve2;
+    rejectBlockingPromise = reject;
+  });
+  ctx._pendingSetup = (async () => {
+    let sleepOldInstance;
+    const donePendingSetup = setupLog.time("pending setup");
+    try {
+      const doneStorageGet = setupLog.time("storage.sandbox.get");
+      const record = await agent2.storage.sandbox.get(sandboxId);
+      doneStorageGet();
+      const bindingDefaults = binding.defaults ?? {};
+      const effectiveVersion = opts?.version ?? bindingDefaults.version ?? null;
+      const effectiveRun = opts?.run ?? bindingDefaults.run;
+      const effectiveNetworkPolicy = opts?.networkPolicy ?? bindingDefaults.networkPolicy ?? null;
+      const effectiveCwd = ctx._cwd || opts?.cwd || bindingDefaults.cwd || null;
+      if (effectiveCwd) {
+        ctx._cwd = effectiveCwd;
+      }
+      const effectiveConfig = {
+        ...bindingDefaults.config,
+        // biome-ignore lint/suspicious/noExplicitAny: opts is a union; config exists on binding-specific branches
+        ...opts?.config
+      };
+      if (record) {
+        const versionMatches = !effectiveVersion || record.setup?.version === effectiveVersion;
+        if (versionMatches && record.setup?.completedAt) {
+          resolveBlockingPromise();
+          const doneConnectExisting = setupLog.time(
+            "connect existing sandbox",
+            {
+              setupState: "completed"
+            }
+          );
+          const instance = await binding.connect({
+            agent: agent2,
+            metadata: record.setup.metadata,
+            cwd: record.setup.cwd,
+            signal: opts?.signal,
+            log: setupLog
+          });
+          doneConnectExisting();
+          ctx._cwd = instance.cwd;
+          return instance;
+        }
+        if (versionMatches && !record.setup?.completedAt) {
+          resolveBlockingPromise();
+          const donePollUntilReady = setupLog.time("poll until ready");
+          await pollUntilReady(ctx, opts?.signal);
+          donePollUntilReady();
+          const doneStorageGetPostPoll = setupLog.time(
+            "storage.sandbox.get (post-poll)"
+          );
+          const ready = await agent2.storage.sandbox.get(sandboxId);
+          doneStorageGetPostPoll();
+          if (!ready) {
+            throw new SandboxNotFoundError({ id: sandboxId });
+          }
+          const doneConnectExisting = setupLog.time(
+            "connect existing sandbox",
+            {
+              setupState: "post-poll"
+            }
+          );
+          const instance = await binding.connect({
+            agent: agent2,
+            metadata: ready.setup.metadata,
+            cwd: ready.setup.cwd,
+            signal: opts?.signal,
+            log: setupLog
+          });
+          doneConnectExisting();
+          ctx._cwd = instance.cwd;
+          return instance;
+        }
+        if (record.setup.metadata) {
+          const oldInstanceMetadata = record.setup.metadata;
+          sleepOldInstance = (async () => {
+            const doneStopOldInstance = setupLog.time(
+              "stop old sandbox instance"
+            );
+            try {
+              const old = await binding.connect({
+                agent: agent2,
+                metadata: oldInstanceMetadata,
+                log: setupLog
+              });
+              await old.stop();
+            } catch {
+              doneStopOldInstance();
+              return;
+            }
+            doneStopOldInstance();
+          })();
+        }
+      }
+      const now = Date.now();
+      const setup_ = {
+        binding: bindingName,
+        version: effectiveVersion ?? record?.setup?.version ?? null,
+        networkPolicy: effectiveNetworkPolicy ?? record?.setup?.networkPolicy ?? null,
+        completedAt: null,
+        metadata: null,
+        cwd: null
+      };
+      const newRecord = {
+        id: sandboxId,
+        setup: setup_,
+        createdAt: record?.createdAt ?? now,
+        lastActiveAt: now
+      };
+      const doneStorageSetPending = setupLog.time(
+        "storage.sandbox.set (setup pending)"
+      );
+      await agent2.storage.sandbox.set(sandboxId, newRecord);
+      doneStorageSetPending();
+      resolveBlockingPromise();
+      const doneBindingCreate = setupLog.time("binding.create");
+      const result = await binding.create({
+        cwd: ctx._cwd ?? ".",
+        agent: agent2,
+        setup: {
+          ...setup_,
+          run: effectiveRun,
+          config: effectiveConfig
+        },
+        record: newRecord,
+        signal: opts?.signal,
+        log: setupLog
+      });
+      doneBindingCreate();
+      setup_.completedAt = Date.now();
+      setup_.metadata = result.metadata;
+      setup_.cwd = result.instance.cwd;
+      const doneStorageUpdateComplete = setupLog.time(
+        "storage.sandbox.update (setup complete)"
+      );
+      await agent2.storage.sandbox.update(sandboxId, {
+        setup: setup_,
+        lastActiveAt: Date.now()
+      });
+      doneStorageUpdateComplete();
+      ctx._cwd = result.instance.cwd;
+      return result.instance;
+    } catch (err) {
+      ctx._pendingSetup = void 0;
+      rejectBlockingPromise(err);
+      throw err;
+    } finally {
+      const doneFinalize = setupLog.time("finalize setup");
+      await sleepOldInstance;
+      doneFinalize();
+      donePendingSetup();
+    }
+  })();
+  const doneWaitForUnblock = setupLog.time("wait for setup unblock");
+  await blockingPromise;
+  doneWaitForUnblock();
+  return { done: ctx._pendingSetup };
+}
+async function resolve(ctx, signal) {
+  const sandboxId = await resolveSandboxId(ctx);
+  const agent2 = ctx.agent;
+  const log2 = createLogger({
+    config: { ...agent2.options.logging, name: agent2.name },
+    subsystem: "sandbox:resolve",
+    context: { sandboxId }
+  });
+  if (ctx._pendingSetup) {
+    return await ctx._pendingSetup;
+  }
+  let record = await agent2.storage.sandbox.get(sandboxId);
+  if (!record) {
+    const { done } = await setup(ctx, { signal });
+    return await done;
+  }
+  if (!record.setup?.completedAt) {
+    await pollUntilReady(ctx, signal);
+    record = await agent2.storage.sandbox.get(sandboxId);
+  }
+  if (!record) {
+    throw new SandboxNotFoundError({ id: sandboxId });
+  }
+  const { binding } = await resolveBinding(
+    ctx.agent.options.sandbox,
+    record.setup.binding
+  );
+  agent2.storage.sandbox.update(sandboxId, { lastActiveAt: Date.now() }).catch((error) => {
+    log2.error("Failed to update sandbox lastActiveAt", { error });
+  });
+  const instance = await binding.connect({
+    agent: agent2,
+    metadata: record.setup.metadata,
+    cwd: record.setup.cwd,
+    signal,
+    log: log2
+  });
+  ctx._cwd = instance.cwd;
+  return instance;
+}
+async function pollUntilReady(ctx, signal) {
+  const id = ctx.sandboxId;
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    signal?.throwIfAborted();
+    const record = await ctx.agent.storage.sandbox.get(id);
+    if (record?.setup?.completedAt) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+  throw new SandboxError({
+    reason: `Timed out waiting for sandbox "${id}" setup to complete`
+  });
+}
+
+// src/sandbox/exec.ts
+async function exec(sandboxContext, ...opts) {
+  const sbx = await resolve(sandboxContext);
+  return await sbx.exec(...opts);
+}
+
+// src/sandbox/get-domain.ts
+async function getDomain(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.getDomain(...opts);
+}
+
+// src/sandbox/get-status.ts
+async function getStatus(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.getStatus(...opts);
+}
+
+// src/sandbox/kill.ts
+async function kill(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.kill(...opts);
+}
+
+// src/sandbox/read-file.ts
+async function readFile(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.readFile(...opts);
+}
+
+// src/sandbox/snapshot.ts
+async function snapshot(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.snapshot(...opts);
+}
+
+// src/sandbox/start.ts
+async function start(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.start(...opts);
+}
+
+// src/sandbox/stop.ts
+async function stop(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.stop(...opts);
+}
+
+// src/sandbox/update-network-policy.ts
+async function updateNetworkPolicy(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.updateNetworkPolicy(...opts);
+}
+
+// src/sandbox/write-files.ts
+async function writeFiles(sandboxContext, ...opts) {
+  "use step";
+  const sbx = await resolve(sandboxContext);
+  return await sbx.writeFiles(...opts);
+}
+
+// src/sandbox/handle.ts
+function sandboxHandle(agent2, id) {
+  const sandboxId = typeof id === "string" ? id : id?.id ?? `sandbox_${ulid3()}`;
+  const contexts = getSandboxContexts(agent2);
+  let sandboxContext = contexts.get(sandboxId);
+  if (!sandboxContext) {
+    sandboxContext = { agent: agent2, sandboxId };
+    contexts.set(sandboxId, sandboxContext);
+  }
+  return {
+    id: sandboxId,
+    get cwd() {
+      return sandboxContext._cwd ?? ".";
+    },
+    setup: setup.bind(null, sandboxContext),
+    exec: exec.bind(null, sandboxContext),
+    readFile: readFile.bind(null, sandboxContext),
+    writeFiles: writeFiles.bind(null, sandboxContext),
+    getDomain: getDomain.bind(null, sandboxContext),
+    updateNetworkPolicy: updateNetworkPolicy.bind(null, sandboxContext),
+    start: start.bind(null, sandboxContext),
+    stop: stop.bind(null, sandboxContext),
+    kill: kill.bind(null, sandboxContext),
+    snapshot: snapshot.bind(null, sandboxContext),
+    getStatus: getStatus.bind(null, sandboxContext)
+  };
+}
+function lazySandboxHandle(agent2, sessionId) {
+  const sandboxContext = {
+    agent: agent2,
+    sandboxId: null,
+    _sessionId: sessionId
+  };
+  return {
+    setup: setup.bind(null, sandboxContext),
+    exec: exec.bind(null, sandboxContext),
+    readFile: readFile.bind(null, sandboxContext),
+    writeFiles: writeFiles.bind(null, sandboxContext),
+    getDomain: getDomain.bind(null, sandboxContext),
+    updateNetworkPolicy: updateNetworkPolicy.bind(null, sandboxContext),
+    start: start.bind(null, sandboxContext),
+    stop: stop.bind(null, sandboxContext),
+    kill: kill.bind(null, sandboxContext),
+    snapshot: snapshot.bind(null, sandboxContext),
+    getStatus: getStatus.bind(null, sandboxContext)
+  };
+}
+
+// src/session/handle.ts
+import { ulid as ulid4 } from "ulid";
+
+// src/utils/usage.ts
+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/session/history.ts
+async function history(sessionContext) {
+  "use step";
+  const [session, messages, parts] = await Promise.all([
+    sessionContext.agent.storage.session.get(sessionContext.sessionId),
+    sessionContext.agent.storage.message.listBySession(
+      sessionContext.sessionId
+    ),
+    sessionContext.agent.storage.part.listBySession(sessionContext.sessionId)
+  ]);
+  const lastAssistant = messages.find(
+    (m) => m.id === session?.lastMessageId && m.role === "assistant"
+  ) ?? messages.filter((m) => m.role === "assistant").at(-1);
+  const isStreaming = lastAssistant?.completedAt === null && lastAssistant?.interruptedAt === null;
+  const streamingMessageId = isStreaming ? lastAssistant.id : null;
+  const visibleUntil = lastAssistant?.createdAt;
+  const assembled = assembleUIMessages({
+    messages,
+    parts,
+    includeQueued: visibleUntil !== void 0,
+    until: visibleUntil
+  });
+  const usage2 = computeSessionUsage(messages);
+  return { messages: assembled, streamingMessageId, usage: usage2 };
+}
+
+// src/session/stream.ts
+import * as errore4 from "errore";
+function isWorkflowRun(arg) {
+  return typeof arg === "object" && arg !== null && "getReadable" in arg && typeof arg.getReadable === "function";
+}
+async function stream(sessionContext, runOrOpts) {
+  if (isWorkflowRun(runOrOpts)) {
+    const reader = runOrOpts.getReadable().getReader();
+    await reader.read().catch(() => {
+      throw new StreamError({
+        id: sessionContext.sessionId,
+        reason: "stream() failed to read first chunk from workflow run"
+      });
+    });
+    reader.cancel();
+    return runOrOpts.getReadable();
+  }
+  const opts = runOrOpts;
+  const session = await sessionContext.agent.storage.session.get(
+    sessionContext.sessionId
+  );
+  if (!session) {
+    throw new SessionNotFoundError({ id: sessionContext.sessionId });
+  }
+  const messageId = opts?.messageId ?? session.lastMessageId;
+  if (!messageId) {
+    throw new StreamError({
+      id: sessionContext.sessionId,
+      reason: "No message to stream"
+    });
+  }
+  const activeRuns = getActiveRuns();
+  const active = activeRuns.get(messageId);
+  if (!active) {
+    const message = await sessionContext.agent.storage.message.get(messageId);
+    if (message?.workflowRunId) {
+      const readable = await import("workflow/api").then(({ getRun }) => getRun(message.workflowRunId).getReadable()).catch(() => void 0);
+      if (readable) {
+        return readable;
+      }
+    }
+    throw new StreamError({
+      id: sessionContext.sessionId,
+      reason: `No active run for message ${messageId}`
+    });
+  }
+  return replayActiveRun(active, opts?.startIndex);
+}
+var StreamError = class extends errore4.createTaggedError({
+  name: "StreamError",
+  message: "Stream failed for session $id: $reason"
+}) {
+};
+
+// src/session/update.ts
+async function update(sessionContext, opts) {
+  "use step";
+  const updates = Object.fromEntries(
+    Object.entries(opts).filter(([, value]) => value !== void 0)
+  );
+  if (Object.keys(updates).length === 0) {
+    return;
+  }
+  await sessionContext.agent.storage.session.update(sessionContext.sessionId, {
+    ...updates,
+    updatedAt: Date.now()
+  });
+}
+
+// src/session/usage.ts
+async function usage(sessionContext) {
+  "use step";
+  const messages = await sessionContext.agent.storage.message.listBySession(
+    sessionContext.sessionId
+  );
+  return computeSessionUsage(messages);
+}
+
+// src/session/handle.ts
+function sessionHandle(agent2, id) {
+  const sessionId = typeof id === "string" ? id : id?.id ?? `session_${ulid4()}`;
+  const contexts = getSessionContexts(agent2);
+  let sessionContext = contexts.get(sessionId);
+  if (!sessionContext) {
+    sessionContext = { agent: agent2, sessionId };
+    contexts.set(sessionId, sessionContext);
+  }
+  return {
+    id: sessionId,
+    send: send.bind(
+      null,
+      sessionContext
+    ),
+    stream: stream.bind(null, sessionContext),
+    history: history.bind(null, sessionContext),
+    interrupt: interrupt.bind(null, sessionContext),
+    usage: usage.bind(null, sessionContext),
+    update: update.bind(null, sessionContext),
+    sandbox: lazySandboxHandle(agent2, sessionId)
+  };
+}
+
+// src/agent/client.ts
+var sessionContextsMap = /* @__PURE__ */ new WeakMap();
+var sandboxContextsMap = /* @__PURE__ */ new WeakMap();
+function getSessionContexts(agent2) {
+  let map = sessionContextsMap.get(agent2);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    sessionContextsMap.set(agent2, map);
+  }
+  return map;
+}
+function getSandboxContexts(agent2) {
+  let map = sandboxContextsMap.get(agent2);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    sandboxContextsMap.set(agent2, map);
+  }
+  return map;
+}
+var Agent = class _Agent {
+  name;
+  options;
+  constructor(name, options) {
+    this.name = name;
+    this.options = options ?? {};
+    this.session = sessionHandle.bind(null, this);
+    this.sandbox = sandboxHandle.bind(
+      null,
+      this
+    );
+  }
+  static [WORKFLOW_SERIALIZE](instance) {
+    return { name: instance.name };
+  }
+  static [WORKFLOW_DESERIALIZE](data) {
+    return getAgent(data.name, true);
+  }
+  _resolvedStorage;
+  get storage() {
+    if (this._resolvedStorage) {
+      return this._resolvedStorage;
+    }
+    if (this.options.storage) {
+      this._resolvedStorage = toStorage(this.options.storage);
+      return this._resolvedStorage;
+    }
+    const log2 = createLogger({
+      config: { ...this.options.logging, name: this.name },
+      subsystem: "storage"
+    });
+    if (shouldFallbackToKV2()) {
+      log2.info(
+        `No storage adapter configured \u2014 using KV2 (namespace: "${this.name}").`
+      );
+      this._resolvedStorage = toStorage(
+        kvStorageFallback({ prefix: this.name })
+      );
+      return this._resolvedStorage;
+    }
+    log2.warn(
+      "No storage adapter configured \u2014 using localStorage(). Data will not persist across restarts."
+    );
+    this._resolvedStorage = toStorage(localStorage());
+    return this._resolvedStorage;
+  }
+  get tools() {
+    return { ...builtInTools, ...this.options.tools };
+  }
+  get hooks() {
+    return this.options.hooks ?? {};
+  }
+  session;
+  sandbox;
+  /**
+   * Create a derived agent with merged options. The returned agent is NOT
+   * registered in the workflow registry – it's a one-off instance used by
+   * the framework to layer fs-scanned config onto an agent.ts definition.
+   */
+  extend(fn) {
+    return new _Agent(this.name, fn(this.options));
+  }
+};
+function agent(name, options) {
+  const instance = new Agent(name, options);
+  registerAgent(name, instance);
+  return instance;
+}
+
+export {
+  SessionNotFoundError,
+  SandboxNotFoundError,
+  StorageError,
+  StorageConflictError,
+  SandboxError,
+  MessageNotFoundError,
+  tool,
+  builtinToolNames,
+  AgentStatus,
+  agent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/errors.ts", "../src/tools/tool.ts", "../src/tools/index.ts", "../src/session/send.ts", "../src/session/ai-loop/stream-text.ts", "../src/skills/parser.ts", "../src/skills/discover.ts", "../src/skills/resolve-host.ts", "../src/skills/resolve-inline.ts", "../src/skills/resolve-remote.ts", "../src/skills/resolve.ts", "../src/utils/prompt-cache.ts", "../src/utils/ui.ts", "../src/session/interrupt.ts", "../src/tools/javascript.ts", "../src/tools/needs-approval.ts", "../src/agent/registry.ts", "../src/agent/client.ts", "../src/sandbox/handle.ts", "../src/agent/is-vercel.ts", "../src/sandbox/setup.ts", "../src/sandbox/exec.ts", "../src/sandbox/get-domain.ts", "../src/sandbox/get-status.ts", "../src/sandbox/kill.ts", "../src/sandbox/read-file.ts", "../src/sandbox/snapshot.ts", "../src/sandbox/start.ts", "../src/sandbox/stop.ts", "../src/sandbox/update-network-policy.ts", "../src/sandbox/write-files.ts", "../src/session/handle.ts", "../src/utils/usage.ts", "../src/session/history.ts", "../src/session/stream.ts", "../src/session/update.ts", "../src/session/usage.ts"],
  "sourcesContent": ["import * as errore from \"errore\";\n\nexport class SessionNotFoundError extends errore.createTaggedError({\n  name: \"SessionNotFoundError\",\n  message: \"Session $id not found\",\n}) {}\n\nexport class SessionError extends errore.createTaggedError({\n  name: \"SessionError\",\n  message: \"Session $id failed: $reason\",\n}) {}\n\nexport class SandboxNotFoundError extends errore.createTaggedError({\n  name: \"SandboxNotFoundError\",\n  message: \"Sandbox $id not found\",\n}) {}\n\nexport class StorageError extends errore.createTaggedError({\n  name: \"StorageError\",\n  message: \"$reason\",\n}) {}\n\nexport class StorageConflictError extends errore.createTaggedError({\n  name: \"StorageConflictError\",\n  message: \"$reason\",\n}) {}\n\nexport class SandboxError extends errore.createTaggedError({\n  name: \"SandboxError\",\n  message: \"$reason\",\n}) {}\n\nexport class MessageNotFoundError extends errore.createTaggedError({\n  name: \"MessageNotFoundError\",\n  message: \"Message $id not found\",\n}) {}\n", "import {\n  tool as aiTool,\n  type Tool,\n  type ToolExecutionOptions,\n  type UIMessage,\n} from \"ai\";\nimport type { z } from \"zod\";\nimport type { SandboxInstance } from \"../sandbox/adapter\";\nimport type { ToolContext } from \"./index\";\n\n/**\n * Define an agent tool with typed context and state.\n *\n * Pass the same `contextSchema` and/or `stateSchema` (Zod objects) used in\n * your agent definition to get typed `context` and `state` inside `execute`.\n *\n * ```ts\n * import { tool } from \"experimental-agent\";\n * import { contextSchema, stateSchema } from \"./context\";\n *\n * export const MyTool = tool({\n *   contextSchema,\n *   stateSchema,\n *   inputSchema: z.object({ query: z.string() }),\n *   execute: async ({ query }, { context, state, sandbox }) => {\n *     context.channelId // \u2713 typed from contextSchema\n *     state.counter++   // \u2713 typed from stateSchema, mutable\n *   },\n * });\n * ```\n */\nexport function tool<\n  TInputSchema extends z.ZodType,\n  TContextSchema extends z.ZodType = z.ZodType<Record<string, unknown>>,\n  TStateSchema extends z.ZodType = z.ZodType<Record<string, unknown>>,\n  // biome-ignore lint/suspicious/noExplicitAny: default erased\n  TOutputSchema extends z.ZodType = z.ZodType<any>,\n>(def: {\n  description?: string;\n  inputSchema: TInputSchema;\n  outputSchema?: TOutputSchema;\n  contextSchema?: TContextSchema;\n  stateSchema?: TStateSchema;\n  execute?: (\n    input: z.infer<TInputSchema>,\n    options: ToolContext<z.infer<TContextSchema>, z.infer<TStateSchema>> & {\n      toolCallId: string;\n      abortSignal: AbortSignal;\n    }\n    // biome-ignore lint/suspicious/noExplicitAny: execute can return anything\n  ) => any;\n  // biome-ignore lint/suspicious/noExplicitAny: erased tool generics\n}): Tool<any, any> {\n  const { execute, contextSchema, stateSchema, ...rest } = def;\n\n  const wrappedExecute = execute\n    ? // biome-ignore lint/suspicious/noExplicitAny: input type erased at runtime\n      (input: any, options: ToolExecutionOptions) => {\n        const ctx = options.experimental_context as {\n          context: unknown;\n          state: unknown;\n          sessionId: string;\n          messages: UIMessage[];\n          sandbox: SandboxInstance;\n        };\n\n        const context = (\n          contextSchema ? contextSchema.parse(ctx.context) : ctx.context\n        ) as z.infer<TContextSchema>;\n\n        if (stateSchema) {\n          stateSchema.parse(ctx.state);\n        }\n        const state = ctx.state as z.infer<TStateSchema>;\n\n        return execute(input, {\n          toolCallId: options.toolCallId,\n          abortSignal: options.abortSignal!,\n          context,\n          state,\n          sessionId: ctx.sessionId,\n          messages: ctx.messages,\n          sandbox: ctx.sandbox,\n        });\n      }\n    : undefined;\n\n  return wrappedExecute\n    ? aiTool({ ...rest, execute: wrappedExecute })\n    : // biome-ignore lint/suspicious/noExplicitAny: no-execute path needs cast\n      aiTool(rest as any);\n}\n", "import {\n  type ToolSet,\n  tool,\n  type UIMessage,\n  type UIMessageStreamWriter,\n} from \"ai\";\nimport { ulid } from \"ulid\";\nimport { z } from \"zod\";\nimport type { AnyAgent } from \"../agent/client\";\nimport type { SandboxInstance } from \"../sandbox/adapter\";\nimport { DEFAULT_WAIT_UNTIL } from \"../sandbox/process-manager\";\nimport { approvalPartId } from \"../session/send\";\nimport type { SkillSummary } from \"../skills/types\";\nimport { createLogger, type Logger } from \"../utils/logger\";\nimport { createJavaScriptTool, type OnSubToolCall } from \"./javascript\";\nimport { checkNeedsApproval } from \"./needs-approval\";\n\nexport { tool as agentTool } from \"./tool\";\n\nconst log = createLogger({ config: { name: \"tools\" }, subsystem: \"tools\" });\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 StreamWriter = UIMessageStreamWriter;\n\nexport type ToolContext<\n  TContext = Record<string, unknown>,\n  TState = Record<string, unknown>,\n> = {\n  context: TContext;\n  state: TState;\n  sessionId: string;\n  sandbox: SandboxInstance;\n  messages: UIMessage[];\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.string().describe(\"Absolute path to the file\"),\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({\n  agent,\n  sandbox,\n  skillsRef,\n  writer,\n  abortController,\n  nextPartIndexRef,\n  assistantMessageId,\n  sessionId,\n  stepLog,\n  context,\n  state,\n  messages,\n  activeTools,\n}: {\n  agent: AnyAgent;\n  sandbox: SandboxInstance;\n  skillsRef: { current: SkillSummary[] };\n  writer: StreamWriter;\n  abortController: AbortController;\n  nextPartIndexRef: { current: number };\n  assistantMessageId: string;\n  sessionId: string;\n  stepLog: Logger;\n  context: Record<string, unknown>;\n  state: Record<string, unknown>;\n  messages: UIMessage[];\n  activeTools?: string[];\n}): {\n  rawTools: ToolSet;\n  toolsWithNeedsApproval: ToolSet;\n  toolContext: ToolContext;\n} {\n  const rawTools: ToolSet = {\n    [builtinToolNames.Read]: tool({\n      ...builtInTools.Read,\n      execute: async ({ path, startLine, endLine }) => {\n        const filePath = path;\n\n        const result = await 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 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 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 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 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 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\n        try {\n          await sandbox.writeFiles({\n            files: [{ path: filePath, content }],\n            destPath: \".\",\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 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\n        try {\n          await sandbox.writeFiles({\n            files: [{ path: filePath, content: newContent }],\n            destPath: \".\",\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({ sandbox });\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  // Add user-defined tools\n  for (const [name, t] of Object.entries(agent.options.tools ?? {})) {\n    rawTools[name] = t as ToolSet[string];\n  }\n\n  if (skillsRef.current.length > 0) {\n    rawTools[builtinToolNames.Skill] = tool({\n      ...builtInTools.Skill,\n      execute: async ({ name }) => {\n        const skills = 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 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  const onSubToolCall: OnSubToolCall = async (toolName, toolInput, execute) => {\n    const needsApproval = await checkNeedsApproval({\n      agent,\n      toolName,\n      input: toolInput,\n      toolCallId: `js_${toolName}_${Date.now()}`,\n      messages: [],\n    });\n\n    if (!needsApproval) {\n      try {\n        const result = await execute();\n        return { result };\n      } catch (err) {\n        return {\n          error: err instanceof Error ? err.message : String(err),\n        };\n      }\n    }\n\n    const approvalId = `js_approval_${ulid()}`;\n    const toolCallId = `js_tc_${ulid()}`;\n    const partId = approvalPartId(approvalId);\n\n    await agent.storage.part.set(partId, {\n      id: partId,\n      index: nextPartIndexRef.current++,\n      messageId: assistantMessageId,\n      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    writer.write({\n      type: \"tool-input-start\",\n      toolCallId,\n      toolName,\n    });\n    writer.write({\n      type: \"tool-input-available\",\n      toolCallId,\n      toolName,\n      input: toolInput,\n    });\n    writer.write({\n      type: \"tool-approval-request\",\n      approvalId,\n      toolCallId,\n    });\n\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 updated = await agent.storage.part.get(partId);\n      if (\n        updated &&\n        \"state\" in updated.part &&\n        ((updated.part as { state: string }).state === \"approval-responded\" ||\n          (updated.part as { state: string }).state === \"output-denied\")\n      ) {\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            writer.write({\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            writer.write({\n              type: \"tool-output-error\",\n              toolCallId,\n              errorText: error,\n            });\n            return { error };\n          }\n        }\n        writer.write({\n          type: \"tool-output-denied\",\n          toolCallId,\n        });\n        return {\n          error: `Tool \"${toolName}\" denied: ${approval?.reason || \"user denied\"}`,\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 toolContext: ToolContext = {\n    context,\n    state,\n    sessionId,\n    sandbox,\n    messages: messages as ToolContext[\"messages\"],\n  };\n\n  rawTools[builtinToolNames.JavaScript] = createJavaScriptTool({\n    tools: rawTools,\n    sandbox,\n    activeTools,\n    onSubToolCall,\n    toolContext,\n  });\n\n  const toolsWithNeedsApproval = 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              let toolInput = args[0];\n              if (agent.hooks[\"tool.before\"]) {\n                const beforeResult = await agent.hooks[\"tool.before\"]({\n                  name,\n                  input: toolInput,\n                  context: toolContext,\n                });\n                if (beforeResult?.input !== undefined) {\n                  toolInput = beforeResult.input;\n                  args[0] = toolInput as (typeof args)[0];\n                }\n              }\n\n              let result = await originalExecute(...args);\n\n              if (agent.hooks[\"tool.after\"]) {\n                const afterResult = await agent.hooks[\"tool.after\"]({\n                  name,\n                  input: toolInput,\n                  result,\n                  context: toolContext,\n                });\n                if (afterResult?.result !== undefined) {\n                  result = afterResult.result as typeof result;\n                }\n              }\n\n              done();\n              return result;\n            } catch (e) {\n              done({\n                error: e instanceof Error ? e.message : String(e),\n              });\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            return await checkNeedsApproval({\n              agent,\n              toolName: name,\n              input: toolInput,\n              toolCallId: opts.toolCallId,\n              messages: opts.messages,\n            });\n          },\n        },\n      ];\n    })\n  );\n\n  return { rawTools, toolsWithNeedsApproval, toolContext };\n}\n", "import type { FinishReason, ToolSet, UIMessage, UIMessageChunk } from \"ai\";\nimport { all } from \"better-all\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport type { TypedUIMessage } from \"../agent/registry\";\nimport type { SkillSummary } from \"../skills/types\";\nimport type { Message, Part } from \"../storage/types\";\nimport { createLogger } from \"../utils/logger\";\nimport type { StepUsage } from \"../utils/usage\";\nimport {\n  type StreamTextResult,\n  streamText,\n  streamTextStep,\n} from \"./ai-loop/stream-text\";\nimport type { SessionContext } from \"./handle\";\nimport { interrupt } from \"./interrupt\";\n\nconst DEFAULT_STEP_THROUGHPUT = 100;\n\nexport type ApprovalData = {\n  approvalId: string;\n  approved: boolean;\n  reason?: string;\n};\n\ntype MessageData<Tools extends ToolSet, TMessageMetadata = unknown> =\n  | UIMessage<TMessageMetadata>\n  | {\n      role?: TypedUIMessage<unknown, Tools>[\"role\"];\n      parts: TypedUIMessage<unknown, Tools>[\"parts\"];\n      metadata?: TMessageMetadata | null;\n      id?: string;\n    };\n\nexport type SendInput<Tools extends ToolSet, TMessageMetadata = unknown> =\n  | string\n  | MessageData<Tools, TMessageMetadata>\n  | { type: \"message\"; message: MessageData<Tools, TMessageMetadata> }\n  | { type: \"approval\"; approval: ApprovalData };\n\nexport type SendOptions<TContext, TState = unknown> = {\n  interruptIfStreaming?:\n    | boolean\n    | { lastPart: { index: number; part: unknown } };\n  context?: TContext;\n  initialState?: TState;\n  abortSignal?: AbortSignal;\n  sandboxId?: string;\n};\n\nexport type SendResult = {\n  assistantMessageId: string;\n  done: true | Promise<true>;\n};\n\nexport type ActiveRun = {\n  chunks: UIMessageChunk[];\n  writable: WritableStream<UIMessageChunk>;\n  done: Promise<void>;\n  /** Resolves when a new chunk is available. Replaced after each notification. */\n  onChunk: Promise<void>;\n};\n\nconst ACTIVE_RUNS_KEY = Symbol.for(\"experimental-agent:activeRuns\");\n\nexport function getActiveRuns(): Map<string, ActiveRun> {\n  const g = globalThis as Record<symbol, Map<string, ActiveRun> | undefined>;\n  if (!g[ACTIVE_RUNS_KEY]) {\n    g[ACTIVE_RUNS_KEY] = new Map();\n  }\n  return g[ACTIVE_RUNS_KEY];\n}\n\nexport async function send<\n  Tools extends ToolSet,\n  TContext,\n  TMessageMetadata = unknown,\n  TState = unknown,\n>(\n  sessionContext: SessionContext,\n  input:\n    | SendInput<Tools, TMessageMetadata>\n    | SendInput<Tools, TMessageMetadata>[],\n  opts?: SendOptions<TContext, TState>\n): Promise<SendResult> {\n  if (opts?.interruptIfStreaming) {\n    const lastPart =\n      typeof opts.interruptIfStreaming === \"object\"\n        ? opts.interruptIfStreaming.lastPart\n        : undefined;\n    await interrupt(sessionContext, { lastPart });\n  }\n\n  const {\n    workflowRunId,\n    workflowWritable,\n    existingPartCount,\n    assistantMessageId,\n    assistantMessageCreatedAt,\n    state,\n  } = await errore.tryAsync({\n    try: () =>\n      initSessionStep<Tools>({\n        sessionContext,\n        sessionId: sessionContext.sessionId,\n        sandboxId: opts?.sandboxId,\n        initialState: opts?.initialState as Record<string, unknown> | undefined,\n        input,\n      }),\n    catch: (e) => {\n      if (e instanceof Error) {\n        throw e;\n      }\n      throw new SendError({\n        id: sessionContext.sessionId,\n        reason: String(e),\n        cause: e,\n      });\n    },\n  });\n\n  const loopOpts = {\n    sessionContext,\n    assistantMessageId,\n    createdAt: assistantMessageCreatedAt,\n    context: (opts?.context ?? {}) as Record<string, unknown>,\n    state,\n    lastPartIndex: existingPartCount,\n    workflowRunId,\n  };\n\n  if (workflowWritable) {\n    await runLoop<Tools>({ ...loopOpts, writable: workflowWritable });\n    return { assistantMessageId, done: true };\n  }\n\n  const chunks: UIMessageChunk[] = [];\n  let notifyChunk: () => void;\n  let onChunk = new Promise<void>((r) => {\n    notifyChunk = r;\n  });\n\n  const writable = new WritableStream<UIMessageChunk>({\n    write(chunk) {\n      chunks.push(chunk);\n      const prev = notifyChunk;\n      onChunk = new Promise<void>((r) => {\n        notifyChunk = r;\n      });\n      prev();\n    },\n  });\n\n  const done = runLoop<Tools>({ ...loopOpts, writable });\n\n  const activeRun: ActiveRun = {\n    chunks,\n    writable,\n    done,\n    get onChunk() {\n      return onChunk;\n    },\n  };\n  const activeRuns = getActiveRuns();\n  activeRuns.set(assistantMessageId, activeRun);\n  done.finally(() => activeRuns.delete(assistantMessageId));\n\n  return { assistantMessageId, done: done.then(() => true) };\n}\n\n/* -------------------------------------------------------------------------------------------------\n * AI Loop\n * -----------------------------------------------------------------------------------------------*/\n\nasync function runLoop<Tools extends ToolSet>({\n  workflowRunId,\n  sessionContext,\n  assistantMessageId,\n  createdAt,\n  context: initialContext,\n  state,\n  writable,\n  lastPartIndex: initialPartIndex,\n}: {\n  workflowRunId: string | undefined;\n  sessionContext: SessionContext;\n  assistantMessageId: string;\n  createdAt: number;\n  context: Record<string, unknown>;\n  state: Record<string, unknown>;\n  writable: WritableStream;\n  lastPartIndex: number;\n}): Promise<void> {\n  const agent = sessionContext.agent;\n\n  const log = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"ai-loop\",\n  });\n  const msgLog = log.withContext({\n    sessionId: sessionContext.sessionId,\n    messageId: assistantMessageId,\n  });\n  const doneMessage = msgLog.time(\"onMessage\");\n\n  let finishReason: FinishReason | undefined;\n  let lastPartIndex = initialPartIndex;\n  const usageSteps: StepUsage[] = [];\n  let discoveredSkills: SkillSummary[] | null = null;\n  let context = initialContext;\n\n  try {\n    while (finishReason !== \"stop\") {\n      const streamTextFn = workflowRunId\n        ? streamTextStep<Tools>\n        : streamText<Tools>;\n      const throughput = workflowRunId ? 5 : DEFAULT_STEP_THROUGHPUT;\n\n      const result: StreamTextResult = await streamTextFn({\n        stepThroughput: throughput,\n        assistantMessageId,\n        agent,\n        sessionId: sessionContext.sessionId,\n        context,\n        state,\n        createdAt,\n        writable,\n        lastPartIndex,\n        stepIndexOffset: usageSteps.length,\n        discoveredSkills,\n      });\n\n      finishReason = result.finishReason;\n      lastPartIndex = result.lastPartIndex;\n      usageSteps.push(...result.usageSteps);\n      discoveredSkills = result.discoveredSkills;\n      context = result.context;\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(\"pending approvals, stopping loop\", {\n          count: result.pendingApprovals.length,\n          tools: result.pendingApprovals.map((p) => p.toolName),\n        });\n        break;\n      }\n    }\n\n    doneMessage({ totalSteps: usageSteps.length });\n  } catch (err) {\n    msgLog.error(\"AI loop failed\", {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    throw err;\n  } finally {\n    await completeMessageStep({\n      assistantMessageId,\n      sessionContext,\n      writable,\n      usageSteps,\n    });\n  }\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Steps\n * -----------------------------------------------------------------------------------------------*/\n\nasync function initSessionStep<Tools extends ToolSet>({\n  sessionContext,\n  sessionId,\n  sandboxId,\n  initialState,\n  input,\n}: {\n  sessionContext: SessionContext;\n  sessionId: string;\n  sandboxId?: string;\n  initialState?: Record<string, unknown>;\n  input: SendInput<Tools> | SendInput<Tools>[];\n}) {\n  \"use step\";\n\n  let workflowRunId: string | undefined;\n  let workflowWritable: WritableStream | undefined;\n  try {\n    const { getWorkflowMetadata, getWritable } = await import(\"workflow\");\n    workflowRunId = getWorkflowMetadata().workflowRunId;\n    workflowWritable = getWritable();\n  } catch {\n    // workflow not installed\n  }\n\n  const newMessages: Message[] = [];\n  const newParts: Part[] = [];\n  const newApprovals: ApprovalData[] = [];\n  if (Array.isArray(input)) {\n    for (const i of input) {\n      const { message, parts, approvals } = toMessageAndParts({\n        sessionId: sessionContext.sessionId,\n        input: i,\n        defaultRole: \"user\",\n      });\n      if (message) {\n        newMessages.push(message);\n      }\n      newParts.push(...parts);\n      newApprovals.push(...approvals);\n    }\n  } else {\n    const { message, parts, approvals } = toMessageAndParts({\n      input,\n      sessionId: sessionContext.sessionId,\n      defaultRole: \"user\",\n    });\n    if (message) {\n      newMessages.push(message);\n    }\n    newParts.push(...parts);\n    newApprovals.push(...approvals);\n  }\n\n  const lastNewMessage = newMessages.at(-1);\n  const reuseAssistant = lastNewMessage?.role === \"assistant\";\n\n  const assistantMessageId = reuseAssistant\n    ? lastNewMessage.id\n    : `message_${ulid()}`;\n  const baseTime = Date.now();\n  const assistantMessageCreatedAt = baseTime + newMessages.length;\n\n  if (!reuseAssistant) {\n    newMessages.push({\n      id: assistantMessageId,\n      sessionId: sessionContext.sessionId,\n      role: \"assistant\",\n      createdAt: assistantMessageCreatedAt,\n      startedAt: null,\n      completedAt: null,\n      interruptedAt: null,\n      interruptedLastPart: null,\n      usage: null,\n      workflowRunId: null,\n      metadata: null,\n    });\n  }\n\n  const existingPartCount = reuseAssistant\n    ? newParts.filter((p) => p.messageId === assistantMessageId).length\n    : 0;\n\n  let session = await sessionContext.agent.storage.session.get(sessionId);\n  const now = Date.now();\n  if (!session) {\n    session = {\n      id: sessionId,\n      sandboxId: sandboxId ?? null,\n      lastMessageId: null,\n      createdAt: now,\n      updatedAt: now,\n    };\n    await sessionContext.agent.storage.session.set(session.id, session);\n  } else if (sandboxId && sandboxId !== session.sandboxId) {\n    session = { ...session, sandboxId, updatedAt: now };\n    await sessionContext.agent.storage.session.update(session.id, {\n      sandboxId,\n    });\n  }\n\n  await all({\n    async saveMessages() {\n      await Promise.all(\n        newMessages.map(async (m, i) => {\n          const existing = await sessionContext.agent.storage.message.get(m.id);\n          if (existing) {\n            return;\n          }\n          await sessionContext.agent.storage.message.set(m.id, {\n            ...m,\n            createdAt: baseTime + i,\n            workflowRunId:\n              m.id === assistantMessageId\n                ? (workflowRunId ?? null)\n                : m.workflowRunId,\n          });\n        })\n      );\n    },\n    async saveParts() {\n      await Promise.all(\n        newParts.map(async (p) =>\n          sessionContext.agent.storage.part.set(p.id, p)\n        )\n      );\n    },\n    async resolveApprovals() {\n      await Promise.all(\n        newApprovals.map(async (a) => {\n          const partId = approvalPartId(a.approvalId);\n          const part = await sessionContext.agent.storage.part.get(partId);\n          if (!part) {\n            throw new ApprovalNotFoundError({\n              id: sessionContext.sessionId,\n              approvalId: a.approvalId,\n            });\n          }\n          await sessionContext.agent.storage.part.set(partId, {\n            ...part,\n            part: {\n              ...part.part,\n              state: a.approved ? \"approval-responded\" : \"output-denied\",\n              approval: {\n                id: a.approvalId,\n                approved: a.approved,\n                reason: a.reason,\n              },\n            } as typeof part.part,\n          });\n        })\n      );\n    },\n    async updateSession() {\n      await sessionContext.agent.storage.session.set(session.id, {\n        ...session,\n        lastMessageId: assistantMessageId,\n        updatedAt: Date.now(),\n      });\n    },\n  });\n\n  const state: Record<string, unknown> = session.state\n    ? { ...session.state }\n    : { ...(initialState ?? {}) };\n\n  return {\n    workflowRunId,\n    workflowWritable,\n    existingPartCount,\n    assistantMessageId,\n    assistantMessageCreatedAt,\n    state,\n  };\n}\n\nasync function completeMessageStep({\n  assistantMessageId,\n  sessionContext,\n  writable,\n  usageSteps,\n}: {\n  assistantMessageId: string;\n  sessionContext: SessionContext;\n  writable: WritableStream;\n  usageSteps: StepUsage[];\n}) {\n  \"use step\";\n\n  const log = createLogger({\n    config: {\n      ...sessionContext.agent.options.logging,\n      name: sessionContext.agent.name,\n    },\n    subsystem: \"ai-loop\",\n  });\n  const msgLog = log.withContext({\n    sessionId: sessionContext.sessionId,\n    messageId: assistantMessageId,\n  });\n\n  const usage =\n    usageSteps.length > 0\n      ? {\n          steps: usageSteps,\n          summary: {\n            model: usageSteps[0]?.model ?? \"unknown\",\n            inputTokens: usageSteps.reduce((a, s) => a + s.inputTokens, 0),\n            outputTokens: usageSteps.reduce((a, s) => a + s.outputTokens, 0),\n            totalTokens: usageSteps.reduce((a, s) => a + s.totalTokens, 0),\n            cacheReadTokens: usageSteps.reduce(\n              (a, s) => a + s.cacheReadTokens,\n              0\n            ),\n            cacheWriteTokens: usageSteps.reduce(\n              (a, s) => a + s.cacheWriteTokens,\n              0\n            ),\n            reasoningTokens: usageSteps.reduce(\n              (a, s) => a + s.reasoningTokens,\n              0\n            ),\n            stepCount: usageSteps.length,\n          },\n        }\n      : null;\n\n  await Promise.all([\n    sessionContext.agent.storage.message.update(assistantMessageId, {\n      completedAt: Date.now(),\n      usage,\n    }),\n    writable.close().catch(() => undefined),\n  ]);\n\n  msgLog.info(\"message completed\", {\n    steps: usageSteps.length,\n    totalTokens: usage?.summary.totalTokens,\n  });\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\nexport function approvalPartId(approvalId: string): string {\n  return `part_${approvalId}`;\n}\n\nexport function replayActiveRun(\n  active: ActiveRun,\n  startIndex = 0\n): ReadableStream<UIMessageChunk> {\n  let cursor = startIndex;\n  let cancelled = false;\n\n  return new ReadableStream<UIMessageChunk>({\n    async pull(controller) {\n      // Drain any buffered chunks\n      while (cursor < active.chunks.length) {\n        controller.enqueue(active.chunks[cursor++]);\n      }\n\n      // Wait for either a new chunk or completion\n      while (!cancelled && cursor >= active.chunks.length) {\n        const result = await Promise.race([\n          active.onChunk.then(() => \"chunk\" as const),\n          active.done.then(() => \"done\" as const),\n        ]);\n\n        // Drain new chunks\n        while (cursor < active.chunks.length) {\n          controller.enqueue(active.chunks[cursor++]);\n        }\n\n        if (result === \"done\") {\n          controller.close();\n          return;\n        }\n      }\n    },\n    cancel() {\n      cancelled = true;\n    },\n  });\n}\n\nfunction toMessageAndParts<Tools extends ToolSet>({\n  sessionId,\n  id,\n  input,\n  defaultRole,\n}: {\n  sessionId: string;\n  id?: string;\n  input: SendInput<Tools>;\n  defaultRole: UIMessage[\"role\"];\n}): {\n  message: Message | undefined;\n  parts: Part[];\n  approvals: ApprovalData[];\n} {\n  let messageId = id ?? `message_${ulid()}`;\n  if (typeof input === \"string\") {\n    const now = Date.now();\n    return {\n      approvals: [],\n      message: {\n        id: messageId,\n        sessionId,\n        role: defaultRole,\n        createdAt: now,\n        startedAt: null,\n        completedAt: null,\n        interruptedAt: null,\n        interruptedLastPart: null,\n        usage: null,\n        workflowRunId: null,\n        metadata: null,\n      },\n      parts: [\n        {\n          sessionId,\n          messageId,\n          id: `part_${messageId}_0`,\n          index: 0,\n          part: { type: \"text\", text: input },\n        },\n      ],\n    };\n  }\n  if (\"type\" in input && input.type === \"approval\") {\n    return {\n      message: undefined,\n      parts: [],\n      approvals: [input.approval],\n    };\n  }\n\n  const msg =\n    \"type\" in input && input.type === \"message\" ? input.message : input;\n  if (\"id\" in msg && msg.id) {\n    messageId = msg.id;\n  }\n\n  const now = Date.now();\n  const metadata =\n    \"metadata\" in msg && msg.metadata != null\n      ? (msg.metadata as Record<string, unknown>)\n      : null;\n  return {\n    approvals: [],\n    message: {\n      sessionId,\n      id: messageId,\n      createdAt: now,\n      startedAt: null,\n      completedAt: null,\n      interruptedAt: null,\n      interruptedLastPart: null,\n      usage: null,\n      workflowRunId: null,\n      role: msg.role ?? defaultRole,\n      metadata,\n    },\n    parts: msg.parts.map((part, index) => {\n      const ap = part as { approval?: { id: string } };\n      const id = ap.approval?.id\n        ? approvalPartId(ap.approval.id)\n        : `part_${messageId}_${index}`;\n      return { sessionId, messageId, id, index, part };\n    }),\n  };\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Errors\n * -----------------------------------------------------------------------------------------------*/\n\nexport class SendError extends errore.createTaggedError({\n  name: \"SendError\",\n  message: \"Send failed for session $id: $reason\",\n}) {}\n\nexport class ApprovalNotFoundError extends errore.createTaggedError({\n  name: \"ApprovalNotFoundError\",\n  message: \"Approval $approvalId not found in session $id\",\n}) {}\n", "import type {\n  FinishReason,\n  ToolSet,\n  UIMessage,\n  UIMessageStreamWriter,\n} from \"ai\";\nimport {\n  convertToModelMessages,\n  createUIMessageStream,\n  stepCountIs,\n  streamText as streamTextAi,\n} from \"ai\";\nimport type {\n  AgentStatus,\n  AnyAgent,\n  Resolvable,\n  ResolvableArgs,\n  TypedUIMessage,\n} from \"../../agent/client\";\nimport { SessionNotFoundError } from \"../../errors\";\nimport { discoverSkillsInSandbox } from \"../../skills/discover\";\nimport { resolveSkillInputsToSandboxDirs } from \"../../skills/resolve\";\nimport type { SkillSummary } from \"../../skills/types\";\nimport type { Part } from \"../../storage/types\";\nimport { type BuiltInToolName, getTools, type ToolContext } from \"../../tools\";\nimport { createLogger, type Logger } from \"../../utils/logger\";\nimport {\n  applyPromptCachingToModelRequest,\n  mergeProviderOptions,\n} from \"../../utils/prompt-cache\";\nimport { assembleUIMessages } from \"../../utils/ui\";\nimport type { StepUsage } from \"../../utils/usage\";\nimport { approvalPartId } from \"../send\";\n\nconst INTERRUPT_POLL_INTERVAL_MS = 250;\n\nfunction pollForInterrupt({\n  agent,\n  messageId,\n  signal,\n  abortController,\n}: {\n  agent: AnyAgent;\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 log = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"ai-loop\",\n  });\n\n  const poll = async () => {\n    let isFirst = true;\n    while (!signal.aborted) {\n      const message = await agent.storage.message.get(messageId);\n      if (!message) {\n        if (isFirst) {\n          resolveFirstCheck();\n          return;\n        }\n        throw new Error(`Message ${messageId} not found`);\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\ntype StreamTextOptions = {\n  stepThroughput: number;\n  assistantMessageId: string;\n  sessionId: string;\n  agent: AnyAgent;\n  createdAt: number;\n  context: Record<string, unknown>;\n  state: Record<string, unknown>;\n  writable: WritableStream;\n  lastPartIndex: number;\n  stepIndexOffset: number;\n  discoveredSkills: SkillSummary[] | null;\n};\n\nexport type StreamTextResult = {\n  finishReason: FinishReason;\n  lastPartIndex: number;\n  usageSteps: StepUsage[];\n  pendingApprovals: { approvalId: string; toolName: string }[];\n  maxSteps: number | undefined;\n  discoveredSkills: SkillSummary[] | null;\n  context: Record<string, unknown>;\n};\n\nexport async function streamText<Tools extends ToolSet>({\n  stepThroughput,\n  assistantMessageId,\n  agent,\n  sessionId,\n  context,\n  state,\n  createdAt,\n  writable,\n  lastPartIndex,\n  stepIndexOffset,\n  discoveredSkills,\n}: StreamTextOptions): Promise<StreamTextResult> {\n  const log = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"ai-loop\",\n  });\n\n  const stepLog = log.withContext({\n    sessionId,\n    messageId: assistantMessageId,\n  });\n  const doneStep = stepLog.time(\"streamText\");\n\n  const throttledEmitStatus = createThrottledEmitStatus(agent);\n\n  const abortController = new AbortController();\n  const pollController = new AbortController();\n\n  const { firstCheck, interruptedLastPartRef } = pollForInterrupt({\n    agent,\n    messageId: assistantMessageId,\n    signal: pollController.signal,\n    abortController,\n  });\n\n  const doneLoad = stepLog.time(\"load session + messages + parts + sandbox\");\n  const [, messagesResult, partsResult, { sandbox, sandboxRecord }] =\n    await Promise.all([\n      firstCheck,\n      agent.storage.message.listBySession(sessionId),\n      agent.storage.part.listBySession(sessionId),\n      agent.storage.session.get(sessionId).then(async (session) => {\n        if (!session) {\n          throw new SessionNotFoundError({ id: sessionId });\n        }\n\n        const sandboxId = session.sandboxId ?? session.id;\n        const sandbox = agent.sandbox(sandboxId);\n        const sandboxRecord = await agent.storage.sandbox.get(sandboxId);\n\n        return { sandbox, sandboxRecord };\n      }),\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      context,\n    };\n  }\n\n  const setStartedPromise =\n    lastPartIndex === 0\n      ? (async () => {\n          const now = Date.now();\n          const pendingMessages = messagesResult.filter(\n            (m) => m.createdAt <= createdAt && m.startedAt === null\n          );\n          if (pendingMessages.length > 0) {\n            return await Promise.all(\n              pendingMessages.map((m) =>\n                agent.storage.message.update(m.id, {\n                  startedAt: now,\n                  completedAt: m.role === \"assistant\" ? null : now,\n                })\n              )\n            );\n          }\n        })()\n      : null;\n\n  const allParts = [...partsResult];\n  const nextPartIndexRef = {\n    current: Math.max(\n      lastPartIndex,\n      ...allParts\n        .filter((p) => p.messageId === assistantMessageId)\n        .map((p) => p.index + 1),\n      0\n    ),\n  };\n\n  const skillsRef: { current: SkillSummary[] } = {\n    current: discoveredSkills ?? [],\n  };\n\n  // Build uiMessages from current parts (rebuilt between iterations)\n  let uiMessages = assembleUIMessages({\n    messages: messagesResult,\n    parts: allParts,\n    until: createdAt,\n    includeQueued: true,\n    excludeSubToolParts: true,\n  });\n\n  // Build resolvable args for resolving agent options\n  const resolvableArgs: ResolvableArgs = {\n    context,\n    state,\n    sessionId,\n    sandbox,\n    get messages() {\n      return uiMessages;\n    },\n  };\n\n  // skills discovery \u2014 first iteration only\n  if (lastPartIndex === 0 && !discoveredSkills) {\n    const resolvedSkills = await resolveOption(\n      agent.options.skills,\n      resolvableArgs\n    );\n    const skillsDirs = resolvedSkills?.length\n      ? await resolveSkillInputsToSandboxDirs({\n          agent,\n          sandbox,\n          skills: resolvedSkills,\n          sessionId,\n        })\n      : [];\n    if (skillsDirs.length > 0) {\n      const doneSkills = stepLog.time(\"discover skills\", { skillsDirs });\n      skillsRef.current = await discoverSkillsInSandbox({\n        agent,\n        sandbox,\n        skillsDirs,\n        sessionId,\n      });\n      doneSkills({ count: skillsRef.current.length });\n    }\n  }\n\n  /**\n   * Inner loop: run up to `stepThroughput` sequential LLM calls.\n   * Parts are persisted after each call so progress isn't lost.\n   * Session is re-fetched between iterations (config may change),\n   * parallelized with part persistence on non-final iterations.\n   */\n  const usageSteps: StepUsage[] = [];\n  let internalStepIndex = 0;\n  let loopFinishReason: FinishReason = \"unknown\" as FinishReason;\n  let wasAborted = false;\n  const allPendingApprovals: { approvalId: string; toolName: string }[] = [];\n  let currentMaxSteps: number | undefined;\n\n  try {\n    for (let iteration = 0; iteration < stepThroughput; iteration++) {\n      // Resolve agent options fresh each iteration\n      const resolvedModel = await resolveOption(\n        agent.options.model,\n        resolvableArgs\n      );\n      const resolvedGeneration = await resolveOption(\n        agent.options.generation,\n        resolvableArgs\n      );\n      const resolvedActiveTools = (await resolveOption(\n        agent.options.activeTools,\n        resolvableArgs\n      )) as string[] | undefined;\n\n      currentMaxSteps = resolvedGeneration?.maxSteps;\n\n      if (!resolvedModel) {\n        throw new Error(\"Agent model is not set\");\n      }\n\n      const stepParts: UIMessage[\"parts\"] = [];\n      let streamTextFinishReason: FinishReason | undefined;\n\n      try {\n        const stream = createUIMessageStream({\n          execute: async ({ writer }) => {\n            const { rawTools, toolsWithNeedsApproval, toolContext } = getTools({\n              agent,\n              sandbox,\n              skillsRef,\n              writer,\n              abortController,\n              nextPartIndexRef,\n              assistantMessageId,\n              sessionId,\n              stepLog,\n              context,\n              state,\n              messages: uiMessages,\n              activeTools: resolvedActiveTools,\n            });\n\n            // process approvals once (first iteration only)\n            if (iteration === 0) {\n              await processApprovals({\n                allParts,\n                messagesResult,\n                createdAt,\n                rawTools,\n                abortController,\n                toolContext,\n                agent,\n                stepLog,\n                throttledEmitStatus,\n                writer,\n              });\n            }\n\n            throttledEmitStatus({\n              writer,\n              status: { type: \"thinking\" },\n            });\n\n            const iterResult = streamTextAi({\n              messages: [{ role: \"user\" as const, content: \".\" }],\n              tools: toolsWithNeedsApproval,\n              model: resolvedModel,\n              abortSignal: abortController.signal,\n              stopWhen: stepCountIs(1),\n              temperature: resolvedGeneration?.temperature,\n              topK: resolvedGeneration?.topK,\n              topP: resolvedGeneration?.topP,\n              frequencyPenalty: resolvedGeneration?.frequencyPenalty,\n              presencePenalty: resolvedGeneration?.presencePenalty,\n              maxOutputTokens: resolvedGeneration?.maxOutputTokens,\n              headers: resolvedGeneration?.headers,\n              experimental_context: {\n                context,\n                state,\n                sessionId,\n                sandbox,\n                messages: uiMessages,\n              } satisfies ToolContext,\n              prepareStep: async ({ model }) => {\n                const skillsContext = buildSkillsContext(skillsRef.current);\n                const cwdPrompt = sandboxRecord?.setup?.cwd\n                  ? `Your working directory is ${sandboxRecord.setup.cwd}. All file paths should be absolute.`\n                  : \"All file paths must be absolute.\";\n\n                const resolvedSystem = await resolveSystem(\n                  agent.options.system,\n                  resolvableArgs\n                );\n\n                const systemHeader = joinPromptSections(\n                  BASE_SYSTEM_PROMPT,\n                  cwdPrompt,\n                  resolvedSystem\n                );\n                const systemContext = joinPromptSections(\n                  skillsContext,\n                  cwdPrompt\n                );\n\n                const convertedMessages = await convertToModelMessages(\n                  uiMessages,\n                  { ignoreIncompleteToolCalls: true }\n                );\n\n                const modelMessages = [\n                  ...(systemHeader.trim()\n                    ? [{ role: \"system\" as const, content: systemHeader }]\n                    : []),\n                  ...(systemContext.trim()\n                    ? [{ role: \"system\" as const, content: systemContext }]\n                    : []),\n                  ...convertedMessages,\n                ];\n\n                const promptCaching = applyPromptCachingToModelRequest({\n                  model: typeof model === \"string\" ? model : model.modelId,\n                  sessionId,\n                  messages: modelMessages,\n                });\n\n                let activeTools = resolvedActiveTools ?? 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: mergeProviderOptions({\n                    current: resolvedGeneration?.providerOptions,\n                    patch: promptCaching.providerOptions,\n                  }),\n                  activeTools,\n                };\n              },\n              onStepFinish: ({ usage }) => {\n                if (usage) {\n                  usageSteps.push({\n                    stepIndex: stepIndexOffset + internalStepIndex,\n                    model: resolvedModel ?? \"unknown\",\n                    inputTokens: usage.inputTokens ?? 0,\n                    outputTokens: usage.outputTokens ?? 0,\n                    totalTokens: usage.totalTokens ?? 0,\n                    cacheReadTokens:\n                      usage.inputTokenDetails?.cacheReadTokens ?? 0,\n                    cacheWriteTokens:\n                      usage.inputTokenDetails?.cacheWriteTokens ?? 0,\n                    reasoningTokens:\n                      usage.outputTokenDetails?.reasoningTokens ?? 0,\n                  });\n                }\n                internalStepIndex++;\n              },\n            });\n\n            writer.merge(\n              iterResult.toUIMessageStream({\n                generateMessageId: () => assistantMessageId,\n                onFinish: ({ messages }) => {\n                  for (const m of messages) {\n                    if (m.role === \"assistant\") {\n                      stepParts.push(...m.parts);\n                    }\n                  }\n                },\n              })\n            );\n\n            streamTextFinishReason = await iterResult.finishReason;\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      }\n\n      if (abortController.signal.aborted) {\n        wasAborted = true;\n      }\n\n      // Mark interrupted tool parts\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      // Handle interrupted lastPart truncation\n      const lastPart = interruptedLastPartRef.current;\n\n      const newPartRecords = stepParts\n        .map((uiPart, i) => {\n          const index = nextPartIndexRef.current + i;\n          if (lastPart != null && index > lastPart.index) {\n            return null;\n          }\n          const useClientPart = lastPart != null && index === lastPart.index;\n          const content = (\n            useClientPart ? lastPart.part : uiPart\n          ) as TypedUIMessage<Tools>[\"parts\"][number];\n          const partId =\n            \"approval\" in content && content.approval?.id\n              ? approvalPartId(content.approval.id)\n              : `part_${assistantMessageId}_${index}`;\n          return {\n            id: partId,\n            index,\n            messageId: assistantMessageId,\n            sessionId,\n            part: content,\n          };\n        })\n        .filter((r): r is NonNullable<typeof r> => r !== null);\n\n      const persistPromise = Promise.all([\n        ...newPartRecords.map((record) =>\n          agent.storage.part.set(record.id, record)\n        ),\n        agent.storage.session.update(sessionId, { state }),\n      ]);\n\n      nextPartIndexRef.current =\n        lastPart != null\n          ? Math.min(\n              nextPartIndexRef.current + stepParts.length,\n              lastPart.index + 1\n            )\n          : nextPartIndexRef.current + stepParts.length;\n\n      const iterPendingApprovals = 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:\n            \"type\" in p ? String(p.type).replace(\"tool-\", \"\") : \"unknown\",\n        }));\n\n      loopFinishReason = wasAborted\n        ? (\"stop\" as FinishReason)\n        : (streamTextFinishReason ?? (\"unknown\" as FinishReason));\n\n      // Decide whether to break or continue\n      const shouldBreak =\n        iterPendingApprovals.length > 0 ||\n        loopFinishReason === \"stop\" ||\n        wasAborted ||\n        lastPart != null ||\n        (currentMaxSteps != null &&\n          stepIndexOffset + usageSteps.length >= currentMaxSteps) ||\n        iteration >= stepThroughput - 1;\n\n      if (shouldBreak) {\n        await persistPromise;\n        allParts.push(...newPartRecords);\n        allPendingApprovals.push(...iterPendingApprovals);\n        break;\n      }\n\n      // Non-final iteration: persist parts and rebuild messages\n      await persistPromise;\n      allParts.push(...newPartRecords);\n      uiMessages = assembleUIMessages({\n        messages: messagesResult,\n        parts: allParts,\n        until: createdAt,\n        includeQueued: true,\n        excludeSubToolParts: true,\n      });\n    }\n  } finally {\n    pollController.abort();\n    throttledEmitStatus.dispose();\n  }\n\n  if (setStartedPromise) {\n    await setStartedPromise;\n  }\n\n  doneStep({\n    finishReason: loopFinishReason,\n    wasAborted,\n    iterations: internalStepIndex,\n    pendingApprovals: allPendingApprovals.length,\n  });\n\n  return {\n    finishReason: loopFinishReason,\n    lastPartIndex: nextPartIndexRef.current,\n    usageSteps,\n    pendingApprovals: allPendingApprovals,\n    maxSteps: currentMaxSteps,\n    discoveredSkills: skillsRef.current,\n    context,\n  };\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Steps\n * -----------------------------------------------------------------------------------------------*/\n\nexport async function streamTextStep<Tools extends ToolSet>(\n  ...args: Parameters<typeof streamText<Tools>>\n) {\n  \"use step\";\n  return await streamText(...args);\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\nasync function processApprovals({\n  allParts,\n  messagesResult,\n  createdAt,\n  rawTools,\n  abortController,\n  toolContext,\n  agent,\n  stepLog,\n  throttledEmitStatus,\n  writer,\n}: {\n  allParts: Part[];\n  messagesResult: Parameters<typeof assembleUIMessages>[0][\"messages\"];\n  createdAt: number;\n  rawTools: ToolSet;\n  abortController: AbortController;\n  toolContext: ToolContext;\n  agent: AnyAgent;\n  stepLog: Logger;\n  throttledEmitStatus: ReturnType<typeof createThrottledEmitStatus>;\n  writer: StreamWriter;\n}) {\n  // Execute approved tools so the model sees complete tool call + result pairs\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?.approved ===\n        true\n  );\n\n  if (approvedParts.length > 0) {\n    stepLog.info(\"executing approved tools\", {\n      count: approvedParts.length,\n    });\n    throttledEmitStatus({\n      writer,\n      status: { type: \"processing-approvals\" },\n    });\n\n    const preExecMessages = await convertToModelMessages(\n      assembleUIMessages({\n        messages: messagesResult,\n        parts: allParts,\n        until: 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: toolContext,\n            });\n            part.state = \"output-available\";\n            part.output = toolOutput;\n            writer.write({\n              type: \"tool-output-available\",\n              toolCallId: part.toolCallId,\n              output: toolOutput,\n            });\n          } catch (err) {\n            part.state = \"output-error\";\n            part.errorText = err instanceof Error ? err.message : String(err);\n            writer.write({\n              type: \"tool-output-error\",\n              toolCallId: part.toolCallId,\n              errorText: part.errorText,\n            });\n          }\n          await agent.storage.part.set(ap.id, { ...ap, part });\n        }\n      })\n    );\n  }\n\n  // Auto-deny any remaining approval-requested parts so the model\n  // sees complete tool call + denied result pairs (not missing results).\n  const pendingApprovalParts = allParts.filter(\n    (p) => (p.part as { state?: string }).state === \"approval-requested\"\n  );\n  if (pendingApprovalParts.length > 0) {\n    await Promise.all(\n      pendingApprovalParts.map(async (p) => {\n        const denied = {\n          ...p,\n          part: {\n            ...p.part,\n            state: \"output-denied\",\n            approval: {\n              ...((p.part as { approval?: object }).approval ?? {}),\n              approved: false,\n              reason: \"auto-denied: new message sent\",\n            },\n          } as typeof p.part,\n        };\n        Object.assign(p, denied);\n        await agent.storage.part.set(p.id, denied);\n      })\n    );\n  }\n}\n\ntype StreamWriter = UIMessageStreamWriter;\n\nfunction emitStatus({\n  writer,\n  status,\n  agent,\n}: {\n  writer: StreamWriter;\n  status: AgentStatus;\n  agent: AnyAgent;\n}) {\n  writer.write({ type: \"data-status\", data: status, transient: true });\n  agent.hooks?.status?.(status);\n}\n\nconst STATUS_THROTTLE_MS = 500;\n\nfunction createThrottledEmitStatus(agent: AnyAgent) {\n  let timer: ReturnType<typeof setTimeout> | null = null;\n  let pending: {\n    writer: StreamWriter;\n    status: AgentStatus;\n  } | null = null;\n\n  function throttled({\n    writer,\n    status,\n  }: {\n    writer: StreamWriter;\n    status: AgentStatus;\n  }) {\n    pending = { writer, status };\n    if (timer !== null) {\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, agent });\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\nasync function resolveOption<T>(\n  value: Resolvable<T> | undefined,\n  args: ResolvableArgs\n): Promise<T | undefined> {\n  if (value === undefined) {\n    return undefined;\n  }\n  if (typeof value === \"function\") {\n    return await (value as (args: ResolvableArgs) => T | Promise<T>)(args);\n  }\n  return value;\n}\n\nasync function resolveSystem(\n  input: Resolvable<string | string[] | undefined> | undefined,\n  args: ResolvableArgs\n): Promise<string | null> {\n  const result = await resolveOption(input, args);\n  if (!result) {\n    return null;\n  }\n  return Array.isArray(result) ? result.filter(Boolean).join(\"\\n\") : result;\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", "import type { SkillEntry, SkillInput } 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\nexport function normalizeSkills(\n  skills: SkillInput[] | null | undefined\n): SkillEntry[] {\n  if (!skills || skills.length === 0) {\n    return [];\n  }\n\n  return skills.map((skill) => {\n    if (typeof skill !== \"object\" || skill === null) {\n      throw new Error(\n        \"Invalid skills entry: expected an object with a `type` field.\"\n      );\n    }\n    if (\"type\" in skill && skill.type) {\n      return skill as SkillEntry;\n    }\n    throw new Error(\"Invalid skills entry: expected `type`.\");\n  });\n}\n", "import type { AnyAgent } from \"../agent/client\";\nimport type { SandboxInstance } from \"../sandbox/adapter\";\nimport { createLogger, type Logger } from \"../utils/logger\";\nimport { parseSkillFrontmatter } from \"./parser\";\nimport type { SkillSummary } from \"./types\";\n\n/**\n * Discovers skills from directories inside the sandbox by finding and parsing SKILL.md files.\n * Scans each directory for subdirectories containing SKILL.md, extracts frontmatter metadata,\n * and returns summaries for use in the system prompt.\n *\n * @returns Array of skill summaries (deduplicated by name, first occurrence wins)\n */\nexport async function discoverSkillsInSandbox(opts: {\n  agent: AnyAgent;\n  sandbox: SandboxInstance;\n  skillsDirs: string[];\n  sessionId?: string;\n}): Promise<SkillSummary[]> {\n  const { agent, sandbox, skillsDirs, sessionId } = opts;\n  const baseLog = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"skills\",\n  });\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: SandboxInstance;\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: SandboxInstance;\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: SandboxInstance;\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 type { SandboxInstance } from \"../sandbox/adapter\";\nimport type { HostSkillInput } from \"./types\";\n\nasync function collectFiles(opts: {\n  absolutePath: string;\n  relativePrefix?: string;\n}): Promise<{ path: string; content: Buffer }[]> {\n  const { readdir, readFile, stat } = await import(\"node:fs/promises\");\n  const { resolve, posix: pathPosix } = await import(\"node:path\");\n\n  const fileStat = await stat(opts.absolutePath);\n  if (fileStat.isFile()) {\n    const content = await readFile(opts.absolutePath);\n    return [{ path: opts.relativePrefix ?? \"SKILL.md\", content }];\n  }\n\n  if (!fileStat.isDirectory()) {\n    return [];\n  }\n\n  const entries = await readdir(opts.absolutePath, { withFileTypes: true });\n  const files: { path: string; content: Buffer }[] = [];\n\n  for (const entry of entries) {\n    const nextAbs = resolve(opts.absolutePath, entry.name);\n    const nextRel = opts.relativePrefix\n      ? pathPosix.join(opts.relativePrefix, entry.name)\n      : entry.name;\n\n    if (entry.isDirectory()) {\n      files.push(\n        ...(await collectFiles({\n          absolutePath: nextAbs,\n          relativePrefix: nextRel,\n        }))\n      );\n      continue;\n    }\n\n    if (entry.isFile()) {\n      files.push({\n        path: nextRel,\n        content: await readFile(nextAbs),\n      });\n    }\n  }\n\n  return files;\n}\n\nasync function stableDirName(inputPath: string): Promise<string> {\n  const { createHash } = await import(\"node:crypto\");\n  const hash = createHash(\"sha1\").update(inputPath).digest(\"hex\").slice(0, 10);\n  return `host-${hash}`;\n}\n\nexport async function resolveHostSkill(opts: {\n  sandbox: SandboxInstance;\n  skill: HostSkillInput;\n}): Promise<string> {\n  const { resolve, posix: pathPosix } = await import(\"node:path\");\n\n  const hostPath = resolve(process.cwd(), opts.skill.path);\n  const files = await collectFiles({ absolutePath: hostPath });\n  const dirName = await stableDirName(hostPath);\n  const destPath = pathPosix.join(\".agent\", \"skills\", \".materialized\", dirName);\n\n  if (files.length === 0) {\n    return destPath;\n  }\n\n  await opts.sandbox.writeFiles({\n    files,\n    destPath,\n  });\n\n  return destPath;\n}\n", "import type { SandboxInstance } from \"../sandbox/adapter\";\nimport type { InlineSkillInput } from \"./types\";\n\nfunction slugify(value: string): string {\n  return value\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/(^-|-$)/g, \"\");\n}\n\nasync function stableInlineDirName(name: string): Promise<string> {\n  const { createHash } = await import(\"node:crypto\");\n  const slug = slugify(name) || \"inline-skill\";\n  const hash = createHash(\"sha1\").update(name).digest(\"hex\").slice(0, 8);\n  return `${slug}-${hash}`;\n}\n\nfunction buildSkillMarkdown(skill: InlineSkillInput): string {\n  return `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.instructions.trim()}\n`;\n}\n\nexport async function resolveInlineSkill(opts: {\n  sandbox: SandboxInstance;\n  skill: InlineSkillInput;\n}): Promise<string> {\n  const { posix: pathPosix } = await import(\"node:path\");\n\n  const dirName = await stableInlineDirName(opts.skill.name);\n  const destPath = pathPosix.join(\".agent\", \"skills\", \".materialized\", dirName);\n\n  await opts.sandbox.writeFiles({\n    destPath,\n    files: [\n      {\n        path: \"SKILL.md\",\n        content: buildSkillMarkdown(opts.skill),\n      },\n    ],\n  });\n\n  return destPath;\n}\n", "import type { SandboxInstance } from \"../sandbox/adapter\";\nimport type { GitSkillInput } from \"./types\";\n\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\\''`)}'`;\n}\n\nasync function stableRepoDirName(skill: GitSkillInput): Promise<string> {\n  const { createHash } = await import(\"node:crypto\");\n  const hashInput = `${skill.repo}::${skill.ref ?? \"HEAD\"}`;\n  const hash = createHash(\"sha1\").update(hashInput).digest(\"hex\").slice(0, 12);\n  return `git-${hash}`;\n}\n\nexport async function resolveRemoteSkill(opts: {\n  sandbox: SandboxInstance;\n  skill: GitSkillInput;\n}): Promise<string> {\n  const { posix: pathPosix } = await import(\"node:path\");\n\n  const dirName = await stableRepoDirName(opts.skill);\n  const cloneDir = pathPosix.join(\".agent\", \"skills\", \".materialized\", dirName);\n  const quotedDir = shellQuote(cloneDir);\n  const quotedRepo = shellQuote(opts.skill.repo);\n  const quotedRef = shellQuote(opts.skill.ref ?? \"HEAD\");\n\n  const syncCommand = [\n    \"set -euo pipefail\",\n    `if [ ! -d ${quotedDir}/.git ]; then`,\n    `  rm -rf ${quotedDir}`,\n    `  mkdir -p ${quotedDir}`,\n    `  git clone --depth 1 ${quotedRepo} ${quotedDir}`,\n    \"fi\",\n    `if [ ${quotedRef} != 'HEAD' ]; then`,\n    `  git -C ${quotedDir} fetch --depth 1 origin ${quotedRef}`,\n    `  git -C ${quotedDir} checkout FETCH_HEAD`,\n    \"fi\",\n  ].join(\"\\n\");\n\n  const execResult = await opts.sandbox.exec({\n    command: \"bash\",\n    args: [\"-lc\", syncCommand],\n  });\n  const { exitCode, stderr } = await execResult.result;\n  if (exitCode !== 0) {\n    throw new Error(\n      `Failed to materialize git skill from ${opts.skill.repo}: ${stderr || \"unknown error\"}`\n    );\n  }\n\n  let resolvedDir = cloneDir;\n  if (opts.skill.path) {\n    resolvedDir = pathPosix.join(resolvedDir, opts.skill.path);\n  }\n  if (opts.skill.name) {\n    resolvedDir = pathPosix.join(resolvedDir, opts.skill.name);\n  }\n  return resolvedDir;\n}\n", "import type { AnyAgent } from \"../agent/client\";\nimport type { SandboxInstance } from \"../sandbox/adapter\";\nimport { createLogger } from \"../utils/logger\";\nimport { normalizeSkills } from \"./parser\";\nimport { resolveHostSkill } from \"./resolve-host\";\nimport { resolveInlineSkill } from \"./resolve-inline\";\nimport { resolveRemoteSkill } from \"./resolve-remote\";\nimport type { SkillInput } from \"./types\";\n\nexport async function resolveSkillInputsToSandboxDirs(opts: {\n  agent: AnyAgent;\n  sandbox: SandboxInstance;\n  skills: SkillInput[];\n  sessionId?: string;\n}): Promise<string[]> {\n  const baseLog = createLogger({\n    config: { ...opts.agent.options.logging, name: opts.agent.name },\n    subsystem: \"skills\",\n  });\n  const log = opts.sessionId\n    ? baseLog.withContext({ sessionId: opts.sessionId })\n    : baseLog;\n  const entries = normalizeSkills(opts.skills);\n  const resolved: string[] = [];\n\n  for (const entry of entries) {\n    if (entry.type === \"sandbox\") {\n      resolved.push(entry.path);\n      continue;\n    }\n    if (entry.type === \"host\") {\n      resolved.push(\n        await resolveHostSkill({\n          sandbox: opts.sandbox,\n          skill: entry,\n        })\n      );\n      continue;\n    }\n    if (entry.type === \"git\") {\n      resolved.push(\n        await resolveRemoteSkill({\n          sandbox: opts.sandbox,\n          skill: entry,\n        })\n      );\n      continue;\n    }\n    if (entry.type === \"inline\") {\n      resolved.push(\n        await resolveInlineSkill({\n          sandbox: opts.sandbox,\n          skill: entry,\n        })\n      );\n      continue;\n    }\n    log.warn(\"unknown skill source entry encountered\", { entry });\n  }\n\n  return resolved;\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\nexport function 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 {\n  InferUITools,\n  ReasoningUIPart,\n  TextUIPart,\n  ToolSet,\n  UIMessage,\n} from \"ai\";\nimport type { AgentDataTypes } from \"../agent/registry\";\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<Tools extends ToolSet>(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}) {\n  type TypedUIMessage = UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>;\n\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  // Sort by createdAt so messages are in chronological order regardless of\n  // how the storage layer returns them (e.g. local FS reads in readdir order).\n  filtered = [...filtered].sort((a, b) => a.createdAt - b.createdAt);\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 messageId = String(part.messageId);\n    const existing = partsByMessage.get(messageId) ?? [];\n    existing.push(part);\n    partsByMessage.set(messageId, existing);\n  }\n\n  return filtered\n    .map((m) => {\n      const messageId = String(m.id);\n      let messageParts = partsByMessage.get(messageId) ?? [];\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: messageId,\n        role: m.role,\n        parts: messageParts.map((p) => p.part),\n        ...(m.metadata != null ? { metadata: m.metadata } : {}),\n      } as TypedUIMessage;\n    })\n    .filter((m) => m.parts.length > 0);\n}\n", "import type { UIMessage } from \"ai\";\nimport type { SessionContext } from \"./handle\";\n\nexport type InterruptOptions = {\n  lastPart?: {\n    index: number;\n    part: unknown;\n  };\n};\n\nexport async function interrupt(\n  sessionContext: SessionContext,\n  opts?: InterruptOptions\n) {\n  \"use step\";\n  const messages = await sessionContext.agent.storage.message.listBySession(\n    sessionContext.sessionId\n  );\n\n  const now = Date.now();\n  let pendingAssistantMessages = messages.filter(\n    (m) =>\n      m.role === \"assistant\" &&\n      m.completedAt === null &&\n      m.interruptedAt === null\n  );\n\n  if (pendingAssistantMessages.length === 0) {\n    const MAX_RETROACTIVE_MS = 5_000;\n    const latest = messages\n      .filter(\n        (m) =>\n          m.role === \"assistant\" &&\n          m.interruptedAt === null &&\n          m.completedAt !== null &&\n          now - m.completedAt < MAX_RETROACTIVE_MS\n      )\n      .sort((a, b) => b.createdAt - a.createdAt)\n      .at(0);\n    if (latest) {\n      pendingAssistantMessages = [latest];\n    }\n  }\n\n  await Promise.all(\n    pendingAssistantMessages.map((m) =>\n      sessionContext.agent.storage.message.set(m.id, {\n        ...m,\n        interruptedAt: now,\n        interruptedLastPart: opts?.lastPart ?? null,\n      })\n    )\n  );\n\n  const messageIds = new Set(pendingAssistantMessages.map((m) => m.id));\n  if (messageIds.size === 0) {\n    return;\n  }\n\n  const allParts = await sessionContext.agent.storage.part.listBySession(\n    sessionContext.sessionId\n  );\n\n  for (const p of allParts) {\n    if (!messageIds.has(p.messageId)) {\n      continue;\n    }\n    if (\n      p.part &&\n      \"state\" in p.part &&\n      (p.part as { state: string }).state === \"approval-requested\" &&\n      \"approval\" in p.part\n    ) {\n      const approval = (p.part as { approval?: { id: string } }).approval;\n      if (approval?.id) {\n        await sessionContext.agent.storage.part.set(p.id, {\n          ...p,\n          part: {\n            ...p.part,\n            state: \"output-denied\",\n            approval: {\n              ...approval,\n              approved: false,\n              reason: \"interrupted\",\n            },\n          } as UIMessage[\"parts\"][number],\n        });\n      }\n    }\n  }\n}\n", "import { type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { SandboxInstance } from \"../sandbox/adapter\";\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  toolContext,\n}: {\n  code: string;\n  rpcDir: string;\n  abortController: AbortController;\n  sandbox: SandboxInstance;\n  availableTools: ToolSet;\n  onSubToolCall?: OnSubToolCall;\n  toolContext?: Record<string, unknown>;\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      const execOptions = {\n        toolCallId: `js_${toolName}_${Date.now()}`,\n        messages: [],\n        experimental_context: toolContext,\n      };\n      if (onSubToolCall) {\n        response = await onSubToolCall(toolName, input, () =>\n          exec(input, execOptions)\n        );\n      } else {\n        const result = await exec(input, execOptions);\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  sandbox: SandboxInstance;\n  activeTools?: string[];\n  onSubToolCall?: OnSubToolCall;\n  toolContext?: Record<string, unknown>;\n}) {\n  const { sandbox, onSubToolCall } = opts;\n  const activeSet = opts.activeTools ? new Set(opts.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        toolContext: opts.toolContext,\n      });\n    },\n  });\n}\n", "import type { Tool } from \"ai\";\nimport type { AnyAgent } from \"../agent/client\";\nimport type { BuiltInToolName } from \"./index\";\n\n/** Built-in defaults for needsApproval (user can override via agent config). */\nconst builtinNeedsApproval: Partial<Record<BuiltInToolName, boolean>> = {};\n\nexport async function checkNeedsApproval({\n  agent,\n  toolName,\n  input,\n  toolCallId,\n  messages,\n}: {\n  agent: AnyAgent;\n  toolName: string;\n  input: unknown;\n  toolCallId: string;\n  messages: unknown[];\n}): Promise<boolean> {\n  // 1. Per-tool needsApproval on the Tool definition takes priority\n  const toolDef = agent.options.tools?.[toolName] as Tool | undefined;\n  if (toolDef?.needsApproval != null) {\n    if (typeof toolDef.needsApproval === \"boolean\") {\n      return toolDef.needsApproval;\n    }\n    return await toolDef.needsApproval(input, {\n      toolCallId,\n      messages: messages as never[],\n      experimental_context: undefined,\n    });\n  }\n\n  // 2. Agent-level needsApproval map\n  const agentEntry = (\n    agent.options.needsApproval as\n      | Record<\n          string,\n          boolean | ((...args: unknown[]) => boolean | Promise<boolean>)\n        >\n      | undefined\n  )?.[toolName];\n\n  if (agentEntry != null) {\n    if (typeof agentEntry === \"boolean\") {\n      return agentEntry;\n    }\n    return await agentEntry(input, {\n      toolCallId,\n      messages,\n      experimental_context: undefined,\n    });\n  }\n\n  // 3. Built-in defaults\n  return builtinNeedsApproval[toolName as BuiltInToolName] ?? false;\n}\n", "import type {\n  InferToolInput,\n  InferUITools,\n  ModelMessage,\n  ToolSet,\n  UIMessage,\n} from \"ai\";\nimport * as errore from \"errore\";\nimport { z } from \"zod\";\nimport type { BuiltInToolName, builtInTools, ToolContext } from \"../tools\";\nimport type { AnyAgent } from \"./client\";\n\n// \u2500\u2500\u2500 Agent Status \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Transient status indicators emitted over the stream during long-running phases.\n * Delivered to the client as `data-status` chunks with `transient: true` \u2014 not persisted.\n */\nexport const AgentStatus = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"sandbox-setup\") }),\n  z.object({ type: z.literal(\"sandbox-setup-cold\") }),\n  z.object({ type: z.literal(\"loading-skills\") }),\n  z.object({ type: z.literal(\"processing-approvals\") }),\n  z.object({ type: z.literal(\"needs-approval\") }),\n  z.object({ type: z.literal(\"thinking\") }),\n  z.object({ type: z.literal(\"custom\"), status: z.string() }),\n]);\n\nexport type AgentStatus = z.infer<typeof AgentStatus>;\n\nexport type AgentDataTypes = { status: AgentStatus };\n\n// \u2500\u2500\u2500 Hooks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type AgentHooks = {\n  \"tool.before\"?: (opts: {\n    name: string;\n    input: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { input: unknown }>;\n  \"tool.after\"?: (opts: {\n    name: string;\n    input: unknown;\n    result: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { result: unknown }>;\n  status?: (status: AgentStatus) => void | Promise<void>;\n};\n\n// \u2500\u2500\u2500 Needs Approval \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\ntype ToolName<Tools> = Extract<keyof Tools, string> | BuiltInToolName;\n\ntype ToolInput<Tools, K> = K extends BuiltInToolName\n  ? InferToolInput<(typeof builtInTools)[K]>\n  : K extends keyof Tools\n    ? Tools[K] extends import(\"ai\").Tool\n      ? InferToolInput<Tools[K]>\n      : unknown\n    : unknown;\n\nexport type NeedsApprovalMap<Tools> = {\n  [K in ToolName<Tools>]?:\n    | boolean\n    | ((\n        input: ToolInput<Tools, K>,\n        options: {\n          toolCallId: string;\n          messages: ModelMessage[];\n          experimental_context: unknown;\n        }\n      ) => boolean | Promise<boolean>);\n};\n\n// \u2500\u2500\u2500 Infer UI Message \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type InferUIMessage<A> = A extends {\n  tools: infer T extends ToolSet;\n  $UIMessage: UIMessage<infer M>;\n}\n  ? UIMessage<M, AgentDataTypes, InferUITools<T>>\n  : A extends { tools: infer T extends ToolSet }\n    ? UIMessage<unknown, AgentDataTypes, InferUITools<T>>\n    : UIMessage<unknown, AgentDataTypes>;\n\nexport type TypedUIMessage<\n  TMessageMetadata = unknown,\n  Tools extends ToolSet = ToolSet,\n> = UIMessage<TMessageMetadata, AgentDataTypes, InferUITools<Tools>>;\n\n// \u2500\u2500\u2500 Registry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nclass AgentNotFoundError extends errore.createTaggedError({\n  name: \"AgentNotFoundError\",\n  message: `Agent \"$agentName\" not found in registry.\n\nhint: agent() must be called before workflow steps execute.\n      Valid locations: module scope, or inside a \"use workflow\" body.\n\n  // Module scope (static agents)\n  export const myAgent = agent(\"$agentName\", { ... });\n\n  // Workflow body (dynamic agents)\n  async function myWorkflow({ input }) {\n    \"use workflow\";\n    const myAgent = agent(\"$agentName\", { ... });\n    ...\n  }`,\n}) {}\n\nconst AGENT_REGISTRY_KEY = Symbol.for(\"experimental-agent-registry\");\n\nfunction getAgentRegistry(): Map<string, AnyAgent> {\n  const g = globalThis as Record<symbol, unknown>;\n  let registry = g[AGENT_REGISTRY_KEY] as Map<string, AnyAgent> | undefined;\n  if (!registry) {\n    registry = new Map();\n    g[AGENT_REGISTRY_KEY] = registry;\n  }\n  return registry;\n}\n\nexport function registerAgent(name: string, agent: AnyAgent) {\n  getAgentRegistry().set(name, agent);\n}\nexport function getAgent<Required extends boolean>(\n  name: string,\n  required?: Required\n): Required extends true ? AnyAgent : AnyAgent | undefined {\n  const agent = getAgentRegistry().get(name);\n  if (required && !agent) {\n    throw new AgentNotFoundError({ agentName: name });\n  }\n  return agent as Required extends true ? AnyAgent : AnyAgent | undefined;\n}\n", "import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from \"@workflow/serde\";\nimport type { GatewayModelId, InferUITools, ToolSet, UIMessage } from \"ai\";\nimport type { z } from \"zod\";\nimport type { SandboxBinding, SandboxInstance } from \"../sandbox/adapter\";\nimport type { SandboxContext } from \"../sandbox/handle\";\nimport { sandboxHandle } from \"../sandbox/handle\";\nimport { type SessionContext, sessionHandle } from \"../session/handle\";\nimport type { SkillInput } from \"../skills/types\";\nimport { type Storage, type StorageInput, toStorage } from \"../storage/adapter\";\nimport { kvStorageFallback } from \"../storage/bindings/kv\";\nimport { localStorage } from \"../storage/entry\";\nimport { shouldFallbackToKV2 } from \"../storage/should-fallback-kv2\";\nimport type { GenerationOptions } from \"../storage/types\";\nimport { type BuiltInToolName, builtInTools } from \"../tools\";\nimport type { LoggingConfig } from \"../utils/logger\";\nimport { createLogger } from \"../utils/logger\";\nimport {\n  type AgentDataTypes,\n  type AgentHooks,\n  getAgent,\n  type NeedsApprovalMap,\n  registerAgent,\n} from \"./registry\";\n\n// \u2500\u2500\u2500 Resolvable \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type ResolvableArgs<\n  TContext = Record<string, unknown>,\n  Tools extends ToolSet = ToolSet,\n  TState = Record<string, unknown>,\n> = {\n  context: TContext;\n  sessionId: string;\n  sandbox: SandboxInstance;\n  messages: UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>[];\n  state: Readonly<TState>;\n};\n\nexport type Resolvable<\n  T,\n  TContext = Record<string, unknown>,\n  Tools extends ToolSet = ToolSet,\n  TState = Record<string, unknown>,\n> = T | ((args: ResolvableArgs<TContext, Tools, TState>) => T | Promise<T>);\n\n// \u2500\u2500\u2500 Session Defaults \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type SessionDefaults<\n  Tools extends ToolSet = ToolSet,\n  TContext extends Record<string, unknown> = Record<string, unknown>,\n  TState extends Record<string, unknown> = Record<string, unknown>,\n> = {\n  model?: Resolvable<GatewayModelId | undefined, TContext, Tools, TState>;\n  system?: Resolvable<string | string[] | undefined, TContext, Tools, TState>;\n  generation?: Resolvable<\n    GenerationOptions | undefined,\n    TContext,\n    Tools,\n    TState\n  >;\n  activeTools?: Resolvable<\n    readonly (Extract<keyof Tools, string> | BuiltInToolName)[] | undefined,\n    TContext,\n    Tools,\n    TState\n  >;\n  skills?: Resolvable<SkillInput[] | undefined, TContext, Tools, TState>;\n};\n\n// \u2500\u2500\u2500 Agent Options \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type AgentOptions<\n  // biome-ignore lint/suspicious/noExplicitAny: default allows type-erased usage\n  Tools extends ToolSet = any,\n  TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding,\n  TContext extends Record<string, unknown> = Record<string, never>,\n  TState extends Record<string, unknown> = Record<string, unknown>,\n  TMessageMetadata = unknown,\n> = SessionDefaults<Tools, TContext, TState> & {\n  storage?: StorageInput;\n  sandbox?: TSandboxBindings;\n  tools?: Tools;\n  hooks?: AgentHooks;\n  needsApproval?: NeedsApprovalMap<Tools>;\n  contextSchema?: z.ZodType<TContext>;\n  stateSchema?: z.ZodType<TState>;\n  messageMetadataSchema?: z.ZodType<TMessageMetadata>;\n  logging?: Omit<LoggingConfig, \"name\">;\n};\n\n// \u2500\u2500\u2500 Internal context caches (hidden from public API) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nconst sessionContextsMap = new WeakMap<object, Map<string, SessionContext>>();\nconst sandboxContextsMap = new WeakMap<object, Map<string, SandboxContext>>();\n\nexport function getSessionContexts(\n  agent: AnyAgent\n): Map<string, SessionContext> {\n  let map = sessionContextsMap.get(agent);\n  if (!map) {\n    map = new Map();\n    sessionContextsMap.set(agent, map);\n  }\n  return map;\n}\n\nexport function getSandboxContexts(\n  agent: AnyAgent\n): Map<string, SandboxContext> {\n  let map = sandboxContextsMap.get(agent);\n  if (!map) {\n    map = new Map();\n    sandboxContextsMap.set(agent, map);\n  }\n  return map;\n}\n\n// \u2500\u2500\u2500 Agent Class \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// biome-ignore lint/suspicious/noExplicitAny: intentionally erased \u2013 using `any` avoids contravariance issues with tool-typed methods like `send`\nexport type AnyAgent = Agent<any, any, any, any, any>;\n\nexport type InferSession<Agent extends AnyAgent = AnyAgent> = ReturnType<\n  Agent[\"session\"]\n>;\nexport type SessionSendArgs<\n  Agent extends AnyAgent,\n  Session extends InferSession<Agent> = InferSession<Agent>,\n> = Parameters<Session[\"send\"]>;\n\nexport class Agent<\n  TMessageMetadata = unknown,\n  Tools extends ToolSet = ToolSet,\n  TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding,\n  TContext extends Record<string, unknown> = Record<string, never>,\n  TState extends Record<string, unknown> = Record<string, unknown>,\n> {\n  readonly name: string;\n  options: AgentOptions<\n    Tools,\n    TSandboxBindings,\n    TContext,\n    TState,\n    TMessageMetadata\n  >;\n\n  constructor(\n    name: string,\n    options?: AgentOptions<\n      Tools,\n      TSandboxBindings,\n      TContext,\n      TState,\n      TMessageMetadata\n    >\n  ) {\n    this.name = name;\n    this.options = options ?? {};\n    this.session = (sessionHandle<\n      Tools,\n      TContext,\n      TSandboxBindings,\n      TMessageMetadata,\n      TState\n    >).bind(null, this as unknown as AnyAgent);\n    this.sandbox = (sandboxHandle<TSandboxBindings>).bind(\n      null,\n      this as unknown as AnyAgent\n    );\n  }\n\n  static [WORKFLOW_SERIALIZE](instance: AnyAgent) {\n    return { name: instance.name };\n  }\n\n  static [WORKFLOW_DESERIALIZE](data: { name: string }) {\n    return getAgent(data.name, true);\n  }\n\n  private _resolvedStorage: Storage | undefined;\n\n  get storage(): Storage {\n    if (this._resolvedStorage) {\n      return this._resolvedStorage;\n    }\n\n    if (this.options.storage) {\n      this._resolvedStorage = toStorage(this.options.storage);\n      return this._resolvedStorage;\n    }\n\n    const log = createLogger({\n      config: { ...this.options.logging, name: this.name },\n      subsystem: \"storage\",\n    });\n\n    if (shouldFallbackToKV2()) {\n      log.info(\n        `No storage adapter configured \u2014 using KV2 (namespace: \"${this.name}\").`\n      );\n      this._resolvedStorage = toStorage(\n        kvStorageFallback({ prefix: this.name })\n      );\n      return this._resolvedStorage;\n    }\n\n    log.warn(\n      \"No storage adapter configured \u2014 using localStorage(). Data will not persist across restarts.\"\n    );\n    this._resolvedStorage = toStorage(localStorage());\n    return this._resolvedStorage;\n  }\n\n  get tools() {\n    return { ...builtInTools, ...this.options.tools } as typeof builtInTools &\n      Tools;\n  }\n\n  get hooks(): AgentHooks {\n    return this.options.hooks ?? {};\n  }\n\n  readonly session;\n\n  readonly sandbox;\n\n  /**\n   * Create a derived agent with merged options. The returned agent is NOT\n   * registered in the workflow registry \u2013 it's a one-off instance used by\n   * the framework to layer fs-scanned config onto an agent.ts definition.\n   */\n  extend(\n    fn: (options: AgentOptions<Tools, TSandboxBindings, TContext, TState, TMessageMetadata>) => AgentOptions<Tools, TSandboxBindings, TContext, TState, TMessageMetadata>\n  ): Agent<TMessageMetadata, Tools, TSandboxBindings, TContext, TState> {\n    return new Agent(this.name, fn(this.options));\n  }\n\n  /** Phantom property for type inference. Use `typeof myAgent.$UIMessage` to get the typed UIMessage. */\n  declare readonly $UIMessage: UIMessage<\n    TMessageMetadata,\n    AgentDataTypes,\n    InferUITools<typeof builtInTools & Tools>\n  >;\n}\n\nexport function agent<\n  Tools extends ToolSet = ToolSet,\n  TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding,\n  TContext extends Record<string, unknown> = Record<string, never>,\n  TState extends Record<string, unknown> = Record<string, unknown>,\n  TMessageMetadata = unknown,\n>(\n  name: string,\n  options?: AgentOptions<\n    Tools,\n    TSandboxBindings,\n    TContext,\n    TState,\n    TMessageMetadata\n  >\n) {\n  const instance = new Agent<\n    TMessageMetadata,\n    Tools,\n    TSandboxBindings,\n    TContext,\n    TState\n  >(name, options);\n  registerAgent(name, instance);\n  return instance;\n}\n\n// Re-export everything from registry so existing imports from \"./agent/client\" keep working.\nexport {\n  type AgentDataTypes,\n  type AgentHooks,\n  AgentStatus,\n  getAgent,\n  type InferUIMessage,\n  type NeedsApprovalMap,\n  registerAgent,\n  type TypedUIMessage,\n} from \"./registry\";\n", "import { ulid } from \"ulid\";\nimport type { AnyAgent } from \"../agent/client\";\nimport { getSandboxContexts } from \"../agent/client\";\nimport type { SandboxBinding, SandboxInstance } from \"./adapter\";\nimport { exec } from \"./exec\";\nimport { getDomain } from \"./get-domain\";\nimport { getStatus } from \"./get-status\";\nimport { kill } from \"./kill\";\nimport { readFile } from \"./read-file\";\nimport { setup } from \"./setup\";\nimport { snapshot } from \"./snapshot\";\nimport { start } from \"./start\";\nimport { stop } from \"./stop\";\nimport { updateNetworkPolicy } from \"./update-network-policy\";\nimport { writeFiles } from \"./write-files\";\n\nexport type SandboxContext = {\n  agent: AnyAgent;\n  sandboxId: string | null;\n  _pendingSetup?: Promise<SandboxInstance>;\n  _cwd?: string;\n  _sessionId?: string;\n};\n\nexport type SandboxOptions = {\n  id?: string;\n};\n\nexport type SandboxHandle<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding,\n> = ReturnType<typeof sandboxHandle<TSandboxBindings>>;\n\nexport function sandboxHandle<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[],\n>(agent: AnyAgent, id?: string | SandboxOptions) {\n  const sandboxId =\n    typeof id === \"string\" ? id : (id?.id ?? `sandbox_${ulid()}`);\n\n  const contexts = getSandboxContexts(agent);\n  let sandboxContext = contexts.get(sandboxId);\n  if (!sandboxContext) {\n    sandboxContext = { agent, sandboxId };\n    contexts.set(sandboxId, sandboxContext);\n  }\n\n  return {\n    id: sandboxId,\n    get cwd() {\n      return sandboxContext!._cwd ?? \".\";\n    },\n    setup: (setup<TSandboxBindings>).bind(null, sandboxContext),\n    exec: exec.bind(null, sandboxContext),\n    readFile: readFile.bind(null, sandboxContext),\n    writeFiles: writeFiles.bind(null, sandboxContext),\n    getDomain: getDomain.bind(null, sandboxContext),\n    updateNetworkPolicy: updateNetworkPolicy.bind(null, sandboxContext),\n    start: start.bind(null, sandboxContext),\n    stop: stop.bind(null, sandboxContext),\n    kill: kill.bind(null, sandboxContext),\n    snapshot: snapshot.bind(null, sandboxContext),\n    getStatus: getStatus.bind(null, sandboxContext),\n  };\n}\n\ntype SandboxMethods<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[],\n> = Omit<SandboxHandle<TSandboxBindings>, \"id\" | \"cwd\">;\n\nexport function lazySandboxHandle<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[],\n>(\n  agent: AnyAgent,\n  sessionId: string\n): SandboxMethods<TSandboxBindings> {\n  const sandboxContext: SandboxContext = {\n    agent,\n    sandboxId: null,\n    _sessionId: sessionId,\n  };\n\n  return {\n    setup: (setup<TSandboxBindings>).bind(null, sandboxContext),\n    exec: exec.bind(null, sandboxContext),\n    readFile: readFile.bind(null, sandboxContext),\n    writeFiles: writeFiles.bind(null, sandboxContext),\n    getDomain: getDomain.bind(null, sandboxContext),\n    updateNetworkPolicy: updateNetworkPolicy.bind(null, sandboxContext),\n    start: start.bind(null, sandboxContext),\n    stop: stop.bind(null, sandboxContext),\n    kill: kill.bind(null, sandboxContext),\n    snapshot: snapshot.bind(null, sandboxContext),\n    getStatus: getStatus.bind(null, sandboxContext),\n  };\n}\n", "export const isVercel = async () => {\n  try {\n    const { getVercelOidcToken } = await import(\"@vercel/oidc\");\n    return Boolean(await getVercelOidcToken());\n  } catch {\n    return false;\n  }\n};\n", "import { isVercel } from \"../agent/is-vercel\";\nimport { SandboxError, SandboxNotFoundError } from \"../errors\";\nimport type { Sandbox } from \"../storage/types\";\nimport { createLogger } from \"../utils/logger\";\nimport type {\n  SandboxBinding,\n  SandboxInstance,\n  SandboxSetupFields,\n  WithConfig,\n} from \"./adapter\";\nimport type { BuiltInBindings } from \"./bindings\";\nimport type { SandboxContext } from \"./handle\";\n\nconst POLL_INTERVAL_MS = 50;\nconst POLL_TIMEOUT_MS = 5 * 60 * 1000;\n\ntype SetupCommonFields = Partial<SandboxSetupFields> & {\n  cwd?: string;\n  run?: (sandbox: SandboxInstance) => Promise<void>;\n  signal?: AbortSignal;\n};\n\ntype ToBindingUnion<T extends SandboxBinding | SandboxBinding[]> =\n  T extends SandboxBinding[] ? T[number] : T;\n\ntype SetupOptsForBinding<B extends SandboxBinding> =\n  // biome-ignore lint/suspicious/noExplicitAny: .\n  B extends SandboxBinding<infer T, infer C, any>\n    ? { type: T } & SetupCommonFields & WithConfig<C>\n    : never;\n\ntype IsDefault<T extends SandboxBinding | SandboxBinding[]> =\n  SandboxBinding extends T ? true : false;\n\nexport type SetupOpts<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[],\n> =\n  | SetupOptsForBinding<\n      IsDefault<TSandboxBindings> extends true\n        ? BuiltInBindings\n        : ToBindingUnion<TSandboxBindings>\n    >\n  | (SetupCommonFields & { type?: never });\n\nexport type SetupResult = {\n  done: Promise<SandboxInstance>;\n};\n\nfunction isSingleBinding(\n  sandbox: SandboxBinding | SandboxBinding[]\n): sandbox is SandboxBinding {\n  return !Array.isArray(sandbox);\n}\n\n/** Auto-detect the default binding: vercel \u2192 docker \u2192 local cascade. */\nasync function getDefaultBinding(): Promise<SandboxBinding> {\n  if (await isVercel()) {\n    const { vercelSandbox } = await import(\"./bindings/vercel\");\n    return vercelSandbox();\n  }\n\n  if (await isDockerAvailable()) {\n    const { dockerSandbox } = await import(\"./bindings/docker\");\n    return dockerSandbox();\n  }\n\n  const { localSandbox } = await import(\"./bindings/local\");\n  return localSandbox();\n}\n\nasync function isDockerAvailable(): Promise<boolean> {\n  try {\n    const { execSync } = await import(\"node:child_process\");\n    execSync(\"docker sandbox --help\", { stdio: \"ignore\", timeout: 5000 });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function resolveBinding(\n  sandbox: SandboxBinding | SandboxBinding[] | undefined,\n  type?: string\n): Promise<{ binding: SandboxBinding; bindingName: string }> {\n  if (!sandbox) {\n    const binding = await getDefaultBinding();\n    return { binding, bindingName: binding.type };\n  }\n  if (isSingleBinding(sandbox)) {\n    return { binding: sandbox, bindingName: sandbox.type };\n  }\n  if (type) {\n    const match = sandbox.find((b) => b.type === type);\n    if (!match) {\n      throw new SandboxError({\n        reason: `Unknown binding type: \"${type}\". Available: ${sandbox.map((b) => b.type).join(\", \")}`,\n      });\n    }\n    return { binding: match, bindingName: match.type };\n  }\n  if (sandbox.length === 0) {\n    throw new SandboxError({ reason: \"No sandbox bindings configured\" });\n  }\n  return { binding: sandbox[0], bindingName: sandbox[0].type };\n}\n\nasync function resolveSandboxId(ctx: SandboxContext): Promise<string> {\n  if (ctx.sandboxId) {\n    return ctx.sandboxId;\n  }\n  if (!ctx._sessionId) {\n    throw new Error(\n      \"SandboxContext has no sandboxId and no sessionId to resolve from\"\n    );\n  }\n  const record = await ctx.agent.storage.session.get(ctx._sessionId);\n  ctx.sandboxId = record?.sandboxId ?? ctx._sessionId;\n  return ctx.sandboxId;\n}\n\nexport async function setup<\n  TSandboxBindings extends SandboxBinding | SandboxBinding[],\n>(\n  ctx: SandboxContext,\n  opts?: SetupOpts<TSandboxBindings>\n): Promise<SetupResult> {\n  \"use step\";\n  const sandboxId = await resolveSandboxId(ctx);\n  if (ctx._pendingSetup) {\n    return { done: ctx._pendingSetup };\n  }\n\n  const agent = ctx.agent;\n  const log = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"sandbox:setup\",\n    context: { sandboxId },\n  });\n\n  const doneResolveBinding = log.time(\"resolve binding\", {\n    requestedType: opts?.type,\n  });\n  const { binding, bindingName } = await resolveBinding(\n    agent.options.sandbox,\n    opts?.type\n  );\n  doneResolveBinding();\n\n  if (opts?.cwd) {\n    ctx._cwd = opts.cwd;\n  }\n\n  const setupLog = log.withContext({\n    binding: bindingName,\n    version: opts?.version ?? binding.defaults?.version,\n  });\n\n  // biome-ignore lint/suspicious/noConfusingVoidType: .\n  let resolveBlockingPromise = (value: void) => value;\n  // biome-ignore lint/suspicious/noExplicitAny: .\n  // biome-ignore lint/suspicious/noEmptyBlockStatements: .\n  let rejectBlockingPromise = (_reason?: any) => {};\n  const blockingPromise = new Promise<void>((resolve, reject) => {\n    resolveBlockingPromise = resolve;\n    rejectBlockingPromise = reject;\n  });\n\n  ctx._pendingSetup = (async () => {\n    let sleepOldInstance: Promise<void> | undefined;\n    const donePendingSetup = setupLog.time(\"pending setup\");\n\n    try {\n      const doneStorageGet = setupLog.time(\"storage.sandbox.get\");\n      const record = await agent.storage.sandbox.get(sandboxId);\n      doneStorageGet();\n\n      const bindingDefaults = binding.defaults ?? {};\n      const effectiveVersion = opts?.version ?? bindingDefaults.version ?? null;\n      const effectiveRun = opts?.run ?? bindingDefaults.run;\n      const effectiveNetworkPolicy =\n        opts?.networkPolicy ?? bindingDefaults.networkPolicy ?? null;\n      const effectiveCwd =\n        ctx._cwd || opts?.cwd || bindingDefaults.cwd || null;\n      if (effectiveCwd) {\n        ctx._cwd = effectiveCwd;\n      }\n      const effectiveConfig = {\n        ...bindingDefaults.config,\n        // biome-ignore lint/suspicious/noExplicitAny: opts is a union; config exists on binding-specific branches\n        ...(opts as any)?.config,\n      };\n\n      if (record) {\n        const versionMatches =\n          !effectiveVersion || record.setup?.version === effectiveVersion;\n\n        if (versionMatches && record.setup?.completedAt) {\n          resolveBlockingPromise();\n          const doneConnectExisting = setupLog.time(\n            \"connect existing sandbox\",\n            {\n              setupState: \"completed\",\n            }\n          );\n          const instance = await binding.connect({\n            agent,\n            metadata: record.setup.metadata,\n            cwd: record.setup.cwd,\n            signal: opts?.signal,\n            log: setupLog,\n          });\n          doneConnectExisting();\n          ctx._cwd = instance.cwd;\n          return instance;\n        }\n\n        if (versionMatches && !record.setup?.completedAt) {\n          resolveBlockingPromise();\n          const donePollUntilReady = setupLog.time(\"poll until ready\");\n          await pollUntilReady(ctx, opts?.signal);\n          donePollUntilReady();\n\n          const doneStorageGetPostPoll = setupLog.time(\n            \"storage.sandbox.get (post-poll)\"\n          );\n          const ready = await agent.storage.sandbox.get(sandboxId);\n          doneStorageGetPostPoll();\n\n          if (!ready) {\n            throw new SandboxNotFoundError({ id: sandboxId });\n          }\n          const doneConnectExisting = setupLog.time(\n            \"connect existing sandbox\",\n            {\n              setupState: \"post-poll\",\n            }\n          );\n          const instance = await binding.connect({\n            agent,\n            metadata: ready.setup.metadata,\n            cwd: ready.setup.cwd,\n            signal: opts?.signal,\n            log: setupLog,\n          });\n          doneConnectExisting();\n          ctx._cwd = instance.cwd;\n          return instance;\n        }\n\n        if (record.setup.metadata) {\n          const oldInstanceMetadata = record.setup.metadata;\n          sleepOldInstance = (async () => {\n            const doneStopOldInstance = setupLog.time(\n              \"stop old sandbox instance\"\n            );\n            try {\n              const old = await binding.connect({\n                agent,\n                metadata: oldInstanceMetadata,\n                log: setupLog,\n              });\n              await old.stop();\n            } catch {\n              doneStopOldInstance();\n              return;\n            }\n            doneStopOldInstance();\n          })();\n        }\n      }\n\n      const now = Date.now();\n      const setup_: Sandbox[\"setup\"] = {\n        binding: bindingName,\n        version: effectiveVersion ?? record?.setup?.version ?? null,\n        networkPolicy:\n          effectiveNetworkPolicy ?? record?.setup?.networkPolicy ?? null,\n        completedAt: null,\n        metadata: null,\n        cwd: null,\n      };\n\n      const newRecord: Sandbox = {\n        id: sandboxId,\n        setup: setup_,\n        createdAt: record?.createdAt ?? now,\n        lastActiveAt: now,\n      };\n\n      const doneStorageSetPending = setupLog.time(\n        \"storage.sandbox.set (setup pending)\"\n      );\n      await agent.storage.sandbox.set(sandboxId, newRecord);\n      doneStorageSetPending();\n\n      resolveBlockingPromise();\n\n      const doneBindingCreate = setupLog.time(\"binding.create\");\n      const result = await binding.create({\n        cwd: ctx._cwd ?? \".\",\n        agent,\n        setup: {\n          ...setup_,\n          run: effectiveRun,\n          config: effectiveConfig,\n        },\n        record: newRecord,\n        signal: opts?.signal,\n        log: setupLog,\n      });\n      doneBindingCreate();\n\n      setup_.completedAt = Date.now();\n      setup_.metadata = result.metadata;\n      setup_.cwd = result.instance.cwd;\n\n      const doneStorageUpdateComplete = setupLog.time(\n        \"storage.sandbox.update (setup complete)\"\n      );\n      await agent.storage.sandbox.update(sandboxId, {\n        setup: setup_,\n        lastActiveAt: Date.now(),\n      });\n      doneStorageUpdateComplete();\n\n      ctx._cwd = result.instance.cwd;\n      return result.instance;\n    } catch (err) {\n      ctx._pendingSetup = undefined;\n      rejectBlockingPromise(err);\n      throw err;\n    } finally {\n      const doneFinalize = setupLog.time(\"finalize setup\");\n      await sleepOldInstance;\n      doneFinalize();\n      donePendingSetup();\n    }\n  })();\n\n  const doneWaitForUnblock = setupLog.time(\"wait for setup unblock\");\n  await blockingPromise;\n  doneWaitForUnblock();\n  return { done: ctx._pendingSetup };\n}\n\nexport async function resolve(\n  ctx: SandboxContext,\n  signal?: AbortSignal\n): Promise<SandboxInstance> {\n  const sandboxId = await resolveSandboxId(ctx);\n  const agent = ctx.agent;\n  const log = createLogger({\n    config: { ...agent.options.logging, name: agent.name },\n    subsystem: \"sandbox:resolve\",\n    context: { sandboxId },\n  });\n\n  if (ctx._pendingSetup) {\n    return await ctx._pendingSetup;\n  }\n\n  let record = await agent.storage.sandbox.get(sandboxId);\n\n  if (!record) {\n    const { done } = await setup(ctx, { signal });\n    return await done;\n  }\n\n  if (!record.setup?.completedAt) {\n    await pollUntilReady(ctx, signal);\n    record = await agent.storage.sandbox.get(sandboxId);\n  }\n\n  if (!record) {\n    throw new SandboxNotFoundError({ id: sandboxId });\n  }\n\n  const { binding } = await resolveBinding(\n    ctx.agent.options.sandbox,\n    record.setup.binding\n  );\n\n  agent.storage.sandbox\n    .update(sandboxId, { lastActiveAt: Date.now() })\n    .catch((error) => {\n      log.error(\"Failed to update sandbox lastActiveAt\", { error });\n    });\n\n  const instance = await binding.connect({\n    agent,\n    metadata: record.setup.metadata,\n    cwd: record.setup.cwd,\n    signal,\n    log,\n  });\n  ctx._cwd = instance.cwd;\n  return instance;\n}\n\nasync function pollUntilReady(\n  ctx: SandboxContext,\n  signal?: AbortSignal\n): Promise<void> {\n  const id = ctx.sandboxId!;\n  const deadline = Date.now() + POLL_TIMEOUT_MS;\n\n  while (Date.now() < deadline) {\n    signal?.throwIfAborted();\n\n    const record = await ctx.agent.storage.sandbox.get(id);\n    if (record?.setup?.completedAt) {\n      return;\n    }\n\n    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));\n  }\n\n  throw new SandboxError({\n    reason: `Timed out waiting for sandbox \"${id}\" setup to complete`,\n  });\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function exec(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"exec\"]>\n) {\n  // note: .exec can't be a step because it returns logs and a result promise which can't be serialized\n  const sbx = await resolve(sandboxContext);\n  return await sbx.exec(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function getDomain(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"getDomain\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.getDomain(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function getStatus(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"getStatus\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.getStatus(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function kill(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"kill\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.kill(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function readFile(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"readFile\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.readFile(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function snapshot(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"snapshot\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.snapshot(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function start(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"start\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.start(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function stop(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"stop\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.stop(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function updateNetworkPolicy(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"updateNetworkPolicy\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.updateNetworkPolicy(...opts);\n}\n", "import type { SandboxInstance } from \"./adapter\";\nimport type { SandboxContext } from \"./handle\";\nimport { resolve } from \"./setup\";\n\nexport async function writeFiles(\n  sandboxContext: SandboxContext,\n  ...opts: Parameters<SandboxInstance[\"writeFiles\"]>\n) {\n  \"use step\";\n  const sbx = await resolve(sandboxContext);\n  return await sbx.writeFiles(...opts);\n}\n", "import type { ToolSet } from \"ai\";\nimport { ulid } from \"ulid\";\nimport type { AnyAgent } from \"../agent/client\";\nimport { getSessionContexts } from \"../agent/client\";\nimport type { SandboxBinding } from \"../sandbox/adapter\";\nimport { lazySandboxHandle } from \"../sandbox/handle\";\nimport { history } from \"./history\";\nimport { interrupt } from \"./interrupt\";\nimport { send } from \"./send\";\nimport { stream } from \"./stream\";\nimport { update } from \"./update\";\nimport { usage } from \"./usage\";\n\ntype SessionOptions = {\n  id?: string;\n};\n\nexport type SessionContext = {\n  agent: AnyAgent;\n  sessionId: string;\n};\n\nexport function sessionHandle<\n  Tools extends ToolSet,\n  TContext,\n  TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding,\n  TMessageMetadata = unknown,\n  TState extends Record<string, unknown> = Record<string, unknown>,\n>(agent: AnyAgent, id?: string | SessionOptions) {\n  const sessionId =\n    typeof id === \"string\" ? id : (id?.id ?? `session_${ulid()}`);\n\n  const contexts = getSessionContexts(agent);\n  let sessionContext = contexts.get(sessionId);\n  if (!sessionContext) {\n    sessionContext = { agent, sessionId };\n    contexts.set(sessionId, sessionContext);\n  }\n\n  return {\n    id: sessionId,\n    send: (send<Tools, TContext, TMessageMetadata, TState>).bind(\n      null,\n      sessionContext\n    ),\n    stream: stream.bind(null, sessionContext),\n    history: (history<Tools>).bind(null, sessionContext),\n    interrupt: interrupt.bind(null, sessionContext),\n    usage: usage.bind(null, sessionContext),\n    update: (update<TState>).bind(null, sessionContext),\n    sandbox: lazySandboxHandle<TSandboxBindings>(agent, sessionId),\n  };\n}\n", "export type StepUsage = {\n  stepIndex: number;\n  model: string;\n  inputTokens: number;\n  outputTokens: number;\n  totalTokens: number;\n  cacheReadTokens: number;\n  cacheWriteTokens: number;\n  reasoningTokens: number;\n};\n\nexport type UsageSummary = {\n  model: string;\n  inputTokens: number;\n  outputTokens: number;\n  totalTokens: number;\n  cacheReadTokens: number;\n  cacheWriteTokens: number;\n  reasoningTokens: number;\n  stepCount: number;\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", "import type { ToolSet } from \"ai\";\nimport { assembleUIMessages } from \"../utils/ui\";\nimport { computeSessionUsage, type SessionUsage } from \"../utils/usage\";\nimport type { SessionContext } from \"./handle\";\n\nexport type HistoryResult = {\n  messages: ReturnType<typeof assembleUIMessages>;\n  streamingMessageId: string | null;\n  usage: SessionUsage;\n};\n\nexport async function history<Tools extends ToolSet>(\n  sessionContext: SessionContext\n) {\n  \"use step\";\n  const [session, messages, parts] = await Promise.all([\n    sessionContext.agent.storage.session.get(sessionContext.sessionId),\n    sessionContext.agent.storage.message.listBySession(\n      sessionContext.sessionId\n    ),\n    sessionContext.agent.storage.part.listBySession(sessionContext.sessionId),\n  ]);\n\n  const lastAssistant =\n    messages.find(\n      (m) => m.id === session?.lastMessageId && m.role === \"assistant\"\n    ) ?? messages.filter((m) => m.role === \"assistant\").at(-1);\n\n  const isStreaming =\n    lastAssistant?.completedAt === null &&\n    lastAssistant?.interruptedAt === null;\n  const streamingMessageId = isStreaming ? lastAssistant.id : null;\n  const visibleUntil = lastAssistant?.createdAt;\n\n  const assembled = assembleUIMessages<Tools>({\n    messages,\n    parts,\n    includeQueued: visibleUntil !== undefined,\n    until: visibleUntil,\n  });\n\n  const usage = computeSessionUsage(messages);\n\n  return { messages: assembled, streamingMessageId, usage };\n}\n", "import type { UIMessageChunk } from \"ai\";\nimport * as errore from \"errore\";\nimport { SessionNotFoundError } from \"../errors\";\nimport type { SessionContext } from \"./handle\";\nimport { getActiveRuns, replayActiveRun } from \"./send\";\n\nexport type StreamOptions = {\n  messageId?: string;\n  startIndex?: number;\n};\n\nexport type WorkflowRunLike = {\n  getReadable(options?: { startIndex?: number }): ReadableStream;\n};\n\nfunction isWorkflowRun(arg: unknown): arg is WorkflowRunLike {\n  return (\n    typeof arg === \"object\" &&\n    arg !== null &&\n    \"getReadable\" in arg &&\n    typeof (arg as WorkflowRunLike).getReadable === \"function\"\n  );\n}\n\nexport async function stream(\n  sessionContext: SessionContext,\n  runOrOpts?: WorkflowRunLike | StreamOptions\n): Promise<ReadableStream<UIMessageChunk>> {\n  if (isWorkflowRun(runOrOpts)) {\n    const reader = runOrOpts.getReadable().getReader();\n    // await for the first chunk to be ready before finishing the workflow to avoid race conditions\n    await reader.read().catch(() => {\n      throw new StreamError({\n        id: sessionContext.sessionId,\n        reason: \"stream() failed to read first chunk from workflow run\",\n      });\n    });\n    reader.cancel();\n\n    return runOrOpts.getReadable();\n  }\n\n  const opts = runOrOpts;\n  const session = await sessionContext.agent.storage.session.get(\n    sessionContext.sessionId\n  );\n  if (!session) {\n    throw new SessionNotFoundError({ id: sessionContext.sessionId });\n  }\n  const messageId = opts?.messageId ?? session.lastMessageId;\n  if (!messageId) {\n    throw new StreamError({\n      id: sessionContext.sessionId,\n      reason: \"No message to stream\",\n    });\n  }\n\n  const activeRuns = getActiveRuns();\n  const active = activeRuns.get(messageId);\n  if (!active) {\n    const message = await sessionContext.agent.storage.message.get(messageId);\n    if (message?.workflowRunId) {\n      const readable = await import(\"workflow/api\")\n        .then(({ getRun }) => getRun(message.workflowRunId!).getReadable())\n        .catch(() => undefined);\n      if (readable) {\n        return readable;\n      }\n    }\n\n    throw new StreamError({\n      id: sessionContext.sessionId,\n      reason: `No active run for message ${messageId}`,\n    });\n  }\n\n  return replayActiveRun(active, opts?.startIndex);\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Errors\n * -----------------------------------------------------------------------------------------------*/\n\nexport class StreamError extends errore.createTaggedError({\n  name: \"StreamError\",\n  message: \"Stream failed for session $id: $reason\",\n}) {}\n", "import type { Session } from \"../storage/types\";\nimport type { SessionContext } from \"./handle\";\n\nexport type UpdateOptions<\n  TState extends Record<string, unknown> = Record<string, unknown>,\n> = Partial<Omit<Session, \"id\" | \"createdAt\" | \"updatedAt\" | \"state\">> & {\n  state?: TState;\n};\n\nexport async function update<\n  TState extends Record<string, unknown> = Record<string, unknown>,\n>(\n  sessionContext: SessionContext,\n  opts: UpdateOptions<TState>\n) {\n  \"use step\";\n  const updates = Object.fromEntries(\n    Object.entries(opts).filter(([, value]) => value !== undefined)\n  );\n\n  if (Object.keys(updates).length === 0) {\n    return;\n  }\n\n  await sessionContext.agent.storage.session.update(sessionContext.sessionId, {\n    ...updates,\n    updatedAt: Date.now(),\n  });\n}\n", "import { computeSessionUsage, type SessionUsage } from \"../utils/usage\";\nimport type { SessionContext } from \"./handle\";\n\nexport async function usage(\n  sessionContext: SessionContext\n): Promise<SessionUsage> {\n  \"use step\";\n  const messages = await sessionContext.agent.storage.message.listBySession(\n    sessionContext.sessionId\n  );\n  return computeSessionUsage(messages);\n}\n"],
  "mappings": "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",
  "names": ["tool", "ulid", "z", "errore", "agent", "log", "readFile", "resolve", "log", "agent", "resolve", "log", "sandbox", "sandboxRecord", "stream", "usage", "agent", "log", "usage", "now", "id", "tool", "exec", "tool", "agent", "tool", "z", "agent", "ulid", "start", "state", "errore", "z", "agent", "ulid", "agent", "log", "resolve", "agent", "ulid", "ulid", "usage", "errore", "agent", "ulid", "agent", "log"]
}
