agentbox-sdk 0.1.0 → 0.1.3

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-export { A as AISDKEvent, a as AgentApprovalMode, b as AgentCommandConfig, c as AgentExecutionRequest, d as AgentLocalMcpConfig, e as AgentMcpConfig, f as AgentOptions, g as AgentOptionsBase, h as AgentOptionsMap, i as AgentPermissionDecision, j as AgentPermissionKind, k as AgentPermissionResponse, l as AgentProviderAdapter, m as AgentProviderName, n as AgentRemoteMcpConfig, o as AgentResult, p as AgentRun, q as AgentRunConfig, r as AgentRunSink, s as AgentSkillConfig, t as AgentSubAgentConfig, C as ClaudeCodeAgentOptions, u as ClaudeCodeHookConfig, v as ClaudeCodeHookEvent, w as ClaudeCodeHookHandler, x as ClaudeCodeHookMatcherGroup, y as ClaudeCodeHooksConfig, z as ClaudeCodeProviderOptions, B as CodexAgentOptions, D as CodexCommandHook, E as CodexHookEvent, F as CodexHookMatcherGroup, G as CodexHooksConfig, H as CodexProviderOptions, I as DataContent, J as EmbeddedSkillConfig, K as FilePart, L as ImagePart, M as MessageCompletedEvent, N as MessageInjectedEvent, O as MessageStartedEvent, P as NormalizedAgentEvent, Q as NormalizedAgentEventBase, R as NormalizedAgentEventType, S as OpenCodeAgentOptions, T as OpenCodePluginConfig, U as OpenCodePluginEvent, V as OpenCodePluginHookConfig, W as OpenCodeProviderOptions, X as PermissionRequestedEvent, Y as PermissionResolvedEvent, Z as RawAgentEvent, _ as ReasoningDeltaEvent, $ as RepoSkillConfig, a0 as RunCompletedEvent, a1 as RunErrorEvent, a2 as RunStartedEvent, a3 as TextDeltaEvent, a4 as TextPart, a5 as ToolCallCompletedEvent, a6 as ToolCallDeltaEvent, a7 as ToolCallStartedEvent, a8 as UserContent, a9 as UserContentPart, aa as createNormalizedEvent, ab as normalizeRawAgentEvent, ac as toAISDKEvent, ad as toAISDKStream } from './types-BwcoN0n-.js';
-export { Agent } from './agents/index.js';
-export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec } from './Sandbox-DTprxRZf.js';
+export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupConfig, w as AgentSetupRequest, x as AgentSkillConfig, y as AgentSubAgentConfig, z as AttachedRun, C as ClaudeCodeAgentOptions, B as ClaudeCodeHookConfig, D as ClaudeCodeHookEvent, E as ClaudeCodeHookHandler, F as ClaudeCodeHookMatcherGroup, G as ClaudeCodeHooksConfig, H as ClaudeCodeProviderOptions, I as CodexAgentOptions, J as CodexCommandHook, K as CodexHookEvent, L as CodexHookMatcherGroup, M as CodexHooksConfig, N as CodexProviderOptions, O as DataContent, P as EmbeddedSkillConfig, Q as FilePart, R as ImagePart, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, Y as OpenCodeAgentOptions, Z as OpenCodePluginConfig, _ as OpenCodePluginEvent, $ as OpenCodePluginHookConfig, a0 as OpenCodeProviderOptions, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a5 as RepoSkillConfig, a6 as RunCompletedEvent, a7 as RunErrorEvent, a8 as RunStartedEvent, a9 as TextDeltaEvent, aa as TextPart, ab as ToolCallCompletedEvent, ac as ToolCallDeltaEvent, ad as ToolCallStartedEvent, ae as UserContent, af as UserContentPart, ag as createNormalizedEvent, ah as normalizeRawAgentEvent, ai as toAISDKEvent, aj as toAISDKStream } from './types-B3N-Qo2q.js';
+export { AGENT_RESERVED_PORTS, Agent, collectAllAgentReservedPorts } from './agents/index.js';
+export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec, T as TarballEntry, V as VercelGitSource, p as VercelProviderOptions, q as VercelSandboxOptions } from './Sandbox-CByFJI8X.js';
 export { SandboxAdapter, buildGitCloneCommand } from './sandboxes/index.js';
+export { ProviderLogAssembler } from './events/index.js';
+export { AgentProvider, SandboxProvider } from './enums.js';
 import 'e2b';
+import '@vercel/sandbox';
 import '@daytonaio/sdk';
 import 'modal';
 import 'dockerode';

package/dist/index.js

@@ -1,24 +1,37 @@
 import {
   Agent
-} from "./chunk-BW43ESRM.js";
+} from "./chunk-4MBB6QHD.js";
 import {
+  ProviderLogAssembler,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "./chunk-7FLLQJ6J.js";
+} from "./chunk-ZOWBRUQR.js";
 import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "./chunk-QRQFQTGH.js";
-import "./chunk-HMBWQSVN.js";
-import "./chunk-JFDP556Q.js";
+} from "./chunk-LPKKT6YT.js";
+import {
+  AGENT_RESERVED_PORTS,
+  collectAllAgentReservedPorts
+} from "./chunk-INMA52FV.js";
+import "./chunk-NSJM57Z4.js";
+import {
+  AgentProvider,
+  SandboxProvider
+} from "./chunk-GOFJNFAD.js";
 export {
+  AGENT_RESERVED_PORTS,
   Agent,
+  AgentProvider,
+  ProviderLogAssembler,
   Sandbox,
   SandboxAdapter,
+  SandboxProvider,
   buildGitCloneCommand,
+  collectAllAgentReservedPorts,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,

package/dist/sandboxes/index.d.ts

@@ -1,6 +1,8 @@
-import { l as SandboxProviderName, i as SandboxOptions, a as CommandOptions, b as CommandResult, A as AsyncCommandHandle, h as SandboxListOptions, g as SandboxDescriptor, G as GitCloneOptions } from '../Sandbox-DTprxRZf.js';
-export { C as CommandEvent, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, j as SandboxOptionsBase, k as SandboxOptionsMap, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec } from '../Sandbox-DTprxRZf.js';
+import { l as SandboxProviderName, i as SandboxOptions, a as CommandOptions, b as CommandResult, A as AsyncCommandHandle, h as SandboxListOptions, g as SandboxDescriptor, T as TarballEntry, G as GitCloneOptions } from '../Sandbox-CByFJI8X.js';
+export { C as CommandEvent, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, j as SandboxOptionsBase, k as SandboxOptionsMap, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec, V as VercelGitSource, p as VercelProviderOptions, q as VercelSandboxOptions } from '../Sandbox-CByFJI8X.js';
+export { SandboxProvider } from '../enums.js';
 import 'e2b';
+import '@vercel/sandbox';
 import '@daytonaio/sdk';
 import 'modal';
 import 'dockerode';
@@ -11,6 +13,13 @@ declare abstract class SandboxAdapter<TProvider extends SandboxProviderName = Sa
     protected readonly baseEnv: Record<string, string>;
     private provisioned;
     private provisioning?;
+    /**
+     * Whether `provision()` warm-attached to a pre-existing tagged sandbox
+     * (true) or had to create a fresh one (false). Set by adapter
+     * `provision()` implementations. Stays `false` until `findOrProvision()`
+     * has resolved.
+     */
+    protected wasFoundFlag: boolean;
     constructor(options: TOptions);
     abstract get provider(): TProvider;
     abstract get raw(): TRaw | undefined;
@@ -24,9 +33,54 @@ declare abstract class SandboxAdapter<TProvider extends SandboxProviderName = Sa
     abstract delete(): Promise<void>;
     abstract openPort(port: number): Promise<void>;
     abstract getPreviewLink(port: number): Promise<string>;
-    protected ensureProvisioned(): Promise<void>;
+    uploadFile(_content: Buffer | string, _targetPath: string): Promise<void>;
+    downloadFile(_sourcePath: string): Promise<Buffer>;
+    /**
+     * Upload a tarball of files into the sandbox and execute a command in
+     * the same round-trip. Used by setup paths that would otherwise need one
+     * sandbox RPC per file plus another to run the install script — Modal-
+     * style providers pay ~700ms per RPC, so collapsing N+1 calls into one
+     * is the single biggest win on cold setup.
+     *
+     * Default implementation falls back to `uploadFile` per entry + a final
+     * `run`. Providers that support stdin streaming (Modal) override this to
+     * do the upload + extract + exec in a single sandbox `exec` call.
+     */
+    uploadAndRun(files: TarballEntry[], command: string, options?: CommandOptions): Promise<CommandResult>;
+    /**
+     * Public hook that callers must invoke before they touch the sandbox
+     * (running commands, cloning repos, uploading files, opening preview
+     * links, …). It either attaches to an existing tagged sandbox or creates
+     * a new one. The result is cached so repeated calls are cheap.
+     *
+     * Provisioning is no longer triggered implicitly by `run`, `runAsync`,
+     * `gitClone`, `uploadAndRun`, etc. Those methods now throw a clear error
+     * when the adapter has not been provisioned yet, which makes the
+     * lifecycle explicit and gives callers control over when the
+     * (potentially slow) sandbox attach / create happens.
+     */
+    findOrProvision(): Promise<void>;
+    /**
+     * Throw a consistent error when a method that needs a provisioned
+     * sandbox is called before `findOrProvision()`. Provider adapters call
+     * this at the top of `run`, `runAsync`, `uploadFile`, etc.
+     */
+    protected requireProvisioned(): void;
     get tags(): Record<string, string>;
     get workingDir(): string;
+    /**
+     * Whether `findOrProvision()` warm-attached to a pre-existing tagged
+     * sandbox (`true`) or created a fresh one (`false`). Useful to skip
+     * idempotent setup that the previous run already performed (e.g.
+     * `agent.setup()`). Always `false` before `findOrProvision()` resolves.
+     */
+    get wasFound(): boolean;
+    /**
+     * Headers that callers should attach to HTTP / WebSocket requests they make
+     * against this sandbox's preview URL. Default is empty; providers like
+     * Vercel override this to inject Deployment Protection bypass tokens.
+     */
+    get previewHeaders(): Record<string, string>;
     getMergedEnv(extra?: Record<string, string>): Record<string, string>;
     setSecret(name: string, value: string): void;
     setSecrets(values: Record<string, string>): void;
@@ -35,4 +89,4 @@ declare abstract class SandboxAdapter<TProvider extends SandboxProviderName = Sa
 
 declare function buildGitCloneCommand(options: GitCloneOptions): string;
 
-export { AsyncCommandHandle, CommandOptions, CommandResult, GitCloneOptions, SandboxAdapter, SandboxDescriptor, SandboxListOptions, SandboxOptions, SandboxProviderName, buildGitCloneCommand };
+export { AsyncCommandHandle, CommandOptions, CommandResult, GitCloneOptions, SandboxAdapter, SandboxDescriptor, SandboxListOptions, SandboxOptions, SandboxProviderName, TarballEntry, buildGitCloneCommand };

package/dist/sandboxes/index.js

@@ -2,11 +2,15 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "../chunk-QRQFQTGH.js";
-import "../chunk-HMBWQSVN.js";
-import "../chunk-JFDP556Q.js";
+} from "../chunk-LPKKT6YT.js";
+import "../chunk-INMA52FV.js";
+import "../chunk-NSJM57Z4.js";
+import {
+  SandboxProvider
+} from "../chunk-GOFJNFAD.js";
 export {
   Sandbox,
   SandboxAdapter,
+  SandboxProvider,
   buildGitCloneCommand
 };

package/dist/{types-BwcoN0n-.d.ts → types-B3N-Qo2q.d.ts}

@@ -1,4 +1,5 @@
-import { S as Sandbox } from './Sandbox-DTprxRZf.js';
+import { AgentProvider } from './enums.js';
+import { S as Sandbox } from './Sandbox-CByFJI8X.js';
 
 interface RawAgentEvent<TPayload = unknown> {
     provider: string;
@@ -22,10 +23,24 @@ interface RunStartedEvent extends NormalizedAgentEventBase {
 }
 interface MessageStartedEvent extends NormalizedAgentEventBase {
     type: "message.started";
+    /**
+     * Provider-assigned identifier for the user message that started this turn.
+     * Opaque to callers.
+     *
+     * - claude-code: the user message UUID written to the session JSONL
+     * - codex: the turn id from `turn/started`
+     * - open-code: the message id from `message.updated` (role=user)
+     */
+    messageId?: string;
 }
 interface MessageInjectedEvent extends NormalizedAgentEventBase {
     type: "message.injected";
     content: string;
+    /**
+     * Provider-assigned identifier for the injected user message. See
+     * `MessageStartedEvent.messageId` for provider-specific semantics.
+     */
+    messageId?: string;
 }
 interface TextDeltaEvent extends NormalizedAgentEventBase {
     type: "text.delta";
@@ -71,6 +86,12 @@ interface PermissionResolvedEvent extends NormalizedAgentEventBase {
 interface MessageCompletedEvent extends NormalizedAgentEventBase {
     type: "message.completed";
     text?: string;
+    /**
+     * Provider-assigned identifier for the assistant message that just
+     * completed. Format mirrors `MessageStartedEvent.messageId` but identifies
+     * the assistant turn rather than the user one.
+     */
+    messageId?: string;
 }
 interface RunCompletedEvent extends NormalizedAgentEventBase {
     type: "run.completed";
@@ -260,7 +281,7 @@ interface AgentCommandConfig {
     subtask?: boolean;
 }
 
-type AgentProviderName = "codex" | "opencode" | "claude-code";
+type AgentProviderName = AgentProvider;
 type DataContent = string | URL | Uint8Array | ArrayBuffer | Buffer;
 interface TextPart {
     type: "text";
@@ -279,12 +300,23 @@ interface FilePart {
 }
 type UserContentPart = TextPart | ImagePart | FilePart;
 type UserContent = string | UserContentPart[];
+type AgentReasoningEffort = "low" | "medium" | "high" | "xhigh";
 interface AgentRunConfig {
     input: UserContent;
+    runId?: string;
     model?: string;
     systemPrompt?: string;
     resumeSessionId?: string;
-}
+    reasoning?: AgentReasoningEffort;
+}
+/**
+ * Subset of {@link AgentRunConfig} that needs to be committed at
+ * `agent.setup()` time so the runtime can pre-bake artifacts that
+ * reference it (codex `model_instructions_file`, opencode agent config,
+ * etc.). Unlike `AgentRunConfig`, this never carries per-turn input or
+ * a resumed session id.
+ */
+type AgentSetupConfig = Pick<AgentRunConfig, "systemPrompt" | "model" | "reasoning">;
 type AgentApprovalMode = "auto" | "interactive";
 type AgentPermissionKind = "bash" | "edit" | "tool" | "network" | "file-change" | "unknown";
 type AgentPermissionDecision = "allow" | "deny";
@@ -309,6 +341,14 @@ interface CodexProviderOptions {
     brokerEndpoint?: string;
     useBroker?: boolean;
     hooks?: CodexHooksConfig;
+    /**
+     * When `false`, writes `supports_websockets = false` into Codex's
+     * config.toml. Useful in environments where outbound WebSocket
+     * connections from the Codex CLI aren't available (proxies, network
+     * policies). When `true` or omitted, no key is emitted and Codex
+     * uses its built-in default.
+     */
+    supportsWebsockets?: boolean;
 }
 interface OpenCodeProviderOptions {
     binary?: string;
@@ -335,10 +375,22 @@ interface ClaudeCodeAgentOptions extends AgentOptionsBase {
 }
 type AgentOptionsMap = {
     codex: CodexAgentOptions;
-    opencode: OpenCodeAgentOptions;
+    "open-code": OpenCodeAgentOptions;
     "claude-code": ClaudeCodeAgentOptions;
 };
 type AgentOptions<P extends AgentProviderName = AgentProviderName> = AgentOptionsMap[P];
+interface AgentCostData {
+    total_cost_usd?: number;
+    duration_ms?: number;
+    duration_api_ms?: number;
+    num_turns?: number;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    };
+}
 interface AgentResult {
     id: string;
     provider: AgentProviderName;
@@ -346,6 +398,7 @@ interface AgentResult {
     text: string;
     rawEvents: RawAgentEvent[];
     events: NormalizedAgentEvent[];
+    costData?: AgentCostData | null;
 }
 interface AgentRun extends AsyncIterable<NormalizedAgentEvent> {
     id: string;
@@ -367,20 +420,108 @@ interface AgentRunSink {
     emitRaw(event: RawAgentEvent): void;
     emitEvent(event: NormalizedAgentEvent): void;
     requestPermission(event: PermissionRequestedEvent): Promise<AgentPermissionResponse>;
-    onMessage(handler: (content: UserContent) => Promise<void>): void;
+    onMessage(handler: (content: UserContent) => Promise<{
+        messageId?: string;
+    } | void>): void;
     complete(result?: {
         text?: string;
+        costData?: AgentCostData | null;
     }): void;
     fail(error: unknown): void;
 }
+interface AgentSetupRequest<P extends AgentProviderName = AgentProviderName> {
+    provider: P;
+    options: AgentOptions<P>;
+    config: AgentSetupConfig;
+}
 interface AgentExecutionRequest<P extends AgentProviderName = AgentProviderName> {
     runId: string;
     provider: P;
     options: AgentOptions<P>;
     run: AgentRunConfig;
 }
+/**
+ * Stateless attach request used by {@link Agent.attach} to issue control
+ * commands (abort, sendMessage) against a run that lives on a different
+ * Twill instance.
+ *
+ * The attach call dials the in-sandbox provider server directly via
+ * `sandbox.getPreviewLink(...)` — no shared in-memory state, no broker.
+ * The originating instance still owns the run's event stream and reacts
+ * naturally to whatever the provider emits as a consequence of the
+ * attached command (e.g. `turn/aborted` for codex, message events for
+ * claude-code/opencode).
+ */
+interface AgentAttachRequest<P extends AgentProviderName = AgentProviderName> {
+    provider: P;
+    sandbox: Sandbox;
+    /**
+     * The {@link AgentRunConfig.runId} the originating instance used in
+     * `agent.stream({ runId, ... })`. Required for claude-code (the relay
+     * keys channels by runId) and useful as an idempotency / log id for
+     * the other providers.
+     */
+    runId: string;
+    /**
+     * Provider-native session id captured from {@link AgentRun.sessionIdReady}.
+     *
+     * - codex: the threadId
+     * - opencode: the sessionId
+     * - claude-code: the claude session uuid (optional — runId is the
+     *   primary key inside the relay)
+     */
+    sessionId?: string;
+    /**
+     * Codex only: the in-flight turn id, captured by the originating
+     * caller from the {@link NormalizedAgentEvent} `message.started`
+     * event (whose `messageId` is the codex turnId). `attachAbort` uses
+     * it for `turn/interrupt`. When omitted the codex attach is a no-op.
+     *
+     * The SDK does not persist this itself — bookkeeping it across
+     * processes is the caller's responsibility (e.g. Redis), since
+     * sandbox-side files don't compose well under concurrency.
+     */
+    turnId?: string;
+}
+/**
+ * Thin handle returned by {@link Agent.attach}. Methods are short-lived:
+ * each call opens a fresh transport to the in-sandbox server, performs
+ * the operation, and tears the transport down. There is no "close" —
+ * the handle holds no resources between calls.
+ */
+interface AttachedRun {
+    abort(): Promise<void>;
+    sendMessage(content: UserContent): Promise<void>;
+}
 interface AgentProviderAdapter<P extends AgentProviderName = AgentProviderName> {
+    /**
+     * Sandbox-side preparation work that does not depend on per-run input:
+     * upload artifacts (skills/commands/mcp/hook config), boot any
+     * provider server / relay the run will need.
+     *
+     * Required before {@link AgentProviderAdapter.execute} for sandbox-backed
+     * runs. {@link execute} does not read any setup output and does not
+     * re-do this work — it assumes the relay/server is up and dials it
+     * directly. If `setup` was never called against a remote sandbox the
+     * connect retry inside `execute` fails naturally.
+     *
+     * Idempotent: `applyDifferentialSetup` short-circuits unchanged
+     * artifacts, and the relay/server probes short-circuit when something
+     * is already listening.
+     */
+    setup(request: AgentSetupRequest<P>): Promise<void>;
     execute(request: AgentExecutionRequest<P>, sink: AgentRunSink): Promise<() => Promise<void> | void>;
+    /**
+     * Stateless abort. Dial the in-sandbox provider server, issue the
+     * provider's "interrupt the in-flight turn" primitive, close.
+     */
+    attachAbort(request: AgentAttachRequest<P>): Promise<void>;
+    /**
+     * Stateless message injection. Dial the in-sandbox provider server,
+     * append `content` as a new user turn against the existing session,
+     * close.
+     */
+    attachSendMessage(request: AgentAttachRequest<P>, content: UserContent): Promise<void>;
 }
 
-export { type RepoSkillConfig as $, type AISDKEvent as A, type CodexAgentOptions as B, type ClaudeCodeAgentOptions as C, type CodexCommandHook as D, type CodexHookEvent as E, type CodexHookMatcherGroup as F, type CodexHooksConfig as G, type CodexProviderOptions as H, type DataContent as I, type EmbeddedSkillConfig as J, type FilePart as K, type ImagePart as L, type MessageCompletedEvent as M, type MessageInjectedEvent as N, type MessageStartedEvent as O, type NormalizedAgentEvent as P, type NormalizedAgentEventBase as Q, type NormalizedAgentEventType as R, type OpenCodeAgentOptions as S, type OpenCodePluginConfig as T, type OpenCodePluginEvent as U, type OpenCodePluginHookConfig as V, type OpenCodeProviderOptions as W, type PermissionRequestedEvent as X, type PermissionResolvedEvent as Y, type RawAgentEvent as Z, type ReasoningDeltaEvent as _, type AgentApprovalMode as a, type RunCompletedEvent as a0, type RunErrorEvent as a1, type RunStartedEvent as a2, type TextDeltaEvent as a3, type TextPart as a4, type ToolCallCompletedEvent as a5, type ToolCallDeltaEvent as a6, type ToolCallStartedEvent as a7, type UserContent as a8, type UserContentPart as a9, createNormalizedEvent as aa, normalizeRawAgentEvent as ab, toAISDKEvent as ac, toAISDKStream as ad, type AgentCommandConfig as b, type AgentExecutionRequest as c, type AgentLocalMcpConfig as d, type AgentMcpConfig as e, type AgentOptions as f, type AgentOptionsBase as g, type AgentOptionsMap as h, type AgentPermissionDecision as i, type AgentPermissionKind as j, type AgentPermissionResponse as k, type AgentProviderAdapter as l, type AgentProviderName as m, type AgentRemoteMcpConfig as n, type AgentResult as o, type AgentRun as p, type AgentRunConfig as q, type AgentRunSink as r, type AgentSkillConfig as s, type AgentSubAgentConfig as t, type ClaudeCodeHookConfig as u, type ClaudeCodeHookEvent as v, type ClaudeCodeHookHandler as w, type ClaudeCodeHookMatcherGroup as x, type ClaudeCodeHooksConfig as y, type ClaudeCodeProviderOptions as z };
+export { type OpenCodePluginHookConfig as $, type AISDKEvent as A, type ClaudeCodeHookConfig as B, type ClaudeCodeAgentOptions as C, type ClaudeCodeHookEvent as D, type ClaudeCodeHookHandler as E, type ClaudeCodeHookMatcherGroup as F, type ClaudeCodeHooksConfig as G, type ClaudeCodeProviderOptions as H, type CodexAgentOptions as I, type CodexCommandHook as J, type CodexHookEvent as K, type CodexHookMatcherGroup as L, type CodexHooksConfig as M, type CodexProviderOptions as N, type DataContent as O, type EmbeddedSkillConfig as P, type FilePart as Q, type ImagePart as R, type MessageCompletedEvent as S, type MessageInjectedEvent as T, type MessageStartedEvent as U, type NormalizedAgentEvent as V, type NormalizedAgentEventBase as W, type NormalizedAgentEventType as X, type OpenCodeAgentOptions as Y, type OpenCodePluginConfig as Z, type OpenCodePluginEvent as _, type AgentApprovalMode as a, type OpenCodeProviderOptions as a0, type PermissionRequestedEvent as a1, type PermissionResolvedEvent as a2, type RawAgentEvent as a3, type ReasoningDeltaEvent as a4, type RepoSkillConfig as a5, type RunCompletedEvent as a6, type RunErrorEvent as a7, type RunStartedEvent as a8, type TextDeltaEvent as a9, type TextPart as aa, type ToolCallCompletedEvent as ab, type ToolCallDeltaEvent as ac, type ToolCallStartedEvent as ad, type UserContent as ae, type UserContentPart as af, createNormalizedEvent as ag, normalizeRawAgentEvent as ah, toAISDKEvent as ai, toAISDKStream as aj, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupConfig as v, type AgentSetupRequest as w, type AgentSkillConfig as x, type AgentSubAgentConfig as y, type AttachedRun as z };

package/images/browser-agent.mjs

@@ -43,13 +43,13 @@ export default {
   run: [
     `apt-get update && apt-get install -y --no-install-recommends ${aptPackages.join(" ")} && rm -rf /var/lib/apt/lists/*`,
     "npm cache clean --force",
-    "npm install -g pnpm @anthropic-ai/claude-code @openai/codex opencode-ai agent-browser",
+    "npm install -g pnpm @anthropic-ai/claude-code @anthropic-ai/claude-agent-sdk @anthropic-ai/claude-agent-sdk @openai/codex opencode-ai agent-browser",
     "agent-browser set viewport 1980 1080",
   ],
   workdir: "/workspace",
   cmd: ["sleep", "infinity"],
   resources: {
-    cpu: 4,
-    memoryMiB: 8192,
+    cpu: 1,
+    memoryMiB: 1024,
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {
@@ -33,10 +33,15 @@
     "./events": {
       "types": "./dist/events/index.d.ts",
       "import": "./dist/events/index.js"
+    },
+    "./enums": {
+      "types": "./dist/enums.d.ts",
+      "import": "./dist/enums.js"
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts src/agents/index.ts src/sandboxes/index.ts src/events/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/enums.ts src/agents/index.ts src/sandboxes/index.ts src/events/index.ts src/cli.ts --format esm --dts --clean --watch",
+    "build": "tsup src/index.ts src/enums.ts src/agents/index.ts src/sandboxes/index.ts src/events/index.ts src/cli.ts --format esm --dts --clean",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --max-warnings=0",
     "lint:fix": "eslint . --fix",
@@ -46,14 +51,18 @@
     "test:watch": "vitest",
     "check": "npm run typecheck && npm run lint && npm run test",
     "hooks:install": "lefthook install",
-    "prepare": "if [ -d .git ]; then lefthook install; else echo 'Skipping lefthook install (no .git directory)'; fi"
+    "prepare": "if [ -n \"$CI\" ] || [ ! -d .git ]; then echo 'Skipping lefthook install (CI or no .git directory)'; else lefthook install || echo 'Skipping lefthook install (binary unavailable)'; fi"
   },
   "engines": {
     "node": ">=20.0.0",
     "bun": ">=1.1.0"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.123",
     "@daytonaio/sdk": "^0.161.0",
+    "@types/debug": "^4.1.13",
+    "@vercel/sandbox": "2.0.0-beta.13",
+    "debug": "^4.4.3",
     "dockerode": "^4.0.10",
     "e2b": "^2.19.0",
     "eventsource-parser": "^3.0.6",
@@ -87,6 +96,7 @@
     "modal",
     "daytona",
     "docker",
+    "vercel",
     "typescript",
     "bun"
   ]

package/dist/chunk-7FLLQJ6J.js

@@ -1,185 +0,0 @@
-// src/events/normalized.ts
-function createNormalizedEvent(type, base, extra) {
-  return {
-    type,
-    provider: base.provider,
-    runId: base.runId,
-    timestamp: base.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-    raw: base.raw,
-    meta: base.meta,
-    ...extra ?? {}
-  };
-}
-function normalizeRawAgentEvent(event) {
-  const payload = event.payload;
-  const common = {
-    provider: event.provider,
-    runId: event.runId,
-    raw: event,
-    timestamp: event.timestamp
-  };
-  if (event.type === "assistant" && Array.isArray(
-    payload?.message?.content
-  )) {
-    const blocks = (payload?.message).content;
-    const text = blocks.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("");
-    return [
-      createNormalizedEvent("message.started", common),
-      ...text ? [createNormalizedEvent("text.delta", common, { delta: text })] : [],
-      createNormalizedEvent("message.completed", common, { text }),
-      createNormalizedEvent("run.completed", common, { text })
-    ];
-  }
-  if (event.type.includes("delta")) {
-    const delta = String(
-      payload?.delta ?? payload?.text ?? payload?.["content"] ?? ""
-    );
-    const normalizedType = event.type.includes("reasoning") ? "reasoning.delta" : "text.delta";
-    return [createNormalizedEvent(normalizedType, common, { delta })];
-  }
-  if (event.type.includes("tool")) {
-    const toolName = String(payload?.toolName ?? payload?.tool_name ?? "tool");
-    if (event.type.includes("completed") || event.type.includes("summary")) {
-      return [
-        createNormalizedEvent("tool.call.completed", common, {
-          toolName,
-          callId: payload?.callId ?? payload?.tool_use_id,
-          output: payload?.output ?? payload?.result
-        })
-      ];
-    }
-    return [
-      createNormalizedEvent("tool.call.started", common, {
-        toolName,
-        callId: payload?.callId ?? payload?.tool_use_id,
-        input: payload?.input
-      })
-    ];
-  }
-  if (event.type === "result") {
-    const text = String(payload?.result ?? payload?.text ?? "");
-    return [createNormalizedEvent("run.completed", common, { text })];
-  }
-  if (event.type === "error") {
-    return [
-      createNormalizedEvent("run.error", common, {
-        error: String(
-          payload?.message ?? payload?.error ?? "Unknown agent error"
-        )
-      })
-    ];
-  }
-  return [];
-}
-
-// src/events/ai-sdk.ts
-function toAISDKEvent(event) {
-  switch (event.type) {
-    case "run.started":
-      return {
-        type: "response-start",
-        id: event.runId,
-        provider: event.provider
-      };
-    case "message.injected":
-      return {
-        type: "message-injected",
-        id: event.runId,
-        provider: event.provider,
-        content: event.content
-      };
-    case "text.delta":
-      return {
-        type: "text-delta",
-        id: event.runId,
-        provider: event.provider,
-        textDelta: event.delta
-      };
-    case "reasoning.delta":
-      return {
-        type: "reasoning-delta",
-        id: event.runId,
-        provider: event.provider,
-        textDelta: event.delta
-      };
-    case "tool.call.started":
-      return {
-        type: "tool-input-start",
-        id: event.runId,
-        provider: event.provider,
-        toolName: event.toolName,
-        callId: event.callId
-      };
-    case "tool.call.delta":
-      return {
-        type: "tool-input-delta",
-        id: event.runId,
-        provider: event.provider,
-        toolName: event.toolName,
-        callId: event.callId,
-        inputTextDelta: event.delta
-      };
-    case "tool.call.completed":
-      return {
-        type: "tool-output-available",
-        id: event.runId,
-        provider: event.provider,
-        toolName: event.toolName,
-        callId: event.callId,
-        output: event.output
-      };
-    case "permission.requested":
-      return {
-        type: "permission-requested",
-        id: event.runId,
-        provider: event.provider,
-        requestId: event.requestId,
-        kind: event.kind,
-        title: event.title,
-        message: event.message,
-        input: event.input,
-        canRemember: event.canRemember
-      };
-    case "permission.resolved":
-      return {
-        type: "permission-resolved",
-        id: event.runId,
-        provider: event.provider,
-        requestId: event.requestId,
-        decision: event.decision,
-        remember: event.remember
-      };
-    case "message.completed":
-    case "run.completed":
-      return {
-        type: "response-finish",
-        id: event.runId,
-        provider: event.provider,
-        text: event.text
-      };
-    case "run.error":
-      return {
-        type: "response-error",
-        id: event.runId,
-        provider: event.provider,
-        error: event.error
-      };
-    default:
-      return null;
-  }
-}
-async function* toAISDKStream(events) {
-  for await (const event of events) {
-    const mapped = toAISDKEvent(event);
-    if (mapped) {
-      yield mapped;
-    }
-  }
-}
-
-export {
-  createNormalizedEvent,
-  normalizeRawAgentEvent,
-  toAISDKEvent,
-  toAISDKStream
-};