@agent-compose/sdk 0.5.7 → 0.5.9

package/dist/types/protocol.d.ts

@@ -27,6 +27,23 @@ export interface AgentMessageToolResult extends AgentMessageBase {
     toolUseId: string;
     output: string;
     isError: boolean;
+    /** Structured file diffs produced by the tool call, carried alongside the
+     *  rendered `output` so a richer renderer can use the structure without
+     *  re-plumbing the normaliser. Sourced from ACP `tool_call`/`tool_call_update`
+     *  `diff` content blocks (WS-C / ADR-0020 Q3). Optional and additive:
+     *  existing producers (claude / vercel / legacy JSONL) omit it. `oldText` is
+     *  null for a newly created file. */
+    diffs?: {
+        path: string;
+        oldText: string | null;
+        newText: string;
+    }[];
+    /** File locations touched by the tool call (ACP `locations` field), enabling
+     *  "follow-along" UI. Optional and additive (WS-C / ADR-0020 Q3). */
+    locations?: {
+        path: string;
+        line?: number;
+    }[];
 }
 export interface AgentMessageDone extends AgentMessageBase {
     type: "done";
@@ -45,7 +62,21 @@ export interface AgentMessageUsage extends AgentMessageBase {
     durationMs: number;
     numTurns: number;
 }
-export type AgentMessage = AgentMessageInit | AgentMessageText | AgentMessageThinking | AgentMessageToolUse | AgentMessageToolResult | AgentMessageDone | AgentMessageError | AgentMessageUsage;
+/** Structured execution plan emitted by an agent (ACP `plan` session update,
+ *  WS-C / ADR-0020 Q2). Each `plan` notification REPLACES the whole plan — the
+ *  normaliser emits one `AgentMessagePlan` per notification carrying the entire
+ *  `entries` array, and downstream treats the latest as authoritative. This is
+ *  NOT an `AgentStatus` and does not feed self-pause; it is observability only.
+ *  Additive 9th kind: existing producers never emit it. */
+export interface AgentMessagePlan extends AgentMessageBase {
+    type: "plan";
+    entries: {
+        content: string;
+        priority: "high" | "medium" | "low";
+        status: "pending" | "in_progress" | "completed";
+    }[];
+}
+export type AgentMessage = AgentMessageInit | AgentMessageText | AgentMessageThinking | AgentMessageToolUse | AgentMessageToolResult | AgentMessageDone | AgentMessageError | AgentMessageUsage | AgentMessagePlan;
 /** Status block the agent emits to signal iteration completion or blockers. */
 export interface AgentStatus {
     summary: string;

package/dist/types/runtime.d.ts

@@ -4,6 +4,7 @@
 import type { SandboxProvider } from "./sandbox.js";
 import type { AgentMessage } from "./protocol.js";
 import type { Processor, ProcessorContext, ToolCall } from "../processors/processor.js";
+import type { BoundaryPauseFn } from "../pause/pause-core.js";
 import type { RequestContext } from "../request-context/request-context.js";
 /** Configuration for a single MCP server. */
 export interface McpServerConfig {
@@ -28,6 +29,12 @@ export interface RuntimeOptions {
     /** Agent id and label for processor context / adapter logs. */
     agentId?: string;
     iteration?: number;
+    /** The run's pause boundary, threaded from the agent loop so a runtime-driven
+     *  pre-tool gate (e.g. the ACP `session/request_permission` path through
+     *  `gateToolCall`) can raise a human-approval `ctx.pause`. The runtime binds it
+     *  to the current `{ agentId, iteration }` when it builds a ProcessorContext.
+     *  Absent ⇒ a processor pause throws (no boundary; see `boundProcessorPause`). */
+    pause?: BoundaryPauseFn;
     /** Optional JSON schema for runtimes with native structured-output support. */
     outputFormat?: {
         type: "json_schema";

package/dist/types/sandbox-environment.d.ts

@@ -35,7 +35,7 @@
  */
 import type { SandboxProvider } from "./sandbox.js";
 import type { Workflow } from "../workflow-steps/types.js";
-import type { SnapshotConfig } from "./workflow-metadata.js";
+import type { SandboxResources, SnapshotConfig } from "./workflow-metadata.js";
 export interface SandboxEnvironmentDefinition {
     name: string;
     description?: string;
@@ -45,6 +45,11 @@ export interface SandboxEnvironmentDefinition {
      *  useful — an env with no snapshot can't be referenced as a
      *  `bootFrom` on another workflow). */
     snapshots?: SnapshotConfig;
+    /** Which substrate to build this environment on (and any sizing).
+     *  An env image is provider-specific — a snapshot captured on E2B
+     *  can't boot on Vercel and vice-versa — so building the E2B base/
+     *  agent-env requires `resources: { provider: "e2b" }`. */
+    resources?: SandboxResources;
 }
 /** Sugar over `defineWorkflow` for setup-only workflows that exist to
  *  capture a snapshot. The workflow takes no meaningful input and returns

package/dist/types/sandbox.d.ts

@@ -21,6 +21,36 @@ export interface SandboxCommandResult {
     stdout: string;
     stderr: string;
 }
+/** A spawned long-lived command with a writable stdin and readable stdout,
+ *  exposed as byte web-streams. Unlike `commands.run` (which buffers to
+ *  completion and exposes stdout only via an `onStdout` callback), a duplex
+ *  handle keeps the process alive and lets the caller WRITE to its stdin —
+ *  the half `commands.run` cannot provide. It is the transport the ACP client
+ *  (`AcpClientPeer` over `ndJsonStream`) needs: the agent CLI reads JSON-RPC
+ *  request frames on stdin and answers on stdout.
+ *
+ *  Only `makeLocalSandboxProvider` implements it. The runner runs IN the
+ *  sandbox VM and spawns CLIs via the local provider (a plain `child_process`
+ *  pipe), so a duplex stdin works identically on Vercel/E2B/local. The
+ *  vercel/e2b providers are the SERVER→sandbox view and never spawn the in-VM
+ *  CLI, so they leave `spawnDuplex` undefined and callers fall back cleanly. */
+export interface SandboxDuplexProcess {
+    /** Subprocess stdin. JSON-RPC request frames are written here. */
+    stdin: WritableStream<Uint8Array>;
+    /** Subprocess stdout. JSON-RPC response/notification frames arrive here. */
+    stdout: ReadableStream<Uint8Array>;
+    /** Resolves when the subprocess exits, carrying the captured stderr tail. */
+    exited: Promise<{
+        exitCode: number;
+        stderr: string;
+    }>;
+    /** Force-terminate the subprocess. */
+    kill(): void;
+}
+export interface SandboxSpawnDuplexOptions {
+    cwd?: string;
+    envs?: Record<string, string>;
+}
 /**
  * A sandbox provider implements the RAW provider operations only. It does NOT
  * implement transient-failure retry/backoff: reconnecting and snapshotting both
@@ -43,6 +73,11 @@ export interface SandboxProvider {
     cwd?: string;
     commands: {
         run(cmd: string, opts?: SandboxCommandRunOptions): Promise<SandboxCommandResult>;
+        /** Spawn a long-lived command with a real duplex stdin/stdout. OPTIONAL —
+         *  implemented only by `makeLocalSandboxProvider` (the in-VM `child_process`
+         *  view). The vercel/e2b providers (server→sandbox) leave it undefined; an
+         *  ACP caller that finds it absent falls back to the JSONL transport. */
+        spawnDuplex?(cmd: string, opts?: SandboxSpawnDuplexOptions): SandboxDuplexProcess;
     };
     files: {
         write(path: string, content: string): Promise<void>;
@@ -60,12 +95,12 @@ export interface SandboxProvider {
         snapshotId: string;
         sizeBytes?: number;
     }>;
-    /** Replace the live sandbox's egress policy in place. Vercel implements
-     *  it via `sandbox.update({ networkPolicy })` (2.x) so the server can
-     *  push a freshly resolved policy — with re-minted connector access
-     *  tokens — before each step instead of relying on the policy baked at
-     *  create. Providers whose enforcement lives inside the VM (E2B
-     *  iron-proxy) leave it undefined. */
+    /** Replace the live sandbox's egress policy in place — so the server can
+     *  push a freshly resolved policy (with re-minted connector access tokens)
+     *  before each step instead of relying on the policy baked at create.
+     *  Vercel implements it via `sandbox.update({ networkPolicy })` (2.x); E2B
+     *  via its native `sandbox.updateNetwork(...)`. Providers without a live
+     *  network-update primitive leave it undefined. */
     updateNetworkPolicy?(policy: SandboxNetworkPolicy): Promise<void>;
 }
 /** Stateless provider-level snapshot deletion — no live sandbox needed,

package/dist/types/workflow-metadata.d.ts

@@ -8,8 +8,13 @@
  * Keep this module free of value imports from `types/workflow.ts` or
  * `workflow-steps/workflow.ts` — it is the cycle-break point.
  */
-import type { SandboxNetworkPolicy } from "../sandbox.js";
+import type { SandboxNetworkPolicy, SandboxSize, SandboxProviderName } from "../sandbox.js";
 import type { Processor } from "../processors/processor.js";
+/** The sandbox providers selectable per-workflow. A narrowing of
+ *  `SandboxProviderName` to the two substrates that execute step workloads —
+ *  `e2b-desktop` (registry-only, never a workflow's runtime) is deliberately
+ *  excluded so a workflow can only ask for a substrate that actually runs steps. */
+export type WorkflowSandboxProvider = Extract<SandboxProviderName, "vercel" | "e2b">;
 /**
  * Workflow-level metadata read by the server at registration. Lives on
  * every `Workflow` as `workflow.metadata`, regardless of which form of
@@ -75,11 +80,14 @@ export interface IOSchema {
 /** Alias kept for backwards source-compatibility with the original
  *  output-only release. New code should prefer `IOSchema`. */
 export type OutputSchema = IOSchema;
-/** Per-connector HTTP request matcher (Tier-2 capability narrowing). The
- *  iron-proxy / firewall consults these when deciding whether to attach the
- *  brokered Authorization header to an outbound request. A request to the
- *  connector host whose method is not in `methods`, or whose path matches no
- *  entry in `pathPrefixes`, is refused (403) and the token is WITHHELD. */
+/** Per-connector HTTP request matcher (Tier-2 capability narrowing). Vercel's
+ *  firewall consults these when deciding whether to attach the brokered
+ *  Authorization header to an outbound request: a request to the connector
+ *  host whose method is not in `methods`, or whose path matches no entry in
+ *  `pathPrefixes`, goes out WITHOUT the token. NOT enforced on E2B — its
+ *  native rules carry only a header transform, no method/path matcher, so the
+ *  token rides every request to an allowed connector host there (the host
+ *  allowlist still confines which hosts are reachable). See `toE2bNetwork`. */
 export interface ConnectorRequestRules {
     /** Allowed HTTP methods (upper-case). Omit = any method (subject to
      *  `access`). */
@@ -134,6 +142,24 @@ export interface InvokePolicy {
     apiKeys?: string[];
     workflows?: string[];
 }
+/** Sandbox machine resources for a workflow's runs. A coarse size knob
+ *  today; kept as its own object so finer controls (disk, gpu, …) can be
+ *  added later without reshaping `WorkflowMetadata`. */
+export interface SandboxResources {
+    /** Machine hardware SKU — one of the `SandboxSize` vCPU strings
+     *  (`2vcpu-4gb` | `4vcpu-8gb` | `8vcpu-16gb` | `32vcpu-64gb`). Maps to
+     *  provider specs at create time (Vercel: 2 / 4 / 8 / 32 vCPU, 2048 MB RAM
+     *  per vCPU). Omit → the smallest SKU. E2B sizing is template-defined and
+     *  ignores this. */
+    size?: SandboxSize;
+    /** Sandbox provider this workflow's runs execute on — `"vercel"` or
+     *  `"e2b"`. Optional and additive: omit and the run resolves to the
+     *  platform default (`vercel`). Set explicitly to pin a workflow to a
+     *  substrate regardless of the deployment default. Snapshot formats are
+     *  provider-specific, so the resolved provider is stamped on the run row
+     *  at first dispatch and reused across pause/resume/replay. */
+    provider?: WorkflowSandboxProvider;
+}
 export interface WorkflowMetadata {
     /** One-line, human-readable description of what the workflow does.
      *  Surfaced on the dashboard template tile + run page header. Authors
@@ -154,6 +180,9 @@ export interface WorkflowMetadata {
     outputSchema?: IOSchema;
     /** All snapshot config — boot source + capture mode. */
     snapshots?: SnapshotConfig;
+    /** Sandbox machine resources — size + provider. Optional; omit → smallest
+     *  SKU on the platform-default provider (`vercel`). */
+    resources?: SandboxResources;
     processors?: readonly Processor[];
     /** Connector requirements — providers whose APIs this workflow calls.
      *  Dispatch resolves an authorized grant per provider and injects a
@@ -165,6 +194,18 @@ export interface WorkflowMetadata {
     /** Tier-1 invoke ACL — who may dispatch this connector-brokering workflow.
      *  See `InvokePolicy`. */
     invokePolicy?: InvokePolicy;
+    /** Set by `defineSandboxEnvironment` to mark this workflow as an ENVIRONMENT
+     *  BUILD — a setup-only workflow whose job is to leave its VM configured and
+     *  snapshot it (base-env / agent-env). Environment builds build a platform
+     *  IMAGE and never use the shared factory drive, so the server SKIPS mounting
+     *  /factory for them: a live Archil mount baked into the captured snapshot
+     *  fails the NEXT boot's re-mount ("an older Archil process is still running
+     *  for this mountpoint"), degrading /factory for every workflow booting from
+     *  that snapshot. Absent on ordinary workflows — which mount /factory exactly
+     *  as before. Optional + additive: an ABSENT flag contributes nothing to the
+     *  canonical metadata hash (frozen-metadata rule), so existing workflows are
+     *  not forced to re-register. */
+    environmentBuild?: boolean;
 }
 /**
  * Pull the server-readable declarations off a source object (run-form

package/dist/types/workflow.d.ts

@@ -27,8 +27,8 @@ export type { WorkflowMetadata } from "./workflow-metadata.js";
 export interface AgentEventSink {
     emit(event: AgentLifecycleEvent): void | Promise<void>;
 }
-import type { SnapshotConfig, BootSnapshot, ReuseSnapshot, IOSchema, OutputSchema } from "./workflow-metadata.js";
-export type { SnapshotConfig, BootSnapshot, ReuseSnapshot, IOSchema, OutputSchema };
+import type { SnapshotConfig, BootSnapshot, ReuseSnapshot, IOSchema, OutputSchema, SandboxResources } from "./workflow-metadata.js";
+export type { SnapshotConfig, BootSnapshot, ReuseSnapshot, IOSchema, OutputSchema, SandboxResources };
 /** Turn/iteration budget for `agent(opts)`. Re-exported here so authors
  *  can type per-invoke budget overrides they pass as workflow input. */
 export interface AgentBudget {
@@ -41,9 +41,16 @@ export interface WorkflowCtx<TInput extends Record<string, unknown> = Record<str
     /** Persist key-value metadata on the run record (e.g. prUrl, planUrl). */
     setMetadata: (data: Record<string, unknown>) => Promise<void>;
     /**
-     * Wrap a named step for observability. Emits step_started / step_completed /
-     * step_failed lifecycle events with duration. Use for long phases you want
+     * Durable named step (ADR-0012). Runs `fn` once and memoises its result to
+     * the sandbox state-dir; on a pause-resume re-entry the recorded value is
+     * returned and `fn` is NOT re-run (a duration-0 "restored" sub-step). Also
+     * emits substep_started / substep_completed / substep_failed lifecycle
+     * events with duration — use for long phases you want both durable and
      * visible on the run's timeline (setup, external API calls, submit).
+     *
+     * Names must be unique within a step body (they key the memoise file).
+     * A body that pauses is never memoised — the resume re-runs it. For
+     * cross-process side effects (DB writes, emails) use `invokeChild`.
      */
     step<T>(name: string, fn: () => Promise<T>): Promise<T>;
     /** Pass to `agent({ events: ctx.agentEvents })` to stream agent lifecycle events. */
@@ -100,6 +107,15 @@ export interface WorkflowDefinition<TOutput = unknown, TInput extends Record<str
      * `invoke({ snapshots })` overrides this default.
      */
     snapshots?: SnapshotConfig;
+    /**
+     * Sandbox resources — machine SKU (`size`, a `SandboxSize` vCPU string:
+     * `2vcpu-4gb` | `4vcpu-8gb` | `8vcpu-16gb` | `32vcpu-64gb`) and `provider`
+     * (`vercel` | `e2b`). `size` maps to provider machine specs at create
+     * (Vercel: vCPUs, 2048 MB RAM per vCPU); E2B sizing is template-defined and
+     * ignores it. Optional; omit → smallest SKU on the default provider.
+     * Per-invocation `invoke({ size })` overrides the size.
+     */
+    resources?: SandboxResources;
     /**
      * Outbound network policy for the runner sandbox.
      * Use "*": [] to allow all traffic while still injecting headers for specific domains.
@@ -171,6 +187,13 @@ export interface WorkflowDefinition<TOutput = unknown, TInput extends Record<str
      * invokePolicy: { users: "owner", workflows: ["nightly-orchestrator"] }
      */
     invokePolicy?: InvokePolicy;
+    /**
+     * Internal — set by `defineSandboxEnvironment`, not by workflow authors.
+     * Marks the workflow as an environment build (base-env / agent-env) so the
+     * server skips mounting the shared factory drive for its runs (#13). See
+     * `WorkflowMetadata.environmentBuild`.
+     */
+    environmentBuild?: boolean;
 }
 /**
  * Declare a workflow. Two forms; both return a `Workflow` whose

package/dist/utils/bundler.d.ts

@@ -20,7 +20,7 @@
  * manifest's `sourceHash` against the source it received.
  */
 import type { SnapshotConfig } from "../types/workflow.js";
-import type { IOSchema, ConnectorRequirements, ConnectorOperationTag, InvokePolicy } from "../types/workflow-metadata.js";
+import type { IOSchema, ConnectorRequirements, ConnectorOperationTag, InvokePolicy, SandboxResources } from "../types/workflow-metadata.js";
 import type { SandboxNetworkPolicy } from "../sandbox.js";
 import { type WorkflowPlan } from "../types/workflow-plan.js";
 /** Bumped when the manifest contract changes in a way the server should
@@ -84,6 +84,9 @@ export interface BundledWorkflow {
     /** Snapshot config from the workflow definition — `bootFrom` (where to
      *  restore at run start), `save`, `retain`. */
     snapshots?: SnapshotConfig;
+    /** Sandbox resources declared via `defineWorkflow({ resources })` — machine
+     *  SKU (`size`) and `provider` (`vercel` | `e2b`). */
+    resources?: SandboxResources;
     workflowPlan: WorkflowPlan;
     /** Compact JSON-Schema-shaped description of the workflow's input
      *  type. Extracted from the workflow's declared `input` zod schema
@@ -98,6 +101,9 @@ export interface BundledWorkflow {
     /** Tier-1 invoke ACL — who may dispatch this connector-brokering
      *  workflow (`defineWorkflow({ invokePolicy })`). */
     invokePolicy?: InvokePolicy;
+    /** Set by `defineSandboxEnvironment` — marks an environment build so the
+     *  server skips the /factory mount for its runs (#13). */
+    environmentBuild?: boolean;
 }
 /**
  * Parse the bundled source and assert the default export is a CallExpression

package/dist/workflow-steps/observability.d.ts

@@ -31,13 +31,19 @@
 import type { AgentLifecycleEvent } from "../agent/agent-loop.js";
 import type { AgentEventSink } from "../types/workflow.js";
 import type { LiveAgentEventEmitter } from "./run-callback.js";
+import type { ScopedMemoize } from "../pause/checkpoint.js";
 /** One named sub-step (from `ctx.step("name", async () => ...)`).
- *  Becomes a `workflow_substep_*` lifecycle event on the run timeline. */
+ *  Becomes a `workflow_substep_*` lifecycle event on the run timeline.
+ *
+ *  `restored` is the durable-step resume case (ADR-0012): the body did NOT
+ *  re-run — its memoised result was read from the state-dir checkpoint a
+ *  prior subprocess wrote. Always `durationMs: 0` (no work happened this
+ *  pass) and never carries `error`. */
 export interface SubStepEvent {
     name: string;
     startedAt: number;
     durationMs: number;
-    status: "completed" | "failed";
+    status: "completed" | "failed" | "restored";
     /** Present when status="failed" — the user error's message. */
     error?: string;
 }
@@ -64,14 +70,34 @@ export declare class StepObservabilityCollector {
     private events;
     private subSteps;
     private readonly liveEmitter?;
+    /** State-dir memoise bound to this step's `step<idx>` scope. Present in
+     *  the sandbox runner (durable `ctx.step`); absent in-process so unit
+     *  tests record observability without touching disk. */
+    private readonly memoize?;
+    /** Sub-step names already used in THIS step body. A durable `ctx.step`
+     *  memoises by name, so a reused name would alias two distinct bodies
+     *  onto one checkpoint file — guarded by throwing on reuse (ADR-0012). */
+    private readonly usedStepNames;
     /** Seqs of events the server confirmed via the live route. */
     private readonly ackedSeqs;
     /** Promises for in-flight live emits — awaited at snapshot time. */
     private readonly inFlight;
     constructor(opts?: {
         liveEmitter?: LiveAgentEventEmitter;
+        memoize?: ScopedMemoize;
     });
     readonly setMetadata: (data: Record<string, unknown>) => Promise<void>;
+    /**
+     * Durable named sub-step (ADR-0012). The body's result is memoised to the
+     * state-dir checkpoint keyed `step<idx>.<name>`; on a pause-resume re-entry
+     * the value is read from disk and `fn` is NOT re-run (recorded as a
+     * duration-0 `"restored"` sub-step). A body that PAUSES (PauseSignal)
+     * propagates BEFORE any memoise write — partial work is never stored, so
+     * the resume re-runs it.
+     *
+     * When no memoise store is wired (in-process tests), the body always runs
+     * and is recorded as a normal timed `"completed"` / `"failed"` sub-step.
+     */
     readonly step: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
     readonly agentEvents: AgentEventSink;
     /** Wait for in-flight live emits to settle (or timeout) so the

package/dist/workflow-steps/types.d.ts

@@ -36,14 +36,18 @@ export interface StepContext<TInput = unknown> extends BaseExecutionContext {
      */
     setMetadata(data: Record<string, unknown>): Promise<void>;
     /**
-     * Wrap a named sub-step for observability. Emits
-     * `workflow_substep_started` / `workflow_substep_completed` /
-     * `workflow_substep_failed` lifecycle events on the run timeline with
-     * the measured `durationMs`. Use for long sub-phases inside one step
-     * (setup, external API call, submit).
+     * Durable named sub-step (ADR-0012). Runs `fn` once and memoises its
+     * result to the state-dir checkpoint keyed `step<idx>.<name>`; on a
+     * pause-resume re-entry the value is read from disk and `fn` is NOT
+     * re-run. Emits `workflow_substep_started` /
+     * `workflow_substep_completed` / `workflow_substep_failed` lifecycle
+     * events on the run timeline with the measured `durationMs` — a restored
+     * sub-step reports `durationMs: 0` and status `"restored"`.
      *
-     * The block runs even if observability flushing fails — instrumentation
-     * never breaks the workflow.
+     * Names must be unique within one step body — they key the memoise file,
+     * so a reused name throws. A body that pauses (PauseSignal) is never
+     * memoised: the resume re-enters and re-runs it. For cross-process side
+     * effects (DB writes, emails) use `invokeChild`, not `step`.
      */
     step<T>(name: string, fn: () => Promise<T>): Promise<T>;
     /**

package/dist/workflow-steps/workflow.d.ts

@@ -20,7 +20,7 @@
  */
 import type { z } from "zod";
 import type { Step, Workflow } from "./types.js";
-import type { SnapshotConfig } from "../types/workflow-metadata.js";
+import type { SnapshotConfig, SandboxResources } from "../types/workflow-metadata.js";
 import type { SandboxNetworkPolicy } from "../sandbox.js";
 import type { Processor } from "../processors/processor.js";
 export interface WorkflowBuilder<TInput, TCurrent> {
@@ -46,6 +46,10 @@ export interface StepWorkflowDefinition<TInput, TOutput> {
     networkPolicy?: SandboxNetworkPolicy;
     placeholders?: Record<string, string>;
     snapshots?: SnapshotConfig;
+    /** Sandbox resources — machine SKU (`size`, a `SandboxSize` vCPU string)
+     *  and `provider` (`vercel` | `e2b`). Vercel maps `size` to vCPUs; E2B
+     *  sizing is template-defined. Omit → smallest SKU on the default provider. */
+    resources?: SandboxResources;
     processors?: readonly Processor[];
 }
 export declare function createStepWorkflow<TInput, TOutput>(opts: StepWorkflowDefinition<TInput, TOutput>): WorkflowBuilder<TInput, TInput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-compose/sdk",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Client library for agent-compose — define agents, runtimes, and workflows, and invoke them against an agent-compose server.",
   "license": "MIT",
   "repository": {
@@ -60,13 +60,14 @@
     "vitest": "^3.0.0"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "0.29.0",
     "@anthropic-ai/claude-agent-sdk": "^0.2.129",
     "@babel/parser": "^7.29.3",
     "@babel/types": "^7.29.0",
     "@e2b/desktop": "^1.1.2",
     "@vercel/sandbox": "^2.2.0",
     "ai": "^6.0.175",
-    "e2b": "^2.3.0",
+    "e2b": "2.30.5",
     "ofetch": "^1.5.1",
     "openai": "^6.33.0",
     "p-retry": "^6.2.0",