@agent-compose/sdk 0.2.3 → 0.2.4

package/dist/runtimes/vercel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Vercel AI SDK runtime — model-agnostic agent execution with agent-compose
+ * owned coding tools over SandboxProvider.
+ */
+import { type LanguageModel } from "ai";
+import type { AgentMessage, ModelExecutionContract, RuntimeOptions, SandboxProvider, ToolCallGateResult } from "../index.js";
+import { type CodingTool } from "../tools/index.js";
+import type { ProcessorContext, ToolCall } from "../processors/processor.js";
+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[];
+}
+export declare class VercelRunner implements ModelExecutionContract {
+    private readonly sandbox;
+    private readonly options;
+    private readonly config;
+    supportsToolCallProcessor: boolean;
+    private readonly tools;
+    private readonly messages;
+    constructor(sandbox: SandboxProvider, options: RuntimeOptions, config: VercelRuntimeConfig);
+    gateToolCall(call: ToolCall, ctx: ProcessorContext): Promise<ToolCallGateResult>;
+    private buildTools;
+    sendMessage(opts: {
+        prompt: string;
+        sessionId?: string;
+        iteration?: number;
+        signal?: AbortSignal;
+    }): AsyncGenerator<AgentMessage>;
+}
+export declare function createVercelRuntime(config: VercelRuntimeConfig): import("../index.js").AgentRuntime<SandboxProvider>;

package/dist/runtimes/vercel.js

@@ -0,0 +1,474 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/runtimes/vercel.ts
+import { streamText, stepCountIs, tool } from "ai";
+
+// src/types/runtime.ts
+function defineRuntime(pkg) {
+  if (typeof pkg.create !== "function")
+    throw new Error("defineRuntime: 'create' is required");
+  return pkg;
+}
+
+// src/tools/coding.ts
+import { z } from "zod";
+import { isAbsolute, join } from "node:path/posix";
+function q(value) {
+  return JSON.stringify(value);
+}
+function resolvePath(path, cwd) {
+  return cwd && !isAbsolute(path) ? join(cwd, path) : path;
+}
+async function readFile(sandbox, path, opts) {
+  const script = `
+const fs = require("fs");
+const path = process.argv[1];
+const offset = process.argv[2] ? Number(process.argv[2]) : 1;
+const limit = process.argv[3] ? Number(process.argv[3]) : 2000;
+const data = fs.readFileSync(path, "utf8");
+const lines = data.split(/\\r?\\n/);
+const start = Math.max(1, offset);
+const end = Math.min(lines.length, start + Math.max(0, limit) - 1);
+for (let i = start; i <= end; i++) console.log(String(i) + ": " + lines[i - 1]);
+`;
+  const args = [q(path), opts?.offset !== undefined ? String(opts.offset) : "", opts?.limit !== undefined ? String(opts.limit) : ""].filter(Boolean).map(q).join(" ");
+  const { stdout } = await sandbox.commands.run(`node -e ${q(script)} ${args}`, { cwd: opts?.cwd, timeoutMs: 30000 });
+  return stdout;
+}
+async function readRawFile(sandbox, path, cwd) {
+  const script = `const fs = require("fs"); process.stdout.write(fs.readFileSync(process.argv[1], "utf8"));`;
+  const { stdout } = await sandbox.commands.run(`node -e ${q(script)} ${q(path)}`, { cwd, timeoutMs: 30000 });
+  return stdout;
+}
+var readTool = {
+  name: "Read",
+  description: "Read a UTF-8 text file from the sandbox. Returns numbered lines. Use offset/limit for large files.",
+  inputSchema: z.object({
+    path: z.string().describe("File path to read. Relative paths resolve from the agent working directory."),
+    offset: z.number().int().positive().optional().describe("1-based line number to start at."),
+    limit: z.number().int().positive().max(5000).optional().describe("Maximum number of lines to return.")
+  }),
+  execute: ({ path, offset, limit }, ctx) => readFile(ctx.sandbox, path, { offset, limit, cwd: ctx.cwd })
+};
+var writeTool = {
+  name: "Write",
+  description: "Write UTF-8 content to a file in the sandbox, creating or replacing the file.",
+  inputSchema: z.object({
+    path: z.string().describe("File path to write. Relative paths resolve from the agent working directory."),
+    content: z.string().describe("Complete file contents to write.")
+  }),
+  execute: async ({ path, content }, ctx) => {
+    const target = resolvePath(path, ctx.cwd);
+    await ctx.sandbox.files.write(target, content);
+    return `Wrote ${content.length} bytes to ${target}`;
+  }
+};
+var editTool = {
+  name: "Edit",
+  description: "Edit a text file by replacing an exact string. Fails if the old string is not found or is ambiguous without replaceAll.",
+  inputSchema: z.object({
+    path: z.string().describe("File path to edit. Relative paths resolve from the agent working directory."),
+    oldString: z.string().min(1).describe("Exact text to replace."),
+    newString: z.string().describe("Replacement text."),
+    replaceAll: z.boolean().optional().describe("Replace every occurrence instead of requiring exactly one match.")
+  }),
+  execute: async ({ path, oldString, newString, replaceAll }, ctx) => {
+    const target = resolvePath(path, ctx.cwd);
+    const before = await readRawFile(ctx.sandbox, target, ctx.cwd);
+    const count = before.split(oldString).length - 1;
+    if (count === 0)
+      throw new Error(`Edit failed: oldString not found in ${target}`);
+    if (!replaceAll && count !== 1)
+      throw new Error(`Edit failed: oldString occurs ${count} times in ${target}; set replaceAll=true or make oldString more specific`);
+    const after = replaceAll ? before.split(oldString).join(newString) : before.replace(oldString, newString);
+    await ctx.sandbox.files.write(target, after);
+    return `Edited ${target}: replaced ${replaceAll ? count : 1} occurrence${(replaceAll ? count : 1) === 1 ? "" : "s"}`;
+  }
+};
+var bashTool = {
+  name: "Bash",
+  description: "Run a shell command in the sandbox. Use for file discovery/search (e.g. globbing/grep via shell commands), tests, builds, and package commands.",
+  inputSchema: z.object({
+    command: z.string().min(1).describe("Shell command to execute."),
+    timeoutMs: z.number().int().positive().max(3600000).optional().describe("Timeout in milliseconds."),
+    cwd: z.string().optional().describe("Optional command working directory. Defaults to the agent working directory.")
+  }),
+  execute: async ({ command, timeoutMs, cwd }, ctx) => {
+    const result = await ctx.sandbox.commands.run(command, {
+      cwd: cwd ?? ctx.cwd,
+      timeoutMs: timeoutMs ?? 120000
+    });
+    if (result.exitCode !== 0)
+      throw new Error(`Command failed with exit code ${result.exitCode}${result.stdout ? `
+${result.stdout}` : ""}`);
+    return result.stdout;
+  }
+};
+var codingTools = [readTool, writeTool, editTool, bashTool];
+// src/processors/runner.ts
+async function runProcessorChain(processors, selectHook, initial, ctx) {
+  let current = initial;
+  for (const p of processors) {
+    const fn = selectHook(p);
+    if (!fn)
+      continue;
+    const verdict = await fn.call(p, current, ctx);
+    if (verdict.kind !== "continue")
+      return verdict;
+    current = verdict.value;
+  }
+  return { kind: "continue", value: current };
+}
+
+// src/request-context/request-context.ts
+var AC_RESERVED_PREFIX = "ac__";
+var AC_TEAM_ID = "ac__teamId";
+var AC_RUN_ID = "ac__runId";
+var AC_WORKFLOW_ID = "ac__workflowId";
+var AC_FACTORY_ID = "ac__factoryId";
+var AC_API_KEY_SCOPES = "ac__apiKeyScopes";
+var AC_PARENT_RUN_ID = "ac__parentRunId";
+var AC_ABORT_SIGNAL = "ac__abortSignal";
+var RESERVED_KEYS = new Set([
+  AC_TEAM_ID,
+  AC_RUN_ID,
+  AC_WORKFLOW_ID,
+  AC_FACTORY_ID,
+  AC_API_KEY_SCOPES,
+  AC_PARENT_RUN_ID,
+  AC_ABORT_SIGNAL
+]);
+var SERIALISABLE_RESERVED_KEYS = new Set([
+  AC_TEAM_ID,
+  AC_RUN_ID,
+  AC_WORKFLOW_ID,
+  AC_FACTORY_ID,
+  AC_API_KEY_SCOPES,
+  AC_PARENT_RUN_ID
+]);
+
+class ReservedKeyError extends Error {
+  key;
+  constructor(key) {
+    super(`request-context: "${key}" is reserved and cannot be mutated downstream`);
+    this.name = "ReservedKeyError";
+    this.key = key;
+  }
+}
+
+class NonSerialisableValueError extends Error {
+  constructor(key, cause) {
+    super(`request-context: value for "${key}" is not JSON-serialisable`, { cause });
+    this.name = "NonSerialisableValueError";
+  }
+}
+function assertJsonSerialisable(key, value, seen = new WeakSet) {
+  if (value === null)
+    return;
+  const type = typeof value;
+  if (type === "string" || type === "boolean")
+    return;
+  if (type === "number") {
+    if (Number.isFinite(value))
+      return;
+    throw new NonSerialisableValueError(key, new TypeError("non-finite numbers are not JSON-serialisable"));
+  }
+  if (type !== "object") {
+    throw new NonSerialisableValueError(key, new TypeError(`${type} is not JSON-serialisable`));
+  }
+  const objectValue = value;
+  if (seen.has(objectValue)) {
+    throw new NonSerialisableValueError(key, new TypeError("cyclic values are not JSON-serialisable"));
+  }
+  seen.add(objectValue);
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertJsonSerialisable(key, item, seen);
+    return;
+  }
+  if (Object.getPrototypeOf(objectValue) !== Object.prototype) {
+    throw new NonSerialisableValueError(key, new TypeError("only plain objects are JSON-serialisable"));
+  }
+  for (const item of Object.values(objectValue))
+    assertJsonSerialisable(key, item, seen);
+}
+
+class RequestContext {
+  reserved;
+  user;
+  constructor(reserved, user) {
+    this.reserved = Object.freeze({
+      ...reserved,
+      apiKeyScopes: Object.freeze([...reserved.apiKeyScopes])
+    });
+    this.user = user;
+  }
+  static fromReserved(reserved) {
+    return new RequestContext(reserved, new Map);
+  }
+  static deserialise(wire) {
+    const ctx = new RequestContext({ ...wire.reserved, abortSignal: undefined }, new Map(Object.entries(wire.user)));
+    return ctx;
+  }
+  withAbortSignal(signal) {
+    return new RequestContext({ ...this.reserved, abortSignal: signal }, new Map(this.user));
+  }
+  get teamId() {
+    return this.reserved.teamId;
+  }
+  get runId() {
+    return this.reserved.runId;
+  }
+  get workflowId() {
+    return this.reserved.workflowId;
+  }
+  get factoryId() {
+    return this.reserved.factoryId;
+  }
+  get apiKeyScopes() {
+    return this.reserved.apiKeyScopes;
+  }
+  get parentRunId() {
+    return this.reserved.parentRunId;
+  }
+  get abortSignal() {
+    return this.reserved.abortSignal;
+  }
+  hasScope(scope) {
+    return this.reserved.apiKeyScopes.includes(scope);
+  }
+  set(key, value) {
+    if (RESERVED_KEYS.has(key) || key.startsWith(AC_RESERVED_PREFIX)) {
+      throw new ReservedKeyError(key);
+    }
+    assertJsonSerialisable(key, value);
+    this.user.set(key, value);
+  }
+  get(key) {
+    return this.user.get(key);
+  }
+  has(key) {
+    return this.user.has(key);
+  }
+  delete(key) {
+    if (RESERVED_KEYS.has(key) || key.startsWith(AC_RESERVED_PREFIX)) {
+      throw new ReservedKeyError(key);
+    }
+    return this.user.delete(key);
+  }
+  entries() {
+    return this.user.entries();
+  }
+  serialise() {
+    return {
+      reserved: {
+        teamId: this.reserved.teamId,
+        runId: this.reserved.runId,
+        workflowId: this.reserved.workflowId,
+        factoryId: this.reserved.factoryId,
+        apiKeyScopes: [...this.reserved.apiKeyScopes],
+        parentRunId: this.reserved.parentRunId
+      },
+      user: Object.fromEntries(this.user)
+    };
+  }
+  forChild(opts) {
+    return RequestContext.fromReserved({
+      teamId: this.reserved.teamId,
+      runId: opts.runId,
+      workflowId: opts.workflowId,
+      factoryId: this.reserved.factoryId,
+      apiKeyScopes: this.reserved.apiKeyScopes,
+      parentRunId: this.reserved.runId
+    });
+  }
+}
+
+// src/utils/errors.ts
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/runtimes/vercel.ts
+function now() {
+  return new Date().toISOString();
+}
+function serialiseOutput(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+function toAgentMessages(part) {
+  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 ?? {},
+        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 [];
+  }
+}
+
+class VercelRunner {
+  sandbox;
+  options;
+  config;
+  supportsToolCallProcessor = true;
+  tools;
+  messages = [];
+  constructor(sandbox, options, config) {
+    this.sandbox = sandbox;
+    this.options = options;
+    this.config = config;
+    this.tools = config.tools ?? codingTools;
+  }
+  async gateToolCall(call, ctx) {
+    const verdict = await runProcessorChain(this.options.processors ?? [], (p) => p.processToolCall, call, ctx);
+    if (verdict.kind === "continue")
+      return { kind: "allow", call: verdict.value };
+    return verdict;
+  }
+  buildTools(iteration, signal) {
+    const set = {};
+    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, execOpts) => {
+          const call = {
+            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) {
+    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,
+      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) {
+        for (const msg of toAgentMessages(part))
+          yield msg;
+      }
+      const response = await result.response;
+      const responseMessages = response.messages;
+      if (responseMessages) {
+        this.messages.length = 0;
+        this.messages.push(...responseMessages);
+      }
+      let usage;
+      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() };
+  }
+}
+function createVercelRuntime(config) {
+  return defineRuntime({
+    create: (sandbox, opts) => new VercelRunner(sandbox, opts, config)
+  });
+}
+export {
+  createVercelRuntime,
+  VercelRunner
+};

package/dist/sandbox.d.ts

@@ -6,8 +6,9 @@
  */
 import { Sandbox } from "e2b";
 import { Sandbox as Desktop } from "@e2b/desktop";
-import type { SandboxProvider, DesktopSandboxProvider } from "./types/sandbox.js";
-export type { SandboxProvider, DesktopSandboxProvider } from "./types/sandbox.js";
+import type { SandboxProvider, DesktopSandboxProvider, SandboxCommandResult } from "./types/sandbox.js";
+export type { SandboxProvider, DesktopSandboxProvider, SandboxCommandRunOptions, SandboxCommandResult } from "./types/sandbox.js";
+export type SandboxProviderName = "vercel" | "e2b" | "e2b-desktop";
 export declare const AGENT_COMPOSE_TAG: string;
 /**
  * Vercel-compatible network policy for outbound HTTPS requests.
@@ -15,16 +16,19 @@ export declare const AGENT_COMPOSE_TAG: string;
  * firewall injects the specified headers before forwarding — credentials never
  * exist inside the VM. E2B ignores this field (future self-hosted mapping TBD).
  */
+export interface SandboxNetworkHeaderTransform {
+    headers?: Record<string, string>;
+}
+export interface SandboxNetworkAllowRule {
+    transform?: SandboxNetworkHeaderTransform[];
+}
+export interface SandboxNetworkSubnetPolicy {
+    allow?: string[];
+    deny?: string[];
+}
 export type SandboxNetworkPolicy = "allow-all" | "deny-all" | {
-    allow?: string[] | Record<string, Array<{
-        transform?: Array<{
-            headers?: Record<string, string>;
-        }>;
-    }>>;
-    subnets?: {
-        allow?: string[];
-        deny?: string[];
-    };
+    allow?: string[] | Record<string, SandboxNetworkAllowRule[]>;
+    subnets?: SandboxNetworkSubnetPolicy;
 };
 export interface SandboxCreateOpts {
     envs: Record<string, string>;
@@ -80,17 +84,15 @@ interface SandboxProviderDef {
 }
 export declare function makeSandboxProvider(sb: Sandbox | Desktop): SandboxProvider;
 export declare function makeDesktopSandboxProvider(sb: Desktop): DesktopSandboxProvider;
+export interface ParseSseExecStreamOptions {
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}
 /**
  * Parse an SSE exec stream from a ReadableStream.
  * Used by the agent sandbox broker in runner.ts.
  */
-export declare function parseSseExecStream(body: ReadableStream<Uint8Array>, opts?: {
-    onStdout?: (d: string) => void;
-    onStderr?: (d: string) => void;
-}): Promise<{
-    exitCode: number;
-    stdout: string;
-}>;
+export declare function parseSseExecStream(body: ReadableStream<Uint8Array>, opts?: ParseSseExecStreamOptions): Promise<SandboxCommandResult>;
 /** Minimal SandboxProvider that targets the current process's host VM.
  *  `commands.run` → `child_process.spawn`; `files.write` → `fs.writeFile`;
  *  `kill` is a no-op because the caller IS the VM. Used by
@@ -100,27 +102,29 @@ export declare function parseSseExecStream(body: ReadableStream<Uint8Array>, opt
 export declare function makeLocalSandboxProvider(): SandboxProvider;
 declare const SANDBOX_PROVIDERS: Record<string, SandboxProviderDef>;
 /** Provision a sandbox for the named provider. */
-export declare function createSandbox(provider: string, opts: SandboxCreateOpts): Promise<SandboxProvider>;
+export declare function createSandbox(provider: SandboxProviderName, opts: SandboxCreateOpts): Promise<SandboxProvider>;
 /** Reconnect to an existing sandbox by provider + provider-native sandbox ID. */
-export declare function reconnectSandbox(provider: string, sandboxId: string): Promise<SandboxProvider>;
+export declare function reconnectSandbox(provider: SandboxProviderName, sandboxId: string): Promise<SandboxProvider>;
 /** Delete a snapshot by id on the named provider. No live sandbox needed. */
-export declare function deleteSandboxSnapshot(provider: string, snapshotId: string): Promise<void>;
+export declare function deleteSandboxSnapshot(provider: SandboxProviderName, snapshotId: string): Promise<void>;
 /**
  * Current active-sandbox count per configured provider, for quota gauges.
  * Skips providers whose required env isn't set or which don't implement
  * `getActiveCount`. Errors are surfaced per-provider so one flaky provider
  * doesn't silence the rest.
  */
-export declare function getSandboxQuotas(): Promise<Record<string, number | Error>>;
+export type SandboxQuotaResult = Partial<Record<SandboxProviderName, number | Error>>;
+export declare function getSandboxQuotas(): Promise<SandboxQuotaResult>;
 /**
  * List every alive sandbox owned by this fleet, across all configured
  * providers — the orphan-reconciler SoT. Providers without `listOwned`
  * or missing env are skipped. Errors propagate per-provider so one flaky
  * provider doesn't silence the rest.
  */
-export declare function listOwnedSandboxes(): Promise<Record<string, OwnedSandbox[] | Error>>;
+export type OwnedSandboxResult = Partial<Record<SandboxProviderName, OwnedSandbox[] | Error>>;
+export declare function listOwnedSandboxes(): Promise<OwnedSandboxResult>;
 /** Kill a sandbox by provider + native ID. Used by the orphan reconciler. */
-export declare function killSandboxById(provider: string, sandboxId: string): Promise<void>;
+export declare function killSandboxById(provider: SandboxProviderName, sandboxId: string): Promise<void>;
 /** Kill all sandboxes across all registered providers. Call at startup to clean up after crashes. */
-export declare function killAllSandboxes(onError?: (provider: string, err: unknown) => void): Promise<void>;
+export declare function killAllSandboxes(onError?: (provider: SandboxProviderName, err: unknown) => void): Promise<void>;
 export { SANDBOX_PROVIDERS };

package/dist/step-invocation/__tests__/invoker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/step-invocation/__tests__/protocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/step-invocation/__tests__/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/step-invocation/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * StepInvocation — cross-process protocol that lets a server-side
+ * activity (Temporal `executeStep`, future Inngest equivalent) drive
+ * one workflow step inside an existing runner sandbox.
+ *
+ * Two halves, single source of truth for the wire:
+ *
+ *   - `invokeStep(sandbox, request)` — server side. Writes input +
+ *     request context, mints a token, builds envs, spawns the runner,
+ *     parses the tokenised stdout sentinel, returns a kinded `StepResult`.
+ *
+ *   - `serveStep(handler)` — runner side. Reads input + request context
+ *     from env-pointed files, runs the handler, emits the tokenised
+ *     sentinel result line, exits with the right code.
+ *
+ * The protocol is intentionally narrow: one input file + one context
+ * file + one tokenised stdout result line. Easy to reason about, easy
+ * to test in isolation.
+ */
+export { STEP_RESULT_PREFIX, STEP_ENV, RUNNER_BUNDLE_PATH, RUNNER_COMMAND, stepInputPath, requestContextPath, } from "./protocol.js";
+export { invokeStep, parseStepResult, buildStepEnvs } from "./invoker.js";
+export { serveStep } from "./server.js";
+export type { StepHandler, ServeStepRequest, StepHandlerResult } from "./server.js";
+export { StepExecutionError } from "./types.js";
+export type { StepRequest, StepResult, StepInvocationError } from "./types.js";