@agent-compose/sdk 0.5.7 → 0.5.9

package/dist/agent/__tests__/run-agent-liveness.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * run-agent working-dir liveness probe (the degraded-FUSE-wedge fix).
+ *
+ * `agent()` delivers the platform context file (AGENTS.md / CLAUDE.md /
+ * GEMINI.md) to the working dir AND uses that write as a bounded liveness
+ * probe of the dir. AGENT_COMPOSE_RUN_DIR points at the /factory FUSE drive,
+ * whose writes HANG uninterruptibly (no timeout) when the mount degraded —
+ * launching the agent there wedges it silently with zero output. The probe
+ * bounds the write at 15s and falls back to /workspace (always present +
+ * writable) when the run dir is wedged.
+ *
+ * These tests pin: (1) the happy path keeps RUN_DIR; (2) a RUN_DIR whose write
+ * hangs forever still selects /workspace within the deadline. `agentLoop` is
+ * mocked so we observe only the `cwd` the loop is launched with; fake timers
+ * drive the 15s deadline without waiting in real time.
+ */
+export {};

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

@@ -0,0 +1,67 @@
+/**
+ * Harness-agnostic agent context delivery.
+ *
+ * Every coding-agent harness we drive (Claude Code, Codex, Amp, Gemini, …)
+ * looks for an instruction file in its working directory — but they disagree
+ * on the NAME (Codex/Amp read `AGENTS.md`; Claude reads `CLAUDE.md`; Gemini
+ * reads `GEMINI.md`). So `agent()` writes the SAME platform manual under all
+ * three names at the agent's working dir, and every harness finds the one it
+ * knows. The manual is the single source of truth here; `base-env` bakes a
+ * static copy at `/workspace/AGENTS.md` for plain shell sessions, but the
+ * per-run copy `agent()` writes is the authoritative one — it carries the
+ * live connector list and lands at the run's working dir.
+ */
+import type { SandboxProvider } from "../types/sandbox.js";
+/**
+ * The platform manual delivered to every agent, regardless of harness.
+ * Covers the three things an agent must know: where files go (the factory
+ * drive + the persist-by-default working dir), how to pause for a human, and
+ * that credentials are network-injected (never in the env). The live
+ * "Connectors & access" section is appended per-run by `buildAgentContextDoc`.
+ */
+export declare const AGENT_COMPOSE_MANUAL = "# Working inside an Agent Compose sandbox\n\nYou are an agent running in a per-run sandbox on the Agent Compose platform.\nUse the **`agentc` CLI** and the **`@agent-compose/sdk`** for everything below \u2014\ndo NOT hand-roll raw HTTP/curl calls against the platform API. The CLI is on\nyour PATH and already authenticated from the environment\n(`AGENT_COMPOSE_URL` / `AGENT_COMPOSE_API_KEY` / `AGENT_COMPOSE_FACTORY` are\ninjected for this run), so commands just work \u2014 no login, no keys to manage.\n\nThe `/ac:*` skills are installed as Claude Code slash commands (`/ac:invoke`,\n`/ac:events`, `/ac:logs`, `/ac:register`, \u2026) \u2014 reach for them too.\n\n## Files \u2014 your outputs persist by default\n\nYour working directory defaults to **`$AGENT_COMPOSE_RUN_DIR`** \u2014 a per-run\ndirectory on the shared factory drive\n(`$AGENT_COMPOSE_FACTORY_DIR/<workflow>/<version>/<run-id>/`) the platform\ncreates and attributes to this run. **Files you write here persist by\ndefault** \u2014 they show up in the dashboard's Files tab and the run's Artifacts\ncard, with no API calls to save them. The dir already exists and is writable.\n\nNeed throwaway scratch \u2014 heavy build output, package caches, temp files?\n`cd /tmp` (or any path outside `/factory`): anything off the factory drive is\nephemeral and discarded when the sandbox ends. In short: **stay in your working\ndir to keep something, `cd` out to throw it away.**\n\nThe whole shared drive is POSIX-mounted at `/factory`; the dashboard-visible\nroot is `$AGENT_COMPOSE_FACTORY_DIR` (`/factory/files`). Earlier versions and\nruns live in sibling dirs under\n`$AGENT_COMPOSE_FACTORY_DIR/$AGENT_COMPOSE_WORKFLOW/` \u2014 read them for prior\ncontext. Other workflows' dirs are present but not your concern.\n\n## Events \u2014 the factory timeline\n\nRecord something on the run/factory timeline (the dashboard renders these)\nwith the CLI \u2014 your run id is `$RUN_ID`:\n\n    agentc events send \"$RUN_ID\" <name> --summary \"<one line>\" [--body '<json>']\n\nNames like `note.created` / `brief.posted` surface in the Workbench;\n`agentc events list` reads them back. `/ac:events` is the skill equivalent.\n\n## Runs\n\n    agentc list                          # registered workflows  (/ac:list)\n    agentc logs \"$RUN_ID\"                # a run's logs           (/ac:logs)\n    agentc invoke <workflow> -i '<json>' # dispatch a workflow    (/ac:invoke)\n\n## Writing workflow / agent code \u2014 the SDK\n\n`@agent-compose/sdk` is installed in `/workspace` \u2014 import it from any script\nyou write there:\n\n    import { defineWorkflow, agent, AgentComposeClient } from \"@agent-compose/sdk\";\n\nUse `/ac:generate-workflow` / `/ac:generate-agent` to scaffold, then\n`agentc register <file.ts>` (or `/ac:register`).\n\n## Pausing to ask the human \u2014 `agentc pause`\n\nWhen you can't or shouldn't proceed without a human, run `agentc pause`, then\n**END YOUR TURN**:\n\n    agentc pause --reason \"Notion returned 401 \u2014 connect Notion to continue\" \\\n                 --option retry --option skip\n\n`agentc pause` does NOT block and does NOT print the answer. It records your\nquestion and returns immediately. The moment you end your turn, the run pauses\n(your sandbox is snapshotted and compute stops while the human decides) and the\nhuman's answer is delivered to you as your **next message** \u2014 you pick up\nexactly where you left off, with the answer in hand. So: ask, end your turn,\nand wait. Do NOT keep working, do NOT call more tools, and do NOT mark the task\ncomplete after pausing.\n\nReach for it the moment you hit \u2014 or foresee \u2014 any of these:\n- **A wall only a human can clear:** a 401/403, a missing credential, an\n  unconnected provider, a host the network refuses. Do NOT retry blindly or try\n  to work around it \u2014 pause and say what needs enabling.\n- **A durable or outward-facing action that needs sign-off:** registering a\n  workflow, deploying, sending email/messages, deleting or overwriting shared\n  data, spending money. Prepare everything, then pause for approval BEFORE you\n  commit it.\n- **A judgment call only the human can settle:** an under-specified request,\n  several valid paths, a conflict with existing state, missing input only they have.\n\nYou compose the `--reason` (the ask) yourself; pass `--option` choices when\nthere are clear ones, omit them for a free-form answer. Each agent pauses\nindependently \u2014 pausing doesn't stop the others.\n\n## Credentials\n\nConnector credentials (Google, GitHub, \u2026) are NEVER in your environment.\nThey're injected at the network layer when you call an allowed host \u2014 make the\nrequest **without** an Authorization header and the platform adds it. Don't try\nto read or exfiltrate tokens; they aren't here. The \"Connectors & access\"\nsection below (when present) lists exactly which providers this run can reach.\n\n## Tools in this environment\n\n- `agentc` \u2014 Agent Compose CLI (your primary interface; authed from env)\n- `@agent-compose/sdk` \u2014 installed in /workspace for writing workflows\n- `/ac:*` Claude Code skills \u2014 slash commands for the above\n- `archil` (factory drive), `rtk`, `bun`\n- A world-writable `/workspace` working directory";
+/**
+ * One connector this run can reach, as the agent should see it. Strictly
+ * NON-SECRET — hosts, methods, paths, identity only. The access token is
+ * injected at the network layer and never appears here. The server builds
+ * this list at dispatch from the run's connector grants × the provider
+ * catalogue and delivers it as the `AGENT_COMPOSE_CONNECTORS` env (JSON array).
+ */
+export interface AgentConnectorInfo {
+    /** Provider key (`github`, `notion`, …). */
+    provider: string;
+    /** Human label ("GitHub", "Notion"). */
+    name?: string;
+    /** API hosts the credential is injected for. */
+    hosts?: string[];
+    /** Allowed HTTP methods (Tier-2 narrowing). Empty/absent = any. */
+    methods?: string[];
+    /** Allowed path prefixes (Tier-2 narrowing). Empty/absent = any. */
+    pathPrefixes?: string[];
+    /** GitHub: the repository the minted token is scoped to. */
+    repository?: string;
+    /** Coarse capability the token was minted with. */
+    access?: string;
+    /** Human scope descriptions, when the provider declares them. */
+    scopes?: string[];
+}
+/** Compose the full per-run agent doc: the static manual + the live
+ *  connectors section read from `AGENT_COMPOSE_CONNECTORS` (a JSON array;
+ *  malformed/absent → no section). */
+export declare function buildAgentContextDoc(env: Record<string, string | undefined>): string;
+/**
+ * Write the platform context at the agent's working dir under every harness's
+ * instruction-file name, so whichever CLI runs finds the one it reads. Codex
+ * and Amp read `AGENTS.md` natively; Claude reads `CLAUDE.md`; Gemini reads
+ * `GEMINI.md` — we write identical content to all three rather than detect the
+ * harness (the runtime's `kind` isn't known until after spawn, and a few extra
+ * small files in our own run dir are harmless).
+ *
+ * Best-effort: a write failure logs and is swallowed — never fail an agent
+ * because its context file couldn't be written.
+ */
+export declare function writeAgentContext(args: {
+    sandbox: Pick<SandboxProvider, "files">;
+    cwd: string;
+    env: Record<string, string | undefined>;
+}): Promise<void>;

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

@@ -6,8 +6,10 @@ import type { RuntimeOptions, ModelExecutionContract } from "../index.js";
 import { z } from "zod";
 import type { AgentStatus, AgentMessage } from "./protocol.js";
 import type { Processor } from "../processors/processor.js";
+import { type BoundaryPauseFn } from "../pause/pause-core.js";
 import { RequestContext } from "../request-context/request-context.js";
 import { type SteerPayload } from "./steer-control.js";
+import { type LocalPauseRequest } from "./local-pause-request.js";
 export declare const DEFAULT_CLAUDE_MODEL = "claude-fable-5";
 export declare function parseAgentStatus(text: string): AgentStatus | null;
 export interface AgentLoopResult<TResponse = unknown> {
@@ -46,12 +48,20 @@ export type AgentMessageSummary = {
     cacheCreationTokens: number;
     durationMs: number;
     numTurns: number;
+    model?: string;
 } | {
     type: "done";
     sessionId: string;
 } | {
     type: "error";
     text: string;
+} | {
+    type: "plan";
+    entries: {
+        content: string;
+        priority: "high" | "medium" | "low";
+        status: "pending" | "in_progress" | "completed";
+    }[];
 };
 export declare function summarizeAgentMessage(msg: AgentMessage): AgentMessageSummary;
 export type AgentLifecycleEvent = {
@@ -127,23 +137,24 @@ export interface AgentLoopOpts<TResponse = unknown> {
         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>;
+    /** The run's pause boundary. agent() builds it (a corePause closed over
+     *  runId/stepIndex); the loop supplies the agentScope so the pauseId is
+     *  stable across resume. Drives both PR-7 steer-pause AND a processor's
+     *  `ctx.pause` (human-approval gate). Absent ⇒ no pause (local tests,
+     *  non-sandbox callers). */
+    pause?: BoundaryPauseFn;
     /** 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;
+    /** Take-once read of a local `agentc pause` request this agent dropped in the
+     *  state dir during its turn (the CLI writes it; see local-pause-request.ts).
+     *  Returns the request (reason + offered options) or null. The loop turns it
+     *  into a staged self-pause the next boundary takes — the same snapshot-release
+     *  path as `needs_input`, but triggered by an explicit `agentc pause` call so
+     *  it is honored regardless of `mode`. */
+    consumeLocalPauseRequest?: () => LocalPauseRequest | null;
     /** PR 7: `auto` (autonomous, default) or `hitl` (can be steer-paused). The
      *  boundary is inert unless `hitl`. */
     mode?: "auto" | "hitl";

package/dist/agent/local-pause-request.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Local pause-request marker — the in-sandbox bridge from `agentc pause` to
+ * the agent loop's snapshot-release pause boundary.
+ *
+ * `agentc pause` runs as a grandchild subprocess of the runner (the agent CLI
+ * shells out to it). It cannot throw a `PauseSignal` into the loop and the
+ * in-memory steer flag (`signalSteerPending`) lives in a different process, so
+ * the only reliable channel is the shared sandbox filesystem. The CLI writes a
+ * durable marker here; the agent loop consumes it at the end of the turn
+ * (alongside the `needs_input` self-pause) and stages a real `ctx.pause` the
+ * next boundary takes — which snapshots the sandbox, releases the activity
+ * (compute stops), and parks the workflow. On resume the human's answer is
+ * delivered as the agent's next user turn.
+ *
+ * This is the ONLY place the marker path + shape are defined — both the CLI
+ * (writer) and the SDK loop (reader) import it, so the two halves can never
+ * drift. Like the rest of the state-dir, the layout is a wire protocol between
+ * the runner and the next subprocess invocation (ADR-0006). The marker is
+ * consumed BEFORE the snapshot, so it never needs to survive a pause.
+ *
+ * Scoped by `agentId` so concurrent `agent()` calls sharing one sandbox each
+ * see only their own request. When the id is unavailable (older agent env that
+ * doesn't inject `AGENT_COMPOSE_AGENT_ID`) both sides fall back to a single
+ * unscoped slot — correct for the common single-agent step, and the only case
+ * where an unscoped marker can be ambiguous (two anonymous agents) is one the
+ * old block-poll CLI couldn't handle either.
+ */
+/** A choice offered to the human. A bare string is shorthand for
+ *  `{ label, value }` with both equal — exactly what the dashboard's
+ *  `readOptions` accepts. */
+export type PauseOption = string | {
+    label: string;
+    value: string;
+};
+/** What `agentc pause` records for the loop to turn into a `ctx.pause`. */
+export interface LocalPauseRequest {
+    /** The question shown to the human (becomes the pause `reason`). */
+    reason: string;
+    /** Optional offered choices, rendered as buttons in the dashboard. */
+    options?: PauseOption[];
+}
+/** Write the marker atomically (tmp → rename) so the loop never reads a
+ *  partial file mid-write. Called by `agentc pause`. */
+export declare function writeLocalPauseRequest(agentId: string | undefined | null, req: LocalPauseRequest): void;
+/** Take-once read: returns + deletes this agent's pending pause request, else
+ *  null. Checks the agent-scoped slot first, then the unscoped fallback. The
+ *  loop calls this once per turn; a malformed marker is dropped (deleted +
+ *  null) rather than wedging the loop. */
+export declare function consumeLocalPauseRequest(agentId: string | undefined | null): LocalPauseRequest | null;

package/dist/agent/local-pause-request.test.d.ts

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

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

@@ -15,13 +15,29 @@
  */
 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;
+ *  so it is validated client-side in the re-spawned runner — an empty answer
+ *  is rejected (PauseSchemaError) so an agent never resumes on nothing. The
+ *  normalised `message` becomes the agent's next user turn.
+ *
+ *  Accepts BOTH resume-payload conventions and normalises to `{ message }`:
+ *    - `{ message }` — the SDK / API steer convention (`answerSteer`).
+ *    - `{ decision }` — what the dashboard's RunPausePanel universally sends
+ *      for every pause (option click or free text). Without this, resuming an
+ *      agent steer / `needs_input` / `agentc pause` pause from the dashboard
+ *      failed schema validation in the re-spawned runner and the agent never
+ *      got the answer — the resume looked like it did nothing. */
+export declare const SteerDecisionSchema: z.ZodPipe<z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    decision: z.ZodOptional<z.ZodString>;
     actor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    message: string;
+    actor: string | null;
+}, {
+    message?: string | undefined;
+    decision?: string | undefined;
+    actor?: string | null | undefined;
+}>>;
 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

package/dist/client.d.ts

@@ -10,10 +10,10 @@
  * `register()` accepts pre-built sources — use the CLI (`agent-compose
  * register`) or build sources yourself and pass them directly.
  */
-import type { SandboxNetworkPolicy } from "./sandbox.js";
+import type { SandboxNetworkPolicy, SandboxSize } from "./sandbox.js";
 import type { RunEvent } from "./types/events.js";
 import type { WorkflowPlan } from "./types/workflow-plan.js";
-import type { SnapshotConfig, IOSchema, ConnectorRequirements, ConnectorOperationTag, InvokePolicy } from "./types/workflow-metadata.js";
+import type { SnapshotConfig, IOSchema, ConnectorRequirements, ConnectorOperationTag, InvokePolicy, SandboxResources } from "./types/workflow-metadata.js";
 import type { WorkflowManifest } from "./utils/bundler.js";
 export interface RegisterResult {
     id: string;
@@ -67,6 +67,9 @@ export interface RegisterWorkflowInput {
     /** All snapshot config — `bootFrom` (where to restore at run start),
      *  `save`, `retain`. See `WorkflowMetadata.snapshots`. */
     snapshots?: SnapshotConfig;
+    /** Sandbox machine resources — size + provider (template defaults).
+     *  See `WorkflowMetadata.resources`. */
+    resources?: SandboxResources;
     /** Provider-neutral execution plan detected by the CLI bundler. */
     workflowPlan?: WorkflowPlan;
     /** Connector requirements declared via `defineWorkflow({ connectors })`
@@ -83,6 +86,10 @@ export interface RegisterWorkflowInput {
     inputSchema?: IOSchema;
     /** Output schema extracted from the workflow's `output` zod schema. */
     outputSchema?: IOSchema;
+    /** Set by `defineSandboxEnvironment` — marks an environment build so the
+     *  server skips the /factory mount for its runs (#13). See
+     *  `WorkflowMetadata.environmentBuild`. */
+    environmentBuild?: boolean;
     /** Factory slug. Defaults to `"default"`. */
     factorySlug?: string;
 }
@@ -101,6 +108,10 @@ export interface InvokeWorkflowOptions {
      *  vars after brokering. Replaces the template-level placeholders for
      *  this run only — registered metadata is not mutated. */
     placeholders?: Record<string, string>;
+    /** Per-invocation machine-size override of the template's `resources.size`.
+     *  `small` (default) | `medium` | `large`; omit → the template default,
+     *  else `small`. Honoured on Vercel (→ vCPUs); E2B ignores it. */
+    size?: SandboxSize;
     /** Explicit parent run id. Pass `null` to suppress ambient RUN_ID auto-detection. */
     parentRunId?: string | null;
     /** Agent loop inside the parent run that caused this invoke, when applicable. */
@@ -135,6 +146,53 @@ export interface TemplateRow {
 export interface ListTemplatesOptions {
     factorySlug?: string;
 }
+/** A human member of your team — the people an agent (or you) can @-flag. */
+export interface TeamMember {
+    /** Membership row id. */
+    id: string;
+    /** The user id — what you pass to `createMentions({ mentionedUserIds })`. */
+    userId: string;
+    role: string;
+    email: string;
+    name: string;
+    joinedAt: string;
+}
+/** A "you were flagged" ping, persisted server-side so it reaches the
+ *  mentioned teammate in their Workbench. */
+export interface Mention {
+    id: string;
+    factoryId: string;
+    mentionedUserId: string;
+    /** Who flagged: 'user' | 'api_key' | 'run' | 'system'. */
+    actorKind: string;
+    actorId: string | null;
+    actorLabel: string | null;
+    /** Where it lives: 'doc' | 'comment' | 'plan' | 'run'. */
+    contextKind: string;
+    contextPath: string | null;
+    /** Ready-made relative dashboard URL the Workbench card links to. */
+    contextUrl: string | null;
+    text: string;
+    runId: string | null;
+    seenAt: string | null;
+    resolvedAt: string | null;
+    createdAt: string;
+}
+export interface CreateMentionsInput {
+    /** Team-member user ids to flag (1–20). Discover them via `listMembers()`.
+     *  Non-members are dropped server-side. */
+    mentionedUserIds: string[];
+    /** The flag message shown in the teammate's Workbench. */
+    text: string;
+    contextKind: "doc" | "comment" | "plan" | "run";
+    /** Factory-relative file path or comment thread id, when applicable. */
+    contextPath?: string;
+    /** Ready-made relative dashboard URL the Workbench card links to (e.g.
+     *  `/factories/<slug>/files/view?path=<plan>`). */
+    contextUrl?: string;
+    runId?: string;
+    factorySlug?: string;
+}
 export interface CreateFactoryInput {
     slug: string;
     name: string;
@@ -622,6 +680,16 @@ export declare class AgentComposeClient {
         factorySlug?: string;
         revision?: number;
     }): Promise<string>;
+    /** List the human members of your team — the people you (or an agent) can
+     *  @-flag with `createMentions`. Each row's `userId` is what
+     *  `mentionedUserIds` expects. */
+    listMembers(): Promise<TeamMember[]>;
+    /** Flag one or more teammates — a durable ping that lands in their factory
+     *  Workbench. Use from an agent (e.g. a remediation plan that needs a human
+     *  to rotate a secret) or any team automation. Resolve `mentionedUserIds`
+     *  via `listMembers()`. When run inside a sandbox the run-callback token is
+     *  forwarded so the ping is attributed to the run ("flagged by <workflow>"). */
+    createMentions(input: CreateMentionsInput): Promise<Mention[]>;
     /** List events ingested into a factory, newest first. Supports
      *  case-insensitive substring filter (`name`) and timestamp-cursor
      *  pagination (`before`). Returns `{ events, has_more }` — the
@@ -673,6 +741,12 @@ export declare class AgentComposeClient {
     listSecrets(workflowName: string, opts?: SecretOptions): Promise<SecretListEntry[]>;
     /** Delete a workflow secret. */
     deleteSecret(workflowName: string, key: string, opts?: SecretOptions): Promise<void>;
+    /** Create or update a factory-level secret. */
+    setFactorySecret(key: string, value: string, opts?: SecretOptions): Promise<SetSecretResult>;
+    /** List factory-level secret keys (metadata only — values are never returned). */
+    listFactorySecrets(opts?: SecretOptions): Promise<SecretListEntry[]>;
+    /** Delete a factory-level secret. */
+    deleteFactorySecret(key: string, opts?: SecretOptions): Promise<void>;
     /** Create a new API key on the caller's team. The plaintext `key` is
      *  returned once — it cannot be retrieved later.
      *

package/dist/index.d.ts

@@ -23,12 +23,12 @@ export type { WorkflowPlan, WorkflowStepPlan } from "./types/workflow-plan.js";
 export type { BaseExecutionContext, InvokeChild } from "./types/execution-context.js";
 export { RequestContext, ReservedKeyError, NonSerialisableValueError, AC_RESERVED_PREFIX, AC_TEAM_ID, AC_RUN_ID, AC_WORKFLOW_ID, AC_FACTORY_ID, AC_API_KEY_SCOPES, AC_PARENT_RUN_ID, AC_ABORT_SIGNAL, } from "./request-context/index.js";
 export type { RequestContextReserved, RequestContextWire, } from "./request-context/index.js";
-export { Verdict, runProcessorChain, denyTools, requireScope, redactPattern, } from "./processors/index.js";
+export { Verdict, runProcessorChain, denyTools, humanApproval, requireScope, redactPattern, } from "./processors/index.js";
 export type { Processor, ProcessorContext, ProcessorVerdict, ToolCall, } from "./processors/index.js";
 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, TemplateSourceRef, 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, ResumePauseOptions, ResumePauseResponse, ResumePauseSuccess, ResumePausePending, ResumePauseActor, } from "./client.js";
+export type { RegisterResult, RegisterWorkflowInput, RuntimeSourceInput, TemplateSourceRef, InvokeWorkflowOptions, InvokeAndWaitOptions, InvokeResult, ListSnapshotsOptions, TemplateRow, ListTemplatesOptions, CreateFactoryInput, UpdateFactoryInput, SecretOptions, SetSecretResult, SecretListEntry, CreateApiKeyInput, StreamRunLogsOptions, TeamMember, Mention, CreateMentionsInput, EventSubjectType, EventRow, ReportEventInput, ListEventsOptions, ListEventsResult, RunLogLine, ListRunLogsOptions, RegisteredRuntime, RunState, RunStatus, FactoryRow, SnapshotListEntry, SnapshotListResponse, ApiKey, ApiKeyCreated, UsageRollupRow, UsageResponse, CancelRunResponse, RequestAgentPauseOptions, RequestAgentPauseResponse, SendAgentMessageOptions, SendAgentMessageResponse, AnswerSteerOptions, ResumePauseOptions, ResumePauseResponse, ResumePauseSuccess, ResumePausePending, ResumePauseActor, } from "./client.js";
 export { parseSseStream } from "./sse.js";
 export { AgentComposeError } from "./errors.js";
 export { formatError } from "./utils/errors.js";
@@ -50,9 +50,10 @@ export { default as ampRuntime } from "./runtimes/amp.js";
 export { bashTool, codingTools, editTool, readTool, writeTool } from "./tools/index.js";
 export type { CodingTool } from "./tools/index.js";
 export type { RunEvent } from "./types/events.js";
-export { createSandbox, reconnectSandbox, killAllSandboxes, killSandboxById, getSandboxQuotas, listOwnedSandboxes, deleteSandboxSnapshot, makeSandboxProvider, makeDesktopSandboxProvider, parseSseExecStream, AGENT_COMPOSE_TAG } from "./sandbox.js";
+export { createSandbox, reconnectSandbox, killAllSandboxes, killSandboxById, getSandboxQuotas, listOwnedSandboxes, deleteSandboxSnapshot, snapshotResolves, makeSandboxProvider, makeDesktopSandboxProvider, parseSseExecStream, AGENT_COMPOSE_TAG, SANDBOX_VCPUS, DEFAULT_SANDBOX_SIZE, E2B_TEMPLATE_SIZES, isE2bSupportedSize, e2bMachineSpec, e2bBaseTemplate, e2bAgentEnvTemplate, isPlatformE2bTemplateAlias } from "./sandbox.js";
 export { SandboxUnavailableError, SANDBOX_UNAVAILABLE_PREFIX } from "./sandbox-errors.js";
-export type { SandboxCreateOpts, SandboxNetworkPolicy, SandboxNetworkHeaderTransform, SandboxNetworkAllowRule, SandboxNetworkSubnetPolicy, SandboxProviderName, SandboxQuotaResult, OwnedSandboxResult, OwnedSandbox, ParseSseExecStreamOptions, SandboxCommandRunOptions, SandboxCommandResult, } from "./sandbox.js";
+export type { SandboxCreateOpts, SandboxNetworkPolicy, SandboxNetworkHeaderTransform, SandboxNetworkAllowRule, SandboxNetworkSubnetPolicy, SandboxProviderName, SandboxQuotaResult, OwnedSandboxResult, OwnedSandbox, SandboxSize, ParseSseExecStreamOptions, SandboxCommandRunOptions, SandboxCommandResult, } from "./sandbox.js";
+export type { SandboxResources } from "./types/workflow-metadata.js";
 export { runWorkflow, WorkflowError, EngineError, classifyError, parseNameVersion } from "./workflows/engine.js";
 export type { WorkflowResult, RunWorkflowOptions, EngineSubsystem } from "./workflows/engine.js";
 export { buildInvokeChild } from "./workflows/invoke-child.js";
@@ -62,11 +63,15 @@ export { invokeStep, serveStep, parseStepResult, buildStepEnvs, StepExecutionErr
 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 { WaitForEventRequest } from "./pause/wrappers.js";
+export { writeLocalPauseRequest, consumeLocalPauseRequest } from "./agent/local-pause-request.js";
+export type { LocalPauseRequest, PauseOption } from "./agent/local-pause-request.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";
 export type { AgentOpts } from "./agent/run-agent.js";
+export { AGENT_COMPOSE_MANUAL, buildAgentContextDoc, writeAgentContext } from "./agent/agent-context.js";
+export type { AgentConnectorInfo } from "./agent/agent-context.js";
 export { AgentMessageSchema, parseAgentResponse } from "./agent/protocol.js";
 export { importSourceModule, TMP_DIR, LATEST_VERSION } from "./utils/source-loader.js";