@agent-compose/sdk 0.5.0 → 0.5.2

package/dist/active-step.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The step currently executing in this runner subprocess.
+ *
+ * Step-mode derivations that must be byte-identical across a pause-resume
+ * re-entry — the agent loop's `agentId` (which names `agent-<id>.json`) and
+ * the pause primitive's `pauseId` — need the running step's index. They
+ * CANNOT read it from `process.env.AC_STEP_INDEX`: `serveStep` scrubs the
+ * transport envs (`AC_STEP_MODE`, `AC_STEP_INDEX`, the result token, …) from
+ * `process.env` *before* the user step body runs, so by the time `agent()` /
+ * `ctx.pause` execute those reads return `undefined`
+ * (`step-invocation/server.ts` `scrubProtocolEnvs`). Reading scrubbed env was
+ * a latent resume bug: `agentId` fell through to `randomUUID()` on every
+ * subprocess, so resume never matched the prior `agent-<id>.json`.
+ *
+ * Instead the step runner sets the index here from the un-scrubbed `stepIndex`
+ * it already holds, and the derivations read it from here.
+ *
+ * Async-local rather than process-global: public in-process execution can run
+ * multiple workflows concurrently, and ids must stay scoped to the async step
+ * body that is deriving them. A fresh subprocess on resume starts with a fresh
+ * async context, the runner re-sets the same `stepIndex`, and the per-step
+ * call-order counters re-derive identical ids — which is exactly what lets
+ * resume find its on-disk state.
+ */
+export interface ActiveStep {
+    stepIndex: number;
+}
+interface ActiveStepState extends ActiveStep {
+    nextAgentCallIndex: number;
+    pauseOrdinalByScope: Map<string, number>;
+}
+/** Set (or clear, with `null`) the step currently running. Called by the
+ *  step runner around `step.run(...)`. Prefer `runWithActiveStep` for real
+ *  async execution; this setter exists for tests and small synchronous helpers. */
+export declare function setActiveStep(step: ActiveStep | null): void;
+/** Run `fn` with a step context scoped to this async call tree. */
+export declare function runWithActiveStep<T>(step: ActiveStep, fn: () => Promise<T>): Promise<T>;
+/** Publish (or clear, with `null`) the active step on the cross-instance bridge.
+ *  Called ONLY by the sandbox step runner (`runWorkflowSingleStep`), which runs
+ *  exactly one step per subprocess — so there is no concurrency to race the
+ *  single global slot. The bundle's `agent()` reads this when its own ALS is
+ *  empty. Returns the prior value so the caller can restore it. */
+export declare function setActiveStepBridge(step: ActiveStep | null): {
+    state: ActiveStepState | null;
+};
+/** Restore a bridge value captured by `setActiveStepBridge`. */
+export declare function restoreActiveStepBridge(prev: {
+    state: ActiveStepState | null;
+}): void;
+/** The step currently running, or `null` outside step execution (local
+ *  tests, dev, between steps). */
+export declare function getActiveStep(): ActiveStep | null;
+/** Return the next implicit `agent()` call coordinate for the active step. */
+export declare function nextAgentCallInActiveStep(): {
+    stepIndex: number;
+    callIndex: number;
+} | null;
+/** Return the next pause ordinal in `scope` for the active step invocation. */
+export declare function nextPauseOrdinalInActiveStep(scope: string): number | null;
+export {};

package/dist/agent/agent-loop-steer.test.d.ts

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

package/dist/agent/agent-loop.d.ts

@@ -7,6 +7,7 @@ import { z } from "zod";
 import type { AgentStatus, AgentMessage } from "./protocol.js";
 import type { Processor } from "../processors/processor.js";
 import { RequestContext } from "../request-context/request-context.js";
+import { type SteerPayload } from "./steer-control.js";
 export declare const DEFAULT_CLAUDE_MODEL = "claude-opus-4-7";
 export declare function parseAgentStatus(text: string): AgentStatus | null;
 export interface AgentLoopResult<TResponse = unknown> {
@@ -30,6 +31,7 @@ export type AgentMessageSummary = {
     type: "tool_use";
     toolName: string;
     toolUseId: string;
+    toolInput: Record<string, unknown>;
     toolInputPreview: string;
 } | {
     type: "tool_result";
@@ -58,6 +60,12 @@ export type AgentLifecycleEvent = {
     agentId: string;
     label: string;
     allowedTools?: string[];
+    /** Resolved model id used for this agent (e.g. `claude-sonnet-4-6`).
+     *  Read off `client.model` after runtime construction. */
+    model?: string;
+    /** Short runtime self-identifier (`claude`, `openai-desktop`, …).
+     *  Drives the per-agent runtime icon on the dashboard. */
+    runtimeKind?: string;
 } | {
     event: "agent.message";
     at: number;
@@ -101,5 +109,43 @@ export interface AgentLoopOpts<TResponse = unknown> {
     processors?: readonly Processor[];
     /** Per-run typed bag — propagated to every processor as `ctx.requestContext`. */
     requestContext?: RequestContext;
+    /**
+     * Mid-iteration user-message injection. When set, the agent loop
+     * builds a per-iteration AsyncQueue and hands it to the runtime as
+     * `inboxStream`. The runner-side inbox poller calls `push()` on
+     * `inbox` when a user message arrives; the runtime (streaming-input
+     * Claude Agent SDK) picks it up at the next safe boundary.
+     *
+     * The loop drains `inbox` into the per-iteration queue while the
+     * iteration is active and stops draining at iteration end — any
+     * messages that arrive between iterations are buffered on `inbox`
+     * and drain into the NEXT iteration's queue. So no message is lost,
+     * but mid-iteration injection requires the runtime to support
+     * streaming input (ignored otherwise — handled at the runtime).
+     */
+    inbox?: import("./async-queue.js").AsyncQueue<{
+        text: string;
+        senderName?: string | null;
+    }>;
+    /** PR 7 steer-pause: the boundary calls this to pause the workflow for a
+     *  human steer. agent() builds it (a corePause closed over runId/stepIndex);
+     *  the loop supplies the agentScope so the pauseId is stable across resume.
+     *  Absent ⇒ no steer pause (local tests, non-sandbox callers). */
+    pause?: <T = unknown>(req: {
+        reason: string;
+        correlationKey?: string;
+        schema?: z.ZodType<T>;
+    }, agentScope: {
+        agentId: string;
+        iteration: number;
+    }) => Promise<T>;
+    /** PR 7: take-once read of this agent's pending steer (set by the control
+     *  poller). Returns the steer's payload (reason / correlationKey) or null.
+     *  The boundary consumes it once per check, and only when no steer is
+     *  already staged. */
+    consumeSteerPending?: () => SteerPayload | null;
+    /** PR 7: `auto` (autonomous, default) or `hitl` (can be steer-paused). The
+     *  boundary is inert unless `hitl`. */
+    mode?: "auto" | "hitl";
 }
 export declare function agentLoop<TResponse = unknown>(opts: AgentLoopOpts<TResponse>): Promise<AgentLoopResult<TResponse>>;

package/dist/agent/async-queue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AsyncQueue — single-producer/single-consumer push-iterable.
+ *
+ * The Claude Agent SDK's streaming-input mode wants
+ * `prompt: AsyncIterable<SDKUserMessage>`. We need a primitive that:
+ *   - lets the agent loop `push()` user turns from outside the iterator
+ *     (initial prompt, plus async-arriving inbox messages)
+ *   - lets the SDK's `for await` consume them in order, blocking until
+ *     the next item arrives
+ *   - terminates cleanly via `close()` so the SDK sees the iterable
+ *     drain and finalises the assistant turn
+ *
+ * Why not an `EventEmitter` or RxJS — both are overkill for one shape.
+ * The implementation is ~30 lines of native Promise plumbing and stays
+ * inside the SDK package so it can be the canonical way agent-loop
+ * builds its prompt iterable.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly buffer;
+    private readonly resolvers;
+    private done;
+    /** Push one item. If a consumer is awaiting, it wakes immediately;
+     *  otherwise the item is buffered until the next `next()` call. */
+    push(value: T): void;
+    /** Signal end-of-stream. Any pending awaiters resolve as
+     *  `{ done: true }`; subsequent `push()` calls are silent no-ops. */
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/agent/protocol.d.ts

@@ -4,4 +4,12 @@ import type { AgentMessage } from "../types/protocol.js";
 export type { AgentMessage, AgentMessageInit, AgentMessageText, AgentMessageThinking, AgentMessageToolUse, AgentMessageToolResult, AgentMessageDone, AgentMessageError, AgentMessageUsage, AgentStatus, } from "../types/protocol.js";
 export { AgentStatusSchema };
 export declare const AgentMessageSchema: z.ZodType<AgentMessage>;
-export declare function parseAgentResponse(text: string): unknown;
+/** Parse the `<response>...</response>` block from agent text. Returns
+ *  `null` if missing or malformed. Callers run schema validation on
+ *  the returned `unknown` directly — the earlier generic overload that
+ *  did the safeParse inline returned `null` on schema failure,
+ *  swallowing the validation error without setting any breadcrumb on
+ *  the loop's `lastResponseValidationError`. No caller used that
+ *  overload; the dedicated `responseSchema` path in `agent-loop.ts`
+ *  does the parse-with-error-capture itself. */
+export declare function parseAgentResponse(text: string): unknown | null;

package/dist/agent/resolve-agent-id.test.d.ts

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

package/dist/agent/run-agent.d.ts

@@ -37,6 +37,11 @@ export interface AgentOpts<T = unknown> {
     tools?: string[];
     /** Turn/iteration caps. Defaults: 40 turns/iteration, 8 iterations. */
     budget?: AgentBudget;
+    /** Steerability (PR 7). `auto` (default) runs autonomously and ignores steer
+     *  requests; `hitl` lets a human pause this agent mid-run via the steer route
+     *  — the loop checks for a pending steer at each iteration boundary and only
+     *  `hitl` agents run the control poller. */
+    mode?: "auto" | "hitl";
     /** If set, the loop demands a `<response>` block when `exit_signal=true`
      *  and validates it against this schema. The response format appendix is
      *  appended to the prompt on first iteration. */
@@ -76,8 +81,16 @@ export interface AgentOpts<T = unknown> {
     requestContext?: RequestContext;
 }
 /**
- * Run an agent loop inside a workflow. Returns the loop's final
- * `AgentLoopResult`, including `response` when a `responseSchema` was
- * supplied and the model validated against it.
+ * Resolve the `agentId` for an `agent()` call. Resolution order:
+ *   1. Caller-supplied `explicitId` (the workflow author owns the id).
+ *   2. Step-mode derivation `step<idx>-agent-<callOrder>` — deterministic
+ *      across a pause-resume re-entry: the same step body re-executes in the
+ *      same call order, so the same id recovers `agent-<id>.json`. The step
+ *      index comes from the active-step context (set by the step runner),
+ *      NOT `process.env.AC_STEP_INDEX` — `serveStep` scrubs that before the
+ *      step body runs, which would orphan the state file on every resume
+ *      (see `active-step.ts`).
+ *   3. `randomUUID()` outside step mode (local tests, dev).
  */
+export declare function resolveAgentId(explicitId?: string): string;
 export declare function agent<T = unknown>(opts: AgentOpts<T>): Promise<AgentLoopResult<T>>;

package/dist/agent/steer-control.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Steer-control (PR 7) — the in-sandbox half of "a human pauses a running
+ * agent." A `runControlPoller` long-polls the per-run control channel; when a
+ * `steer_pause` for this agent arrives it sets a per-agentId **take-once**
+ * flag. The agent loop consumes the flag at its next iteration boundary
+ * (`consumeSteerPending`) and takes a `ctx.pause` there (commit 6).
+ *
+ * Lives in its own module so both `run-agent.ts` (the poller, the signal) and
+ * `agent-loop.ts` (the consume) import it without a cycle.
+ *
+ * The flag is **transient** and best-effort: a steer NOTIFY that arrives while
+ * the poller is between long-poll requests is missed (no durable backing — the
+ * route writes no row). The human re-requests; the loop only commits a durable
+ * `run_pauses` row once it reaches a boundary and takes the pause.
+ */
+import { z } from "zod";
+/** What a steer/resume answer carries. Used as the boundary pause's `schema`
+ *  so it is validated client-side in the re-spawned runner — a null/empty
+ *  message is rejected (PauseSchemaError) so an agent never resumes on an
+ *  empty steer. `message` becomes the agent's next user turn. */
+export declare const SteerDecisionSchema: z.ZodObject<{
+    message: z.ZodString;
+    actor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SteerDecision = z.infer<typeof SteerDecisionSchema>;
+/** Metadata a pending steer carries from the control message to the boundary
+ *  that turns it into a durable pause row. The flag store used to be a bare
+ *  `Set<string>` carrying none of this, so the committed `run_pauses` row
+ *  always had `correlation_key = null` and `reason = "human steer"` —
+ *  `resumePauseByKey` could never match and the operator's reason was lost. */
+export interface SteerPayload {
+    reason: string | null;
+    correlationKey: string | null;
+}
+/** Enqueue a pending steer-pause for `agentId` (called by the poller). A steer
+ *  whose correlationKey matches one already queued replaces it (idempotent);
+ *  a distinct key is appended. */
+export declare function signalSteerPending(agentId: string, payload: SteerPayload): void;
+/** Take-once read: dequeues and returns the next pending steer's payload for
+ *  `agentId` (FIFO), else null. The boundary calls this exactly once per check
+ *  so a single steer can't re-fire on the post-resume continuation; a second
+ *  queued steer surfaces at the next boundary. */
+export declare function consumeSteerPending(agentId: string): SteerPayload | null;
+/**
+ * Long-poll the per-run control channel and set the steer flag for this agent.
+ * Mirrors `runInboxPoller`: same per-run HMAC token, same backoff, stops on
+ * 401/403 (token expired / wrong run). The server holds each request open
+ * until a control message lands or the long-poll window elapses, so this
+ * loops mostly blocked in `fetch`.
+ */
+export declare function runControlPoller(opts: {
+    baseUrl: string;
+    token: string;
+    runId: string;
+    agentId: string;
+    signal: AbortSignal;
+}): Promise<void>;

package/dist/agent/steer-control.test.d.ts

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

package/dist/client.d.ts

@@ -183,6 +183,95 @@ export interface RunStatus<TOutput = unknown> {
     status: RunState;
     output?: TOutput;
 }
+/** ADR-0006 step 10 — actor record returned on a successful resume.
+ *  Shape mirrors the server's `PauseResumeActor` type after the row
+ *  has been stamped. Audit FKs (`userId` / `keyId` / `runId`) may be
+ *  null when the referenced row was deleted between resume and the
+ *  response render — the immutable `label` survives. */
+export interface ResumePauseActor {
+    kind: "session_user" | "api_key" | "agent";
+    /** Better Auth user id when kind='session_user'. */
+    userId?: string | null;
+    /** api_keys.id when kind='api_key'. */
+    keyId?: string | null;
+    /** Caller-run id when kind='agent' (NOT the run being resumed). */
+    runId?: string | null;
+    /** Agent-instance within `runId` when kind='agent'. */
+    agentId?: string | null;
+    label: string;
+}
+/** Success branch of the resume HTTP response. The pause has reached
+ *  a terminal state — `resolved` (workflow signal arrived), `expired`
+ *  (TTL fired first), or `cancelled` (workflow terminated mid-pause).
+ *  Only `resolved` carries the resume payload the user supplied. */
+export interface ResumePauseSuccess {
+    status: "resolved" | "expired" | "cancelled";
+    pauseId: string;
+    resolvedAt: string | null;
+    resumePayload: unknown;
+    actor: ResumePauseActor | null;
+}
+/** Pending branch — the workflow accepted the signal but the row
+ *  flip didn't observe within the route's 5s wait window. The
+ *  operation is in-flight; retry with the same `Idempotency-Key`
+ *  and the cache collapses the duplicate to a single canonical
+ *  response. */
+export interface ResumePausePending {
+    status: "pending";
+    pauseId: string;
+    timedOut: true;
+}
+export type ResumePauseResponse = ResumePauseSuccess | ResumePausePending;
+export interface ResumePauseOptions {
+    /** Stripe-style retry-dedup key — same syntax as the workflow-invoke
+     *  route: 1..255 chars of `[A-Za-z0-9_\-:.]`, no embedded CR/LF.
+     *  Sent as the `Idempotency-Key` request header. (The server reads the
+     *  header first, falling back to a body field for callers behind a
+     *  header-stripping proxy; this client only sends the header.) */
+    idempotencyKey?: string;
+    /** Abort the HTTP request mid-wait (e.g. from a UI cancel button).
+     *  The server's LISTEN tears down via the request's AbortSignal. */
+    signal?: AbortSignal;
+}
+export interface RequestAgentPauseOptions {
+    /** Human-readable note surfaced to the agent as the pause reason. */
+    reason?: string;
+    /** Your handle for answering this pause without the minted pauseId:
+     *  pass the same value to `resumePauseByKey`. */
+    correlationKey?: string;
+    /** Abort the HTTP request. */
+    signal?: AbortSignal;
+}
+export interface AnswerSteerOptions extends ResumePauseOptions {
+    /** Who answered — surfaced to the agent as `[human steer from <actor>]`. */
+    actor?: string;
+}
+/** 202 envelope from a steer-pause request. The request is best-effort and
+ *  fire-and-forget: it publishes a transient control message and returns
+ *  immediately — the agent parks at its next iteration boundary (if it is
+ *  `mode: "hitl"` and still running). Answer it via `answerSteerByKey`
+ *  (pass the `correlationKey` you set here) or `answerSteer` (by pauseId). */
+export interface RequestAgentPauseResponse {
+    status: "steer_requested";
+    runId: string;
+    agentId: string;
+}
+export interface SendAgentMessageOptions {
+    /** Transcript attribution. For non-session callers (API key, orchestrator)
+     *  this names the sender; defaults to the caller's identity server-side. */
+    senderName?: string;
+    /** Abort the HTTP request. */
+    signal?: AbortSignal;
+}
+/** 202 envelope from a message-to-running-agent request. The message is queued
+ *  durably and delivered mid-stream as the agent's next user turn — the workflow
+ *  is NOT paused. `seq` is the message's per-run ordinal. */
+export interface SendAgentMessageResponse {
+    status: "message_enqueued";
+    runId: string;
+    agentId: string;
+    seq: number;
+}
 export interface RunDetail<TOutput = unknown> {
     runId: string;
     title: string;
@@ -408,6 +497,78 @@ export declare class AgentComposeClient {
     deleteRunSnapshot(runId: string, snapshotId: string): Promise<void>;
     /** Poll run status. */
     getStatus<TOutput = unknown>(runId: string): Promise<RunStatus<TOutput>>;
+    /** Resume a paused run by pause id.
+     *
+     *  Returns the terminal state on success (200) or a pending
+     *  envelope (202) if the server's 5s wait timed out. For the
+     *  pending case, retry with the same `idempotencyKey` — the
+     *  server-side cache collapses duplicates to a single canonical
+     *  response once the workflow's row-flip lands.
+     *
+     *  Throws `AgentComposeError` on 4xx/5xx — 404 when the run or
+     *  pause doesn't exist, 403 when the caller lacks scope or the
+     *  run-token cross-run/cross-agent gate fails, 409 when the
+     *  `Idempotency-Key` was reused against a different operation.
+     */
+    resumePause(runId: string, pauseId: string, payload: unknown, opts?: ResumePauseOptions): Promise<ResumePauseResponse>;
+    /** Resume a paused run by correlation key. The correlation key is
+     *  the second resume key set on `ctx.pause({ correlationKey })`;
+     *  the server resolves it to a unique pending pause within the
+     *  run, then delegates to the same handler as `resumePause`.
+     *
+     *  The key is `encodeURIComponent`'d at the call site, so callers
+     *  pass the literal value (containing `/`, `:`, etc. as written).
+     */
+    resumePauseByKey(runId: string, correlationKey: string, payload: unknown, opts?: ResumePauseOptions): Promise<ResumePauseResponse>;
+    /** Answer a steer-pause by its `correlationKey` (PR 7) — the typed,
+     *  footgun-free way to resume a `requestAgentPause`.
+     *
+     *  The steer boundary validates its resume payload against
+     *  `SteerDecisionSchema` (`{ message }`) inside the re-spawned runner; a bare
+     *  string or wrong-shaped payload passed to `resumePause`/`resumePauseByKey`
+     *  fails that check and terminates the run. This wraps `message` in the
+     *  expected shape so the answer is always well-formed. `message` becomes the
+     *  agent's next user turn. Pass the `correlationKey` you gave
+     *  `requestAgentPause`.
+     *
+     *  Throws `AgentComposeError` on 4xx/5xx — 404 when no pending steer matches
+     *  the key. Throws synchronously if `message` is empty. */
+    answerSteerByKey(runId: string, correlationKey: string, message: string, opts?: AnswerSteerOptions): Promise<ResumePauseResponse>;
+    /** Answer a steer-pause by its minted `pauseId`. Use this when you learned
+     *  the pauseId out of band (e.g. from the `pause_requested` lifecycle event);
+     *  otherwise prefer {@link answerSteerByKey}. Same `{ message }` wrapping and
+     *  validation as `answerSteerByKey`. */
+    answerSteer(runId: string, pauseId: string, message: string, opts?: AnswerSteerOptions): Promise<ResumePauseResponse>;
+    /** Request that a running agent pause for human steering (PR 7).
+     *
+     *  Three callers share this route — an operator (session/api-key), another
+     *  agent or external orchestrator (run-callback token), and this method.
+     *  It is fire-and-forget: the server publishes a transient control message
+     *  and returns 202 immediately. The agent takes the pause at its next
+     *  iteration boundary — but only if it was started `mode: "hitl"` and is
+     *  still running; an `auto` agent ignores it. Delivery is best-effort (a
+     *  steer arriving between the in-sandbox poller's long-polls is missed —
+     *  re-request). Once the agent parks, answer it with `answerSteerByKey` (by
+     *  the `correlationKey` you pass here) or `answerSteer` (by the minted
+     *  pauseId) — these wrap the answer in the shape the steer boundary
+     *  validates. The human's `message` becomes the agent's next user turn.
+     *
+     *  Throws `AgentComposeError` on 4xx/5xx — 404 when the run doesn't exist,
+     *  403 when the caller lacks scope or the run-token gate fails.
+     */
+    requestAgentPause(runId: string, agentId: string, opts?: RequestAgentPauseOptions): Promise<RequestAgentPauseResponse>;
+    /** Send a message to a RUNNING agent — the lightweight steer (PR 7).
+     *
+     *  Durable and **non-halting**: the message is queued and delivered to the
+     *  agent mid-stream as its next user turn, *without* pausing the workflow.
+     *  This is the efficient way to nudge or redirect an agent that should keep
+     *  running — reserve `requestAgentPause` for when it must stop and wait. The
+     *  message lands at the agent's next iteration boundary (it finishes the
+     *  current model turn first). `senderName` sets the transcript attribution.
+     *
+     *  Throws `AgentComposeError` on 4xx/5xx — 404 unknown run, 403 scope/gate.
+     */
+    sendAgentMessage(runId: string, agentId: string, message: string, opts?: SendAgentMessageOptions): Promise<SendAgentMessageResponse>;
     /** Full run detail, including input/output and lifecycle events. */
     getRun<TOutput = unknown>(runId: string): Promise<RunDetail<TOutput>>;
     /** Ordered lifecycle timeline for one run. */

package/dist/index.d.ts

@@ -27,11 +27,10 @@ export type { Processor, ProcessorContext, ProcessorVerdict, ToolCall, } from ".
 export type { AgentMessage, AgentMessageInit, AgentMessageText, AgentMessageThinking, AgentMessageToolUse, AgentMessageToolResult, AgentMessageDone, AgentMessageError, AgentMessageUsage, AgentStatus, } from "./types/protocol.js";
 export type { SandboxProvider, DesktopSandboxProvider, } from "./types/sandbox.js";
 export { AgentComposeClient } from "./client.js";
-export type { RegisterResult, RegisterWorkflowInput, RuntimeSourceInput, InvokeWorkflowOptions, InvokeAndWaitOptions, InvokeResult, ListSnapshotsOptions, TemplateRow, ListTemplatesOptions, CreateFactoryInput, UpdateFactoryInput, SecretOptions, SetSecretResult, SecretListEntry, CreateApiKeyInput, StreamRunLogsOptions, EventSubjectType, EventRow, ReportEventInput, ListEventsOptions, ListEventsResult, RunLogLine, ListRunLogsOptions, RegisteredRuntime, RunState, RunStatus, FactoryRow, SnapshotListEntry, SnapshotListResponse, ApiKey, ApiKeyCreated, UsageRollupRow, UsageResponse, CancelRunResponse, } from "./client.js";
+export type { RegisterResult, RegisterWorkflowInput, RuntimeSourceInput, InvokeWorkflowOptions, InvokeAndWaitOptions, InvokeResult, ListSnapshotsOptions, TemplateRow, ListTemplatesOptions, CreateFactoryInput, UpdateFactoryInput, SecretOptions, SetSecretResult, SecretListEntry, CreateApiKeyInput, StreamRunLogsOptions, EventSubjectType, EventRow, ReportEventInput, ListEventsOptions, ListEventsResult, RunLogLine, ListRunLogsOptions, RegisteredRuntime, RunState, RunStatus, FactoryRow, SnapshotListEntry, SnapshotListResponse, ApiKey, ApiKeyCreated, UsageRollupRow, UsageResponse, CancelRunResponse, RequestAgentPauseOptions, RequestAgentPauseResponse, SendAgentMessageOptions, SendAgentMessageResponse, AnswerSteerOptions, } from "./client.js";
 export { parseSseStream } from "./sse.js";
 export { AgentComposeError } from "./errors.js";
 export { formatError } from "./utils/errors.js";
-export { discoverRuntimeName } from "./utils/discovery.js";
 export { bundleWorkflow, BUNDLER_VERSION, WorkflowSourceValidationError, assertDefaultExportIsDefineWorkflow, } from "./utils/bundler.js";
 export type { BundledWorkflow, WorkflowManifest } from "./utils/bundler.js";
 export { AgentStatusSchema } from "./utils/schemas.js";
@@ -50,8 +49,12 @@ export type { WorkflowResult, RunWorkflowOptions, EngineSubsystem } from "./work
 export { buildInvokeChild } from "./workflows/invoke-child.js";
 export { defineStep, isWorkflow, runWorkflowSteps, runWorkflowSingleStep, StepValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, } from "./workflow-steps/index.js";
 export type { Step, StepContext, StepRunResult, Workflow, DefineStepOpts, StepWorkflowDefinition, WorkflowBuilder, RunWorkflowStepsOpts, RunWorkflowStepsResult, RunWorkflowSingleStepOpts, RunWorkflowSingleStepResult, StepObservability, SubStepEvent, } from "./workflow-steps/index.js";
-export { invokeStep, serveStep, parseStepResult, buildStepEnvs, StepExecutionError, STEP_RESULT_PREFIX, STEP_ENV, RUNNER_BUNDLE_PATH, RUNNER_COMMAND, stepInputPath, requestContextPath, } from "./step-invocation/index.js";
-export type { StepRequest, StepResult, StepInvocationError, StepHandler, StepHandlerResult, ServeStepRequest, } from "./step-invocation/index.js";
+export { invokeStep, serveStep, parseStepResult, buildStepEnvs, StepExecutionError, STEP_RESULT_PREFIX, STEP_PAUSE_PREFIX, STEP_ENV, RUNNER_BUNDLE_PATH, RUNNER_COMMAND, stepInputPath, requestContextPath, } from "./step-invocation/index.js";
+export { PauseError, PauseExpiredError, PauseSchemaError, PauseRequestError, } from "./pause/errors.js";
+export type { PauseErrorCode } from "./pause/errors.js";
+export type { PauseRequest } from "./pause/pause-core.js";
+export type { RequestDecisionRequest, WaitForEventRequest } from "./pause/wrappers.js";
+export type { StepRequest, StepResult, StepInvocationError, StepPauseRequest, StepHandler, StepHandlerResult, ServeStepRequest, } from "./step-invocation/index.js";
 export { agentLoop, parseAgentStatus, DEFAULT_CLAUDE_MODEL } from "./agent/agent-loop.js";
 export type { AgentLifecycleEvent, AgentLoopOpts, AgentLoopResult } from "./agent/agent-loop.js";
 export { agent } from "./agent/run-agent.js";