@agent-compose/sdk 0.2.3 → 0.2.5

package/src/runtimes/claude.ts

@@ -1,304 +1,173 @@
-/**
- * Claude CLI runtime — drives agents via the Claude CLI inside a sandbox.
- *
- * Works with any SandboxProvider (E2B, Vercel, etc.) — the provider is
- * selected via SANDBOX_PROVIDER env var, not the runtime definition.
- *
- * Usage:
- *   import { createClaudeRuntime } from "@agent-compose/sdk";
- *   export default createClaudeRuntime({ claudeMdContent: "..." }); // optional global instructions
- */
+/** Claude Agent SDK runtime — replaces the old Claude CLI subprocess runtime. */
 
-import type { SandboxProvider, AgentMessage, ModelExecutionContract, RuntimeOptions } from "../index.js";
+import { query, type HookCallback, type PreToolUseHookInput, type ThinkingConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { AgentMessage, ModelExecutionContract, RuntimeOptions, SandboxProvider, ToolCallGateResult } from "../index.js";
 import { defineRuntime } from "../types/runtime.js";
 import { DEFAULT_CLAUDE_MODEL } from "../agent/agent-loop.js";
+import { runProcessorChain } from "../processors/runner.js";
+import type { ProcessorContext, ToolCall } from "../processors/processor.js";
+import { RequestContext } from "../request-context/request-context.js";
 import { formatError } from "../utils/errors.js";
 
-const NO_TIMEOUT = 0; // claude exits on its own via --max-turns
+function now(): string { return new Date().toISOString(); }
 
-
-function translateEvent(event: Record<string, unknown>): AgentMessage[] {
+function translateMessage(message: Record<string, unknown>): AgentMessage[] {
+  const ts = now();
   const msgs: AgentMessage[] = [];
-  const ts = new Date().toISOString();
 
-  if (event.type === "system" && event.subtype === "init") {
-    msgs.push({ type: "init", sessionId: String(event.session_id ?? ""), timestamp: ts });
+  if (message.type === "system" && message.subtype === "init") {
+    msgs.push({ type: "init", sessionId: String(message.session_id ?? ""), timestamp: ts });
     return msgs;
   }
 
-  if (event.type === "assistant") {
-    const message = event.message as { content?: unknown[] } | undefined;
-    for (const block of message?.content ?? []) {
+  if (message.type === "assistant") {
+    const raw = message.message as { content?: unknown[] } | undefined;
+    for (const block of raw?.content ?? []) {
       const b = block as Record<string, unknown>;
-      if (b.type === "text")     msgs.push({ type: "text", text: String(b.text ?? ""), timestamp: ts });
+      if (b.type === "text") msgs.push({ type: "text", text: String(b.text ?? ""), timestamp: ts });
       if (b.type === "thinking") msgs.push({ type: "thinking", text: String(b.thinking ?? ""), timestamp: ts });
       if (b.type === "tool_use") msgs.push({ type: "tool_use", toolName: String(b.name ?? ""), toolInput: (b.input ?? {}) as Record<string, unknown>, toolUseId: String(b.id ?? ""), timestamp: ts });
     }
     return msgs;
   }
 
-  if (event.type === "user") {
-    const message = event.message as { content?: unknown[] } | undefined;
-    for (const block of message?.content ?? []) {
+  if (message.type === "user") {
+    const raw = message.message as { content?: unknown[] } | undefined;
+    for (const block of raw?.content ?? []) {
       const b = block as Record<string, unknown>;
-      if (b.type === "tool_result") {
-        const raw = b.content;
-        msgs.push({ type: "tool_result", toolUseId: String(b.tool_use_id ?? ""), output: typeof raw === "string" ? raw : JSON.stringify(raw ?? ""), isError: Boolean(b.is_error), timestamp: ts });
-      }
+      if (b.type === "tool_result") msgs.push({ type: "tool_result", toolUseId: String(b.tool_use_id ?? ""), output: typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? ""), isError: Boolean(b.is_error), timestamp: ts });
     }
     return msgs;
   }
 
-  if (event.type === "result") {
-    const usage = event.usage as Record<string, number> | undefined;
-    if (usage) {
-      msgs.push({ type: "usage", inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0, cacheReadTokens: usage.cache_read_input_tokens ?? 0, cacheCreationTokens: usage.cache_creation_input_tokens ?? 0, durationMs: Number(event.duration_ms ?? 0), numTurns: Number(event.num_turns ?? 0), timestamp: ts });
+  if (message.type === "result") {
+    if (typeof message.result === "string" && message.result.trim()) {
+      msgs.push({ type: "text", text: message.result, timestamp: ts });
     }
-    if (event.is_error || event.subtype === "error_during_execution") {
-      const raw = event.error ?? event.result ?? event.message;
-      msgs.push({ type: "error", text: raw == null ? "Unknown error" : typeof raw === "object" ? JSON.stringify(raw) : String(raw), timestamp: ts });
+    const usage = message.usage as Record<string, number> | undefined;
+    if (usage) msgs.push({
+      type: "usage",
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+      cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+      durationMs: Number(message.duration_ms ?? 0),
+      numTurns: Number(message.num_turns ?? 0),
+      timestamp: ts,
+    });
+    if (message.is_error || message.subtype === "error_during_execution") {
+      msgs.push({ type: "error", text: formatError(message.error ?? message.result ?? message.message), timestamp: ts });
     } else {
-      msgs.push({ type: "done", sessionId: String(event.session_id ?? ""), timestamp: ts });
+      msgs.push({ type: "done", sessionId: String(message.session_id ?? ""), timestamp: ts });
     }
-    return msgs;
   }
 
   return msgs;
 }
 
+export interface ClaudeRuntimeConfig {
+  /** Global instructions appended to the Claude Code system prompt. */
+  claudeMdContent?: string;
+  /** Env overrides for Agent SDK provider routing. */
+  env?: Record<string, string>;
+  /** Model to use. Defaults to DEFAULT_CLAUDE_MODEL. */
+  model?: string;
+  /** MCP servers to configure for the Agent SDK. */
+  mcpServers?: Record<string, { command: string; args?: string[]; env?: Record<string, string> }>;
+  /** Claude Code executable. Defaults to `claude` from PATH inside the sandbox. */
+  pathToClaudeCodeExecutable?: string;
+  /** Controls Claude's extended thinking behavior when supported by the model. */
+  thinking?: ThinkingConfig;
+  /** Reasoning effort hint for models that support adaptive thinking. */
+  effort?: "low" | "medium" | "high" | "xhigh" | "max";
+}
+
 export class ClaudeRunner implements ModelExecutionContract {
-  private claudeMdWritten = false;
-  private homeDir: string | null = null;
-  private label: string;
+  supportsToolCallProcessor = true;
 
   constructor(
-    private sandbox: SandboxProvider,
-    private options: RuntimeOptions = {},
-    private claudeMdContent: string = "",
-    private configEnv: Record<string, string> = {},
-    private configModel?: string,
-    private configMcpServers?: Record<string, { command: string; args?: string[]; env?: Record<string, string> }>,
-  ) {
-    this.label = options.label ?? "[Agent]";
-  }
-
-  private async getHomeDir(): Promise<string> {
-    if (!this.homeDir) {
-      const { stdout } = await this.sandbox.commands.run("echo $HOME", { timeoutMs: 30_000 });
-      this.homeDir = stdout.trim() || "/home/user";
-    }
-    return this.homeDir;
+    // Claude Agent SDK executes in this process. In dispatched workflows this
+    // process is already the runner sandbox, so there is no remote provider hop.
+    _sandbox: SandboxProvider,
+    private readonly options: RuntimeOptions = {},
+    private readonly config: ClaudeRuntimeConfig = {},
+  ) {}
+
+  async gateToolCall(call: ToolCall, ctx: ProcessorContext): Promise<ToolCallGateResult> {
+    const verdict = await runProcessorChain(this.options.processors ?? [], p => p.processToolCall, call, ctx);
+    if (verdict.kind === "continue") return { kind: "allow", call: verdict.value };
+    return verdict;
   }
 
-  private async deployGlobalConfig(): Promise<void> {
-    if (this.claudeMdWritten) return;
-    const home = await this.getHomeDir();
-
-    await this.sandbox.commands.run(`mkdir -p "${home}/.claude" && find "${home}/.claude" -name "*.json" -not -name "CLAUDE.md" -delete 2>/dev/null || true`, { timeoutMs: 5000 });
-    await this.sandbox.files.write(`${home}/.claude/CLAUDE.md`, this.claudeMdContent);
-    // Write env overrides to settings.json so the CLI picks them up at startup.
-    // This is how the CLI reads ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, etc.
-    if (Object.keys(this.configEnv).length) {
-      const settings = JSON.stringify({ env: this.configEnv });
-      const b64 = Buffer.from(settings).toString("base64");
-      await this.sandbox.commands.run(`echo "${b64}" | base64 -d > "${home}/.claude/settings.json"`, { timeoutMs: 5_000 });
-    }
-    // MCP servers: config-level (from createClaudeRuntime) as base, opts-level (from agent definition) overrides.
-    const mcpServers = this.configMcpServers;
-    if (mcpServers && Object.keys(mcpServers).length) {
-      // MCP servers live in ~/.claude.json per Claude Code docs (not ~/.claude/settings.json).
-      // Use a shell command rather than files.write — Vercel's writeFiles API defaults paths to
-      // /vercel/sandbox, so absolute paths in the home directory may not resolve correctly.
-      const b64 = Buffer.from(JSON.stringify({ mcpServers })).toString("base64");
-      await this.sandbox.commands.run(`echo "${b64}" | base64 -d > "${home}/.claude.json"`, { timeoutMs: 5_000 });
-      process.stderr.write(`${this.label}[mcp] wrote ${Object.keys(mcpServers).join(",")} to ~/.claude.json\n`);
-    }
-    // Configure git in one shot: disable credential prompts, clear credential helper,
-    // and set a placeholder Authorization header for github.com HTTPS requests.
-    // The sandbox provider's network policy firewall replaces this header with the
-    // real token before forwarding — the token is never readable inside the VM.
-    // (api.github.com is the REST API, not git; git only uses github.com URLs.)
-    const placeholderB64 = Buffer.from("x-access-token:placeholder").toString("base64");
-    await this.sandbox.commands.run(
-      [
-        `git config --global core.askPass ""`,
-        `git config --global credential.interactive false`,
-        `git config --global credential.helper ""`,
-        `git config --global "http.https://github.com/.extraHeader" "Authorization: Basic ${placeholderB64}"`,
-      ].join(" && "),
-      { timeoutMs: 5_000 },
-    ).catch((e: unknown) => console.warn(`${this.label}[init] git config failed (non-fatal): ${formatError(e)}`));
-
-    try {
-      await this.sandbox.commands.run("rtk init --global --hook-only --auto-patch", { timeoutMs: 10_000 });
-    } catch {
-      console.warn("[Transport] rtk init failed (non-fatal) — token compression disabled");
-    }
-    this.claudeMdWritten = true;
-  }
-
-  /** Stream one CLI invocation, yielding AgentMessages. Resolves when the process exits. */
-  private async *_runCli(cmd: string, label: string, signal?: AbortSignal): AsyncGenerator<AgentMessage> {
-    type QueueItem = AgentMessage | { sentinel: "error"; text: string } | null;
-    const queue: QueueItem[] = [];
-    let notify: (() => void) | null = null;
-
-    function enqueue(items: AgentMessage[]): void { queue.push(...items); notify?.(); notify = null; }
-
-    let lineBuffer = "";
-    let stderrBuffer = "";
-
-    const maxTurns = this.options.maxTurns ?? 40;
-
-    function handleStdout(data: string): void {
-      lineBuffer += data;
-      const lines = lineBuffer.split("\n");
-      lineBuffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const event = JSON.parse(trimmed) as Record<string, unknown>;
-          if (event.type === "assistant") {
-            const content = (event.message as { content?: unknown[] })?.content ?? [];
-            for (const block of content) {
-              const b = block as Record<string, unknown>;
-              if (b.type === "text")     process.stdout.write(".");
-              if (b.type === "tool_use") process.stderr.write(`\n${label} ${b.name}(${JSON.stringify(b.input).slice(0, 80)})`);
-            }
-          } else if (event.type === "result") {
-            process.stderr.write(`\n${label}[result:${event.num_turns}/${maxTurns}/${event.subtype}]\n`);
-          } else if (event.type === "system") {
-            const ev = event as Record<string,unknown>;
-            const mcpSrvs = (ev.mcp_servers as {name:string;status:string}[] | undefined) ?? [];
-            const mcpStr = mcpSrvs.length ? ` mcp=[${mcpSrvs.map(s=>`${s.name}:${s.status}`).join(",")}]` : " mcp=[]";
-            process.stderr.write(`\n${label}[init:${ev.session_id}]${mcpStr}\n`);
-          }
-          enqueue(translateEvent(event));
-        } catch { /* non-JSON line */ }
-      }
-    }
-
-    process.stderr.write(`${label}[cwd:${this.options.cwd ?? "(none)"}]\n`);
-    const runPromise = this.sandbox.commands.run(cmd, {
-      cwd: this.options.cwd,
-      timeoutMs: NO_TIMEOUT,
-      onStdout: handleStdout,
-      onStderr: (data: string) => { stderrBuffer += data; process.stderr.write(`${label}[stderr] ${data.trimEnd()}\n`); },
+  async *sendMessage(opts: { prompt: string; sessionId?: string; iteration?: number; signal?: AbortSignal }): AsyncGenerator<AgentMessage> {
+    const requestContext = this.options.requestContext ?? RequestContext.fromReserved({
+      teamId: "", runId: "", workflowId: "",
+      factoryId: null, apiKeyScopes: [], parentRunId: null,
     });
 
-    runPromise
-      .catch((err: unknown) => {
-        const e = err as Record<string, unknown>;
-        if (e && typeof e === "object" && "exitCode" in e) process.stderr.write(`${label}[transport] command failed — exitCode=${e.exitCode} error=${JSON.stringify(e.error)} stdout_tail=${String(e.stdout ?? "").slice(-200)} stderr_tail=${String(e.stderr ?? "").slice(-200)}\n`);
-        queue.push({ sentinel: "error", text: stderrBuffer.trim() ? `Agent process failed: ${formatError(err)}\n\n${stderrBuffer.trim()}` : `Agent process failed: ${formatError(err)}` });
-      })
-      .finally(() => {
-        if (lineBuffer.trim()) { try { enqueue(translateEvent(JSON.parse(lineBuffer.trim()) as Record<string, unknown>)); } catch { /* ignore */ } }
-        queue.push(null);
-        notify?.(); notify = null;
+    const preToolHook: HookCallback = async (input, toolUseId, { signal }) => {
+      const pre = input as PreToolUseHookInput;
+      const call: ToolCall = {
+        toolName: pre.tool_name,
+        toolInput: (pre.tool_input ?? {}) as Record<string, unknown>,
+        toolUseId: toolUseId ?? `${pre.tool_name}-${Date.now()}`,
+      };
+      const gate = await this.gateToolCall(call, {
+        requestContext,
+        abortSignal: signal ?? opts.signal ?? new AbortController().signal,
+        retryCount: 0,
+        agentId: this.options.agentId ?? "agent",
+        iteration: opts.iteration ?? 1,
       });
+      if (gate.kind === "allow") return { hookSpecificOutput: { hookEventName: pre.hook_event_name, permissionDecision: "allow", updatedInput: gate.call.toolInput } };
+      if (gate.kind === "deny") return { hookSpecificOutput: { hookEventName: pre.hook_event_name, permissionDecision: "deny", permissionDecisionReason: gate.reason } };
+      return { continue: false, systemMessage: gate.reason };
+    };
 
-    while (true) {
-      while (queue.length > 0) {
-        const item = queue.shift()!;
-        if (item === null) return;
-        if ("sentinel" in item) { yield { type: "error", text: item.text, timestamp: new Date().toISOString() }; return; }
-        if (signal?.aborted) return;
-        const msg = item as AgentMessage;
-        yield (msg.type === "error" && stderrBuffer.trim() && !msg.text.includes(stderrBuffer.trim()))
-          ? { ...msg, text: `${msg.text}\n\n${stderrBuffer.trim()}` }
-          : msg;
-      }
-      await new Promise<void>(r => { notify = r; });
-    }
-  }
-
-  async *sendMessage(opts: { prompt: string; sessionId?: string; signal?: AbortSignal }): AsyncGenerator<AgentMessage> {
-    await this.deployGlobalConfig();
-
-    if (opts.sessionId) {
-      await this.sandbox.commands.run(`pkill -x claude 2>/dev/null || true`, { timeoutMs: 10_000 });
-    }
-
-    const maxTurns = this.options.maxTurns ?? 40;
-    const model    = this.configModel ?? this.options.model ?? DEFAULT_CLAUDE_MODEL;
-    const label    = this.label;
-
-    const promptFile = `/tmp/agent-prompt-${Date.now()}.txt`;
-    await this.sandbox.files.write(promptFile, opts.prompt);
-
-    // Don't restrict tools when MCP servers are configured — --allowedTools also
-    // blocks MCP tools, which would prevent the agent from using them.
-    const hasMcp = this.configMcpServers && Object.keys(this.configMcpServers).length > 0;
-    const allowedToolsFlag = (!hasMcp && this.options.allowedTools?.length)
-      ? ["--allowedTools", this.options.allowedTools.join(",")]
-      : [];
-
-    const buildCmd = (sessionId?: string) => [
-      "claude", "--dangerously-skip-permissions", "--verbose",
-      "--output-format", "stream-json",
-      "--max-turns", String(maxTurns),
-      "--model", model,
-      ...allowedToolsFlag,
-      ...(sessionId ? ["--resume", sessionId] : []),
-      "-p", `"$(cat ${promptFile})"`,
-    ].join(" ");
-
-    const MAX_529_RETRIES  = 5;
-    const BACKOFF_MS       = [60_000, 120_000, 240_000, 480_000, 600_000];
-    let   resumeSessionId  = opts.sessionId;
-
-    for (let attempt = 0; attempt <= MAX_529_RETRIES; attempt++) {
-      let got529      = false;
-      let newSession  = "";
-
-      for await (const msg of this._runCli(buildCmd(resumeSessionId), label, opts.signal)) {
-        if (msg.type === "init") newSession = msg.sessionId;
-        // Intercept 529 — retry instead of propagating
-        if (msg.type === "error" && msg.text.includes("529")) { got529 = true; break; }
-        yield msg;
-        if (msg.type === "done" || msg.type === "error") return;
-      }
-
-      if (!got529) return;
-      if (attempt === MAX_529_RETRIES) {
-        yield { type: "error", text: "Agent process failed: Repeated 529 Overloaded errors — all retries exhausted", timestamp: new Date().toISOString() };
-        return;
+    try {
+      let emittedAssistantText = false;
+      for await (const message of query({
+        prompt: opts.prompt,
+        options: {
+          tools: this.options.allowedTools,
+          allowedTools: this.options.allowedTools,
+          maxTurns: this.options.maxTurns,
+          model: this.config.model ?? this.options.model ?? DEFAULT_CLAUDE_MODEL,
+          outputFormat: this.options.outputFormat,
+          thinking: this.config.thinking,
+          effort: this.config.effort,
+          cwd: this.options.cwd,
+          env: { ...process.env, ...(this.config.env ?? {}) },
+          pathToClaudeCodeExecutable: this.config.pathToClaudeCodeExecutable ?? process.env.CLAUDE_CODE_EXECUTABLE ?? "claude",
+          ...(this.config.claudeMdContent ? { systemPrompt: { type: "preset" as const, preset: "claude_code" as const, append: this.config.claudeMdContent } } : {}),
+          resume: opts.sessionId,
+          mcpServers: this.config.mcpServers,
+          permissionMode: "acceptEdits",
+          hooks: { PreToolUse: [{ hooks: [preToolHook] }] },
+        },
+      })) {
+        const raw = message as unknown as Record<string, unknown>;
+        const translated = translateMessage(raw);
+        for (const msg of translated) {
+          // Claude Agent SDK can surface the same final assistant content both
+          // as an assistant text block and again as result.result. Preserve
+          // result.result for structured-output-only responses, but don't
+          // double-persist identical visible text when assistant text already
+          // arrived in the stream.
+          if (raw.type === "result" && msg.type === "text" && emittedAssistantText) continue;
+          if (msg.type === "text" && raw.type === "assistant") emittedAssistantText = true;
+          yield msg;
+        }
       }
-
-      if (newSession) resumeSessionId = newSession;
-      const wait = BACKOFF_MS[attempt];
-      process.stderr.write(`\n${label}[529] Overloaded — resuming in ${wait / 1000}s (attempt ${attempt + 1}/${MAX_529_RETRIES})${resumeSessionId ? " with session resume" : ""}\n`);
-      await new Promise(r => setTimeout(r, wait));
+    } catch (err) {
+      yield { type: "error", text: formatError(err), timestamp: now() };
     }
   }
 }
 
-export interface ClaudeRuntimeConfig {
-  /** Global instructions written to ~/.claude/CLAUDE.md in every sandbox. */
-  claudeMdContent?: string;
-  /**
-   * Environment variables set before each CLI invocation.
-   * Use to configure API provider routing (e.g. OpenRouter):
-   *   env: { ANTHROPIC_BASE_URL: "https://openrouter.ai/api", ANTHROPIC_AUTH_TOKEN: "$OPENROUTER_API_KEY", ANTHROPIC_API_KEY: "" }
-   */
-  env?: Record<string, string>;
-  /** Model to use (e.g. "claude-opus-4-6", "anthropic/claude-sonnet-4-6"). */
-  model?: string;
-  /** MCP servers to configure in the sandbox. Written to ~/.claude.json before the first iteration. */
-  mcpServers?: Record<string, { command: string; args?: string[]; env?: Record<string, string> }>;
-}
-
-/**
- * Create a Claude CLI runtime.
- *
- * Encapsulates everything about how the Claude CLI runs in a sandbox:
- * API provider routing, MCP server configuration, and global instructions.
- */
 export function createClaudeRuntime(config: ClaudeRuntimeConfig = {}) {
   return defineRuntime({
-    create: (sandbox, opts) => new ClaudeRunner(sandbox, opts, config.claudeMdContent ?? "", config.env ?? {}, config.model, config.mcpServers),
+    create: (sandbox, opts) => new ClaudeRunner(sandbox, opts, config),
   });
 }
 

package/src/runtimes/vercel.ts

@@ -0,0 +1,180 @@
+/**
+ * Vercel AI SDK runtime — model-agnostic agent execution with agent-compose
+ * owned coding tools over SandboxProvider.
+ */
+
+import { streamText, stepCountIs, tool, type LanguageModel } from "ai";
+import type { AgentMessage, ModelExecutionContract, RuntimeOptions, SandboxProvider, ToolCallGateResult } from "../index.js";
+import { defineRuntime } from "../types/runtime.js";
+import { codingTools, type CodingTool } from "../tools/index.js";
+import { runProcessorChain } from "../processors/runner.js";
+import type { ProcessorContext, ToolCall } from "../processors/processor.js";
+import { RequestContext } from "../request-context/request-context.js";
+import { formatError } from "../utils/errors.js";
+
+type AiToolSet = Record<string, ReturnType<typeof tool<Record<string, unknown>, string>>>;
+
+export interface VercelRuntimeConfig {
+  /** Vercel AI SDK language model (e.g. openai("gpt-5"), anthropic("claude-sonnet-4-5")). */
+  model: LanguageModel;
+  /** Optional system prompt prepended to every model call. */
+  system?: string;
+  /** Override/extend the default coding tools. Defaults: Read, Write, Edit, Bash. */
+  tools?: readonly CodingTool[];
+}
+
+function now(): string { return new Date().toISOString(); }
+
+function serialiseOutput(value: unknown): string {
+  return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+
+function toAgentMessages(part: Record<string, unknown>): AgentMessage[] {
+  const ts = now();
+  switch (part.type) {
+    case "text-delta":
+    case "text":
+      return [{ type: "text", text: String(part.text ?? ""), timestamp: ts }];
+    case "reasoning-delta":
+    case "reasoning":
+      return [{ type: "thinking", text: String(part.text ?? ""), timestamp: ts }];
+    case "tool-call":
+      return [{
+        type: "tool_use",
+        toolName: String(part.toolName ?? ""),
+        toolInput: (part.input ?? {}) as Record<string, unknown>,
+        toolUseId: String(part.toolCallId ?? ""),
+        timestamp: ts,
+      }];
+    case "tool-result":
+      return [{
+        type: "tool_result",
+        toolUseId: String(part.toolCallId ?? ""),
+        output: serialiseOutput(part.output),
+        isError: false,
+        timestamp: ts,
+      }];
+    case "tool-error":
+      return [{
+        type: "tool_result",
+        toolUseId: String(part.toolCallId ?? ""),
+        output: formatError(part.error),
+        isError: true,
+        timestamp: ts,
+      }];
+    case "error":
+      return [{ type: "error", text: formatError(part.error), timestamp: ts }];
+    default:
+      return [];
+  }
+}
+
+export class VercelRunner implements ModelExecutionContract {
+  supportsToolCallProcessor = true;
+  private readonly tools: readonly CodingTool[];
+  private readonly messages: unknown[] = [];
+
+  constructor(
+    private readonly sandbox: SandboxProvider,
+    private readonly options: RuntimeOptions,
+    private readonly config: VercelRuntimeConfig,
+  ) {
+    this.tools = config.tools ?? codingTools;
+  }
+
+  async gateToolCall(call: ToolCall, ctx: ProcessorContext): Promise<ToolCallGateResult> {
+    const verdict = await runProcessorChain(this.options.processors ?? [], p => p.processToolCall, call, ctx);
+    if (verdict.kind === "continue") return { kind: "allow", call: verdict.value };
+    return verdict;
+  }
+
+  private buildTools(iteration: number, signal?: AbortSignal): AiToolSet {
+    const set: AiToolSet = {};
+    for (const t of this.tools) {
+      if (this.options.allowedTools && !this.options.allowedTools.includes(t.name)) continue;
+      set[t.name] = tool({
+        description: t.description,
+        inputSchema: t.inputSchema,
+        execute: async (input: Record<string, unknown>, execOpts: { toolCallId?: string; abortSignal?: AbortSignal }) => {
+          const call: ToolCall = {
+            toolName: t.name,
+            toolInput: input,
+            toolUseId: execOpts.toolCallId ?? `${t.name}-${Date.now()}`,
+          };
+          const requestContext = this.options.requestContext ?? RequestContext.fromReserved({
+            teamId: "", runId: "", workflowId: "",
+            factoryId: null, apiKeyScopes: [], parentRunId: null,
+          });
+          const gate = await this.gateToolCall(call, {
+            requestContext,
+            abortSignal: execOpts.abortSignal ?? signal ?? new AbortController().signal,
+            retryCount: 0,
+            agentId: this.options.agentId ?? "agent",
+            iteration,
+          });
+          if (gate.kind === "deny") return gate.reason;
+          if (gate.kind === "abort") throw new Error(gate.reason);
+          return t.execute(gate.call.toolInput, {
+            sandbox: this.sandbox,
+            cwd: this.options.cwd,
+            abortSignal: execOpts.abortSignal ?? signal,
+          });
+        },
+      });
+    }
+    return set;
+  }
+
+  async *sendMessage(opts: { prompt: string; sessionId?: string; iteration?: number; signal?: AbortSignal }): AsyncGenerator<AgentMessage> {
+    const sessionId = opts.sessionId ?? `vercel-${Date.now()}`;
+    yield { type: "init", sessionId, timestamp: now() };
+
+    const inputMessages = [...this.messages, { role: "user", content: opts.prompt }];
+    const result = streamText({
+      model: this.config.model,
+      ...(this.config.system ? { system: this.config.system } : {}),
+      messages: inputMessages as never,
+      tools: this.buildTools(opts.iteration ?? 1, opts.signal),
+      stopWhen: stepCountIs(this.options.maxTurns ?? 40),
+      abortSignal: opts.signal,
+    });
+
+    try {
+      for await (const part of result.fullStream as AsyncIterable<Record<string, unknown>>) {
+        for (const msg of toAgentMessages(part)) yield msg;
+      }
+
+      const response = await result.response;
+      const responseMessages = (response as unknown as { messages?: unknown[] }).messages;
+      if (responseMessages) {
+        this.messages.length = 0;
+        this.messages.push(...responseMessages);
+      }
+      let usage: Awaited<typeof result.usage> | undefined;
+      try { usage = await result.usage; } catch { usage = undefined; }
+      if (usage) {
+        yield {
+          type: "usage",
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+          cacheCreationTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+          durationMs: 0,
+          numTurns: opts.iteration ?? 1,
+          timestamp: now(),
+        };
+      }
+    } catch (err) {
+      yield { type: "error", text: formatError(err), timestamp: now() };
+      return;
+    }
+
+    yield { type: "done", sessionId, timestamp: now() };
+  }
+}
+
+export function createVercelRuntime(config: VercelRuntimeConfig) {
+  return defineRuntime({
+    create: (sandbox, opts) => new VercelRunner(sandbox, opts, config),
+  });
+}