coding-agents-sdk 0.0.1 → 0.3.0

package/dist/index-DNyKelMh.d.mts

@@ -0,0 +1,39 @@
+import { D as ProcessSpawner, f as EnsureDisjoint, l as BaseAgent, p as ExclusiveExecutionTargetOptions, t as AgentEventHandler } from "./types-COlDAzs5.mjs";
+import { t as Container } from "./index-R77YR8ak.mjs";
+import { i as Sandbox } from "./index-DCaZeLrI.mjs";
+import { z } from "zod/v4";
+
+//#region src/adapters/gemini-cli/events/schemas.d.ts
+declare const geminiEventSchema: z.ZodObject<{
+  type: z.ZodString;
+}, z.core.$loose>;
+type GeminiEvent = z.infer<typeof geminiEventSchema>;
+//#endregion
+//#region src/adapters/gemini-cli/types.d.ts
+type GeminiCliPermissionMode = "default" | "full";
+interface GeminiCliRunOptions {
+  allowedTools?: string[];
+  disallowedTools?: string[];
+  permissionMode?: GeminiCliPermissionMode;
+  extraArgs?: string[];
+}
+type GeminiCliAgentOptions = ExclusiveExecutionTargetOptions<Container, Sandbox> & GeminiCliRunOptions & {
+  command?: string[] | string;
+  cwd?: string;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  sessionId?: string;
+  model?: string;
+  systemPrompt?: string;
+  logPath?: string;
+  spawner?: ProcessSpawner;
+  onEvent?: AgentEventHandler;
+};
+interface GeminiCliAgent extends BaseAgent<EnsureDisjoint<GeminiCliRunOptions>> {
+  readonly type: "gemini-cli";
+}
+//#endregion
+//#region src/adapters/gemini-cli/adapter.d.ts
+declare const createGeminiCliAgent: (options?: GeminiCliAgentOptions) => GeminiCliAgent;
+//#endregion
+export { GeminiCliRunOptions as a, GeminiCliPermissionMode as i, GeminiCliAgent as n, GeminiEvent as o, GeminiCliAgentOptions as r, createGeminiCliAgent as t };

package/dist/index-DP4Jxoax.d.mts

@@ -0,0 +1,110 @@
+import { S as McpServerConfig } from "./events-D31_b0sA.mjs";
+import { D as ProcessSpawner, f as EnsureDisjoint, l as BaseAgent, p as ExclusiveExecutionTargetOptions, t as AgentEventHandler } from "./types-COlDAzs5.mjs";
+import { t as Container } from "./index-R77YR8ak.mjs";
+import { i as Sandbox } from "./index-DCaZeLrI.mjs";
+import { z } from "zod/v4";
+
+//#region src/adapters/codex-cli/events/schemas.d.ts
+declare const codexEventSchema: z.ZodObject<{
+  type: z.ZodString;
+}, z.core.$loose>;
+type CodexEvent = z.infer<typeof codexEventSchema>;
+declare const codexThreadStartedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"thread.started">;
+  thread_id: z.ZodString;
+}, z.core.$loose>;
+type CodexThreadStartedEvent = z.infer<typeof codexThreadStartedEventSchema>;
+declare const codexTurnCompletedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"turn.completed">;
+  usage: z.ZodOptional<z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+    total_tokens: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+  last_agent_message: z.ZodOptional<z.ZodString>;
+  duration_ms: z.ZodOptional<z.ZodNumber>;
+  num_turns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+type CodexTurnCompletedEvent = z.infer<typeof codexTurnCompletedEventSchema>;
+declare const codexTurnFailedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"turn.failed">;
+  usage: z.ZodOptional<z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+    total_tokens: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+  last_agent_message: z.ZodOptional<z.ZodString>;
+  duration_ms: z.ZodOptional<z.ZodNumber>;
+  num_turns: z.ZodOptional<z.ZodNumber>;
+  message: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+type CodexTurnFailedEvent = z.infer<typeof codexTurnFailedEventSchema>;
+declare const codexItemStartedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"item.started">;
+  item: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type CodexItemStartedEvent = z.infer<typeof codexItemStartedEventSchema>;
+declare const codexItemUpdatedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"item.updated">;
+  item: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type CodexItemUpdatedEvent = z.infer<typeof codexItemUpdatedEventSchema>;
+declare const codexItemCompletedEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"item.completed">;
+  item: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type CodexItemCompletedEvent = z.infer<typeof codexItemCompletedEventSchema>;
+declare const codexErrorEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"error">;
+  message: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+type CodexErrorEvent = z.infer<typeof codexErrorEventSchema>;
+//#endregion
+//#region src/adapters/codex-cli/types.d.ts
+type CodexCliSandboxMode = "danger-full-access" | "read-only" | "workspace-write";
+type CodexCliPermissionMode = "default" | "full-access" | "full-auto";
+interface CodexCliRunOptions {
+  codexSandboxMode?: CodexCliSandboxMode;
+  additionalDirectories?: string[];
+  skipGitRepoCheck?: boolean;
+  permissionMode?: CodexCliPermissionMode;
+  ephemeral?: boolean;
+  mcpConfig?: string;
+  mcpServers?: Record<string, McpServerConfig>;
+  extraArgs?: string[];
+  systemPrompt?: never;
+}
+type CodexCliAgentOptions = CodexCliRunOptions & ExclusiveExecutionTargetOptions<Container, Sandbox> & {
+  command?: string[] | string;
+  cwd?: string;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  sessionId?: string;
+  model?: string;
+  logPath?: string;
+  spawner?: ProcessSpawner;
+  onEvent?: AgentEventHandler;
+};
+interface CodexCliAgent extends BaseAgent<EnsureDisjoint<CodexCliRunOptions>> {
+  readonly type: "codex-cli";
+}
+//#endregion
+//#region src/adapters/codex-cli/adapter.d.ts
+declare const createCodexCliAgent: (options?: CodexCliAgentOptions) => CodexCliAgent;
+//#endregion
+export { CodexCliRunOptions as a, CodexEvent as c, CodexItemUpdatedEvent as d, CodexThreadStartedEvent as f, CodexCliPermissionMode as i, CodexItemCompletedEvent as l, CodexTurnFailedEvent as m, CodexCliAgent as n, CodexCliSandboxMode as o, CodexTurnCompletedEvent as p, CodexCliAgentOptions as r, CodexErrorEvent as s, createCodexCliAgent as t, CodexItemStartedEvent as u };

package/dist/index-R77YR8ak.d.mts

@@ -0,0 +1,224 @@
+import { D as ProcessSpawner } from "./types-COlDAzs5.mjs";
+
+//#region src/container/types.d.ts
+type ContainerType = "docker" | "e2b" | "podman";
+interface PortMapping {
+  container: number;
+  host?: number;
+  protocol?: "tcp" | "udp";
+}
+interface VolumeMount {
+  source: string;
+  target: string;
+  readonly?: boolean;
+}
+interface ContainerConfigBase<TType extends ContainerType> {
+  type: TType;
+  workdir: string;
+  name?: string;
+  env?: Record<string, string>;
+}
+interface ExecOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+interface ExecResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+type ContainerStatus = "created" | "disposed" | "running" | "stopped";
+type WorkdirChangeKind = "added" | "deleted" | "modified" | "renamed";
+interface WorkdirSnapshotOptions {
+  cwd?: string;
+}
+interface WorkdirSnapshot {
+  readonly cwd: string;
+  readonly createdAt: Date;
+}
+interface WorkdirFileChange {
+  readonly path: string;
+  readonly previousPath?: string;
+  readonly kind: WorkdirChangeKind;
+  readonly beforeHash?: string;
+  readonly afterHash?: string;
+  readonly beforeSize?: number;
+  readonly afterSize?: number;
+}
+interface WorkdirDiffStats {
+  readonly durationMs: number;
+  readonly filesCompared: number;
+}
+interface WorkdirDiff {
+  readonly cwd: string;
+  readonly changedFiles: readonly string[];
+  readonly fileChanges: readonly WorkdirFileChange[];
+  readonly stats: WorkdirDiffStats;
+}
+interface ContainerIdentity<TType extends ContainerType, TConfig extends ContainerConfigBase<TType>> {
+  readonly type: TType;
+  readonly id: string;
+  readonly name: string;
+  readonly config: TConfig;
+  readonly status: ContainerStatus;
+  readonly workdir: string;
+}
+interface ContainerLifecycle {
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  dispose: () => Promise<void>;
+  [Symbol.asyncDispose]: () => Promise<void>;
+}
+interface ContainerExecution {
+  exec: (command: string, args: string[], options?: ExecOptions) => Promise<ExecResult>;
+  execShell: (script: string, options?: ExecOptions) => Promise<ExecResult>;
+  readonly spawner: ProcessSpawner;
+}
+interface ContainerFileSystem {
+  copyTo: (hostPath: string, containerPath: string) => Promise<void>;
+  copyFrom: (containerPath: string, hostPath: string) => Promise<void>;
+  writeFile: (path: string, content: Uint8Array | string) => Promise<void>;
+  readFile: (path: string) => Promise<string>;
+  fileExists: (path: string) => Promise<boolean>;
+  mkdir: (path: string) => Promise<void>;
+}
+interface ContainerObservability {
+  logs: (options?: {
+    tail?: number;
+  }) => Promise<string>;
+  syncStatus: () => Promise<ContainerStatus>;
+  snapshotWorkdir: (options?: WorkdirSnapshotOptions) => Promise<WorkdirSnapshot>;
+  diffWorkdir: (snapshot: WorkdirSnapshot) => Promise<WorkdirDiff>;
+  releaseWorkdirSnapshot: (snapshot: WorkdirSnapshot) => Promise<void>;
+}
+interface ContainerBase<TType extends ContainerType, TConfig extends ContainerConfigBase<TType>> extends ContainerExecution, ContainerFileSystem, ContainerIdentity<TType, TConfig>, ContainerLifecycle, ContainerObservability {}
+//#endregion
+//#region src/container/oci.d.ts
+interface OciBuildBase {
+  context?: string;
+  args?: Record<string, string>;
+  tag?: string;
+}
+type OciBuildConfig = OciBuildBase & ({
+  dockerfile: string;
+  content?: never;
+} | {
+  dockerfile?: never;
+  content: string;
+});
+interface OciProviderBase {
+  ports?: PortMapping[];
+  mounts?: VolumeMount[];
+  user?: string;
+  binary?: string;
+  extraArgs?: string[];
+  network?: string;
+  platform?: string;
+}
+type OciProviderConfig = OciProviderBase & ({
+  image: string;
+  build?: never;
+} | {
+  image?: never;
+  build: OciBuildConfig;
+});
+//#endregion
+//#region src/container/docker/types.d.ts
+type DockerBuildBase = OciBuildBase;
+type DockerBuildConfig = OciBuildConfig;
+type DockerContainerBase = OciProviderBase;
+type DockerProviderConfig = OciProviderConfig;
+type DockerContainerConfig = ContainerConfigBase<"docker"> & OciProviderConfig;
+interface DockerContainer extends ContainerBase<"docker", DockerContainerConfig> {
+  getMappedPort: (containerPort: number) => number | undefined;
+}
+//#endregion
+//#region src/container/e2b/types.d.ts
+interface E2BSandboxNetworkOptions {
+  allowOut?: string[];
+  denyOut?: string[];
+  allowPublicTraffic?: boolean;
+  maskRequestHost?: string;
+}
+interface E2BSandboxLifecycleOptions {
+  onTimeout: "kill" | "pause";
+  autoResume?: boolean;
+}
+interface E2BConnectionConfig {
+  apiKey?: string;
+  accessToken?: string;
+  domain?: string;
+  requestTimeoutMs?: number;
+  headers?: Record<string, string>;
+}
+interface E2BContainerBase extends E2BConnectionConfig {
+  user?: string;
+  timeoutMs?: number;
+}
+interface E2BCreateConfig extends E2BContainerBase {
+  sandboxId?: never;
+  template?: string;
+  metadata?: Record<string, string>;
+  secure?: boolean;
+  allowInternetAccess?: boolean;
+  network?: E2BSandboxNetworkOptions;
+  lifecycle?: E2BSandboxLifecycleOptions;
+}
+interface E2BConnectConfig extends E2BContainerBase {
+  sandboxId: string;
+  template?: never;
+  metadata?: never;
+  secure?: never;
+  allowInternetAccess?: never;
+  network?: never;
+  lifecycle?: never;
+}
+type E2BProviderConfig = E2BConnectConfig | E2BCreateConfig;
+type E2BContainerConfig = ContainerConfigBase<"e2b"> & E2BProviderConfig;
+interface E2BContainer extends ContainerBase<"e2b", E2BContainerConfig> {
+  getHost: (port: number) => string;
+}
+//#endregion
+//#region src/container/podman/types.d.ts
+type PodmanBuildBase = OciBuildBase;
+type PodmanBuildConfig = OciBuildConfig;
+type PodmanContainerBase = OciProviderBase;
+type PodmanProviderConfig = OciProviderConfig;
+type PodmanContainerConfig = ContainerConfigBase<"podman"> & OciProviderConfig;
+interface PodmanContainer extends ContainerBase<"podman", PodmanContainerConfig> {
+  getMappedPort: (containerPort: number) => number | undefined;
+}
+//#endregion
+//#region src/container/errors.d.ts
+declare class ContainerError extends Error {
+  constructor(message: string);
+}
+declare class ContainerCreateError extends ContainerError {
+  constructor(message: string);
+}
+declare class ContainerStartError extends ContainerError {
+  constructor(message: string);
+}
+declare class ContainerExecError extends ContainerError {
+  constructor(message: string);
+}
+declare class ContainerNotRunningError extends ContainerError {
+  constructor(message?: string);
+}
+declare class ContainerDisposedError extends ContainerError {
+  constructor(message?: string);
+}
+declare class ContainerDiffError extends ContainerError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/container/index.d.ts
+type ContainerConfig = DockerContainerConfig | E2BContainerConfig | PodmanContainerConfig;
+type Container = DockerContainer | E2BContainer | PodmanContainer;
+declare function createContainer(config: DockerContainerConfig): Promise<DockerContainer>;
+declare function createContainer(config: E2BContainerConfig): Promise<E2BContainer>;
+declare function createContainer(config: PodmanContainerConfig): Promise<PodmanContainer>;
+//#endregion
+export { ContainerBase as A, ExecResult as B, E2BProviderConfig as C, DockerContainerBase as D, DockerContainer as E, ContainerLifecycle as F, WorkdirDiffStats as G, VolumeMount as H, ContainerObservability as I, WorkdirSnapshotOptions as J, WorkdirFileChange as K, ContainerStatus as L, ContainerExecution as M, ContainerFileSystem as N, DockerContainerConfig as O, ContainerIdentity as P, ContainerType as R, E2BCreateConfig as S, DockerBuildConfig as T, WorkdirChangeKind as U, PortMapping as V, WorkdirDiff as W, E2BConnectConfig as _, ContainerDiffError as a, E2BContainerBase as b, ContainerExecError as c, PodmanBuildBase as d, PodmanBuildConfig as f, PodmanProviderConfig as g, PodmanContainerConfig as h, ContainerCreateError as i, ContainerConfigBase as j, DockerProviderConfig as k, ContainerNotRunningError as l, PodmanContainerBase as m, ContainerConfig as n, ContainerDisposedError as o, PodmanContainer as p, WorkdirSnapshot as q, createContainer as r, ContainerError as s, Container as t, ContainerStartError as u, E2BConnectionConfig as v, DockerBuildBase as w, E2BContainerConfig as x, E2BContainer as y, ExecOptions as z };

package/dist/index-jUwKDQ34.d.mts

@@ -0,0 +1,146 @@
+import { f as EnsureDisjoint, l as BaseAgent, t as AgentEventHandler } from "./types-COlDAzs5.mjs";
+//#region src/adapters/codex-sdk/types.d.ts
+type CodexSdkSandboxMode = "danger-full-access" | "read-only" | "workspace-write";
+type CodexSdkModelReasoningEffort = "high" | "low" | "medium" | "minimal" | "xhigh";
+type CodexSdkWebSearchMode = "cached" | "disabled" | "live";
+type CodexSdkConfigValue = CodexSdkConfigObject | CodexSdkConfigValue[] | boolean | number | string;
+type CodexSdkConfigObject = {
+  [key: string]: CodexSdkConfigValue;
+};
+type CodexSdkPermissionMode = "never" | "on-failure" | "on-request" | "untrusted";
+interface CodexSdkUsage {
+  input_tokens: number;
+  cached_input_tokens: number;
+  output_tokens: number;
+}
+interface CodexSdkCommandExecutionItem {
+  id: string;
+  type: "command_execution";
+  command: string;
+  aggregated_output: string;
+  exit_code?: number;
+  status: "completed" | "failed" | "in_progress";
+}
+interface CodexSdkFileUpdateChange {
+  path: string;
+  kind: "add" | "delete" | "update";
+}
+interface CodexSdkFileChangeItem {
+  id: string;
+  type: "file_change";
+  changes: CodexSdkFileUpdateChange[];
+  status: "completed" | "failed";
+}
+interface CodexSdkMcpToolCallItem {
+  id: string;
+  type: "mcp_tool_call";
+  server: string;
+  tool: string;
+  arguments: unknown;
+  result?: {
+    content: unknown[];
+    structured_content: unknown;
+  };
+  error?: {
+    message: string;
+  };
+  status: "completed" | "failed" | "in_progress";
+}
+interface CodexSdkAgentMessageItem {
+  id: string;
+  type: "agent_message";
+  text: string;
+}
+interface CodexSdkReasoningItem {
+  id: string;
+  type: "reasoning";
+  text: string;
+}
+interface CodexSdkWebSearchItem {
+  id: string;
+  type: "web_search";
+  query: string;
+}
+interface CodexSdkErrorItem {
+  id: string;
+  type: "error";
+  message: string;
+}
+interface CodexSdkTodoItem {
+  text: string;
+  completed: boolean;
+}
+interface CodexSdkTodoListItem {
+  id: string;
+  type: "todo_list";
+  items: CodexSdkTodoItem[];
+}
+interface CodexSdkThreadError {
+  message: string;
+}
+interface CodexSdkThreadStartedEvent {
+  type: "thread.started";
+  thread_id: string;
+}
+interface CodexSdkTurnStartedEvent {
+  type: "turn.started";
+}
+interface CodexSdkTurnCompletedEvent {
+  type: "turn.completed";
+  usage: CodexSdkUsage;
+}
+interface CodexSdkTurnFailedEvent {
+  type: "turn.failed";
+  error: CodexSdkThreadError;
+}
+interface CodexSdkItemStartedEvent {
+  type: "item.started";
+  item: CodexSdkItem;
+}
+interface CodexSdkItemUpdatedEvent {
+  type: "item.updated";
+  item: CodexSdkItem;
+}
+interface CodexSdkItemCompletedEvent {
+  type: "item.completed";
+  item: CodexSdkItem;
+}
+interface CodexSdkThreadErrorEvent {
+  type: "error";
+  message: string;
+}
+interface CodexSdkRunOptions {
+  permissionMode?: CodexSdkPermissionMode;
+  sandboxMode?: CodexSdkSandboxMode;
+  skipGitRepoCheck?: boolean;
+  modelReasoningEffort?: CodexSdkModelReasoningEffort;
+  networkAccessEnabled?: boolean;
+  webSearchMode?: CodexSdkWebSearchMode;
+  webSearchEnabled?: boolean;
+  additionalDirectories?: string[];
+  systemPrompt?: never;
+}
+interface CodexSdkAgentOptions extends CodexSdkRunOptions {
+  command?: string;
+  baseUrl?: string;
+  apiKey?: string;
+  config?: CodexSdkConfigObject;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  container?: never;
+  sandbox?: never;
+  cwd?: string;
+  sessionId?: string;
+  model?: string;
+  onEvent?: AgentEventHandler;
+}
+interface CodexSdkAgent extends BaseAgent<EnsureDisjoint<CodexSdkRunOptions>> {
+  readonly type: "codex-sdk";
+}
+type CodexSdkItem = CodexSdkAgentMessageItem | CodexSdkCommandExecutionItem | CodexSdkErrorItem | CodexSdkFileChangeItem | CodexSdkMcpToolCallItem | CodexSdkReasoningItem | CodexSdkTodoListItem | CodexSdkWebSearchItem;
+type CodexSdkEvent = CodexSdkItemCompletedEvent | CodexSdkItemStartedEvent | CodexSdkItemUpdatedEvent | CodexSdkThreadErrorEvent | CodexSdkThreadStartedEvent | CodexSdkTurnCompletedEvent | CodexSdkTurnFailedEvent | CodexSdkTurnStartedEvent;
+//#endregion
+//#region src/adapters/codex-sdk/adapter.d.ts
+declare const createCodexSdkAgent: (options?: CodexSdkAgentOptions) => CodexSdkAgent;
+//#endregion
+export { CodexSdkItem as a, CodexSdkEvent as i, CodexSdkAgent as n, CodexSdkPermissionMode as o, CodexSdkAgentOptions as r, CodexSdkRunOptions as s, createCodexSdkAgent as t };

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { C as OutputSchema, S as McpServerConfig, T as agentCapabilitiesSchema, a as SessionStartEvent, b as ImageContentPart, c as ToolResultEvent, i as SessionEndEvent, n as MessageEvent, o as StderrEvent, r as ReasoningEvent, s as ToolCallEvent, t as AgentEvent, u as eventSchema, v as AgentCapabilities, w as TextContentPart, x as JsonSchema, y as ContentPart } from "./events-D31_b0sA.mjs";
+import { C as RunTiming, E as ZodRunRequest, S as RunStatus, T as StructuredRunRequest, _ as RunProcessInfo, a as AgentValidationError, b as RunResultBase, c as AnyRunResult, d as CompletedRunResult, f as EnsureDisjoint, g as RunError, h as JsonSchemaRunRequest, i as AgentType, l as BaseAgent, m as FailedRunResult, n as AgentMetrics, o as AnyCompletedRunResult, r as AgentRunError, s as AnyRunRequest, t as AgentEventHandler, u as CancelledRunResult, v as RunRequest, w as StopReason, x as RunStats, y as RunResult } from "./types-COlDAzs5.mjs";
+import { A as ContainerBase, B as ExecResult, C as E2BProviderConfig, D as DockerContainerBase, E as DockerContainer, F as ContainerLifecycle, G as WorkdirDiffStats, H as VolumeMount, I as ContainerObservability, J as WorkdirSnapshotOptions, K as WorkdirFileChange, L as ContainerStatus, M as ContainerExecution, N as ContainerFileSystem, O as DockerContainerConfig, P as ContainerIdentity, R as ContainerType, S as E2BCreateConfig, T as DockerBuildConfig, U as WorkdirChangeKind, V as PortMapping, W as WorkdirDiff, _ as E2BConnectConfig, a as ContainerDiffError, b as E2BContainerBase, c as ContainerExecError, d as PodmanBuildBase, f as PodmanBuildConfig, g as PodmanProviderConfig, h as PodmanContainerConfig, i as ContainerCreateError, j as ContainerConfigBase, k as DockerProviderConfig, l as ContainerNotRunningError, m as PodmanContainerBase, n as ContainerConfig, o as ContainerDisposedError, p as PodmanContainer, q as WorkdirSnapshot, r as createContainer, s as ContainerError, t as Container, u as ContainerStartError, v as E2BConnectionConfig, w as DockerBuildBase, x as E2BContainerConfig, y as E2BContainer, z as ExecOptions } from "./index-R77YR8ak.mjs";
+import { a as SandboxBase, c as SandboxExecution, d as SandboxStatus, f as SandboxType, i as Sandbox, l as SandboxIdentity, n as BubblewrapSandbox, o as SandboxConfig, r as BubblewrapSandboxConfig, s as SandboxConfigBase, t as createSandbox, u as SandboxLifecycle } from "./index-DCaZeLrI.mjs";
+import { a as ClaudeCodeCliRunOptions, c as ClaudeRateLimitEvent, d as ClaudeUserEvent, i as ClaudeCodeCliPermissionMode, l as ClaudeResultEvent, n as ClaudeCodeCliAgent, o as ClaudeAssistantEvent, r as ClaudeCodeCliAgentOptions, s as ClaudeEvent, u as ClaudeSystemEvent } from "./index-COHwWTg_.mjs";
+import { a as ClaudeCodeSdkExecutable, c as ClaudeCodeSdkSettingSource, i as ClaudeCodeSdkEvent, l as ClaudeCodeSdkSettings, n as ClaudeCodeSdkAgent, o as ClaudeCodeSdkPermissionMode, r as ClaudeCodeSdkAgentOptions, s as ClaudeCodeSdkRunOptions } from "./index-CzvanLE_.mjs";
+import { a as CodexCliRunOptions, c as CodexEvent, d as CodexItemUpdatedEvent, f as CodexThreadStartedEvent, i as CodexCliPermissionMode, l as CodexItemCompletedEvent, m as CodexTurnFailedEvent, n as CodexCliAgent, o as CodexCliSandboxMode, p as CodexTurnCompletedEvent, r as CodexCliAgentOptions, s as CodexErrorEvent, u as CodexItemStartedEvent } from "./index-DP4Jxoax.mjs";
+import { a as CodexSdkItem, i as CodexSdkEvent, n as CodexSdkAgent, o as CodexSdkPermissionMode, r as CodexSdkAgentOptions, s as CodexSdkRunOptions } from "./index-jUwKDQ34.mjs";
+import { a as GeminiCliRunOptions, i as GeminiCliPermissionMode, n as GeminiCliAgent, o as GeminiEvent, r as GeminiCliAgentOptions } from "./index-DNyKelMh.mjs";
+//#region src/core/agent/create-agent.d.ts
+declare function createAgent(type: "claude-code-cli", options?: ClaudeCodeCliAgentOptions): Promise<ClaudeCodeCliAgent>;
+declare function createAgent(type: "claude-code-sdk", options?: ClaudeCodeSdkAgentOptions): Promise<ClaudeCodeSdkAgent>;
+declare function createAgent(type: "codex-cli", options?: CodexCliAgentOptions): Promise<CodexCliAgent>;
+declare function createAgent(type: "codex-sdk", options?: CodexSdkAgentOptions): Promise<CodexSdkAgent>;
+declare function createAgent(type: "gemini-cli", options?: GeminiCliAgentOptions): Promise<GeminiCliAgent>;
+//#endregion
+export { type AgentCapabilities, type AgentEvent, type AgentEventHandler, type AgentMetrics, AgentRunError, type AgentType, AgentValidationError, type AnyCompletedRunResult, type AnyRunRequest, type AnyRunResult, type BaseAgent, type BubblewrapSandbox, type BubblewrapSandboxConfig, type CancelledRunResult, type ClaudeAssistantEvent, type ClaudeCodeCliAgent, type ClaudeCodeCliAgentOptions, type ClaudeCodeCliPermissionMode, type ClaudeCodeCliRunOptions, type ClaudeCodeSdkAgent, type ClaudeCodeSdkAgentOptions, type ClaudeCodeSdkEvent, type ClaudeCodeSdkExecutable, type ClaudeCodeSdkPermissionMode, type ClaudeCodeSdkRunOptions, type ClaudeCodeSdkSettingSource, type ClaudeCodeSdkSettings, type ClaudeEvent, type ClaudeRateLimitEvent, type ClaudeResultEvent, type ClaudeSystemEvent, type ClaudeUserEvent, type CodexCliAgent, type CodexCliAgentOptions, type CodexCliPermissionMode, type CodexCliRunOptions, type CodexCliSandboxMode, type CodexErrorEvent, type CodexEvent, type CodexItemCompletedEvent, type CodexItemStartedEvent, type CodexItemUpdatedEvent, type CodexSdkAgent, type CodexSdkAgentOptions, type CodexSdkEvent, type CodexSdkItem, type CodexSdkPermissionMode, type CodexSdkRunOptions, type CodexThreadStartedEvent, type CodexTurnCompletedEvent, type CodexTurnFailedEvent, type CompletedRunResult, type Container, type ContainerBase, type ContainerConfig, type ContainerConfigBase, ContainerCreateError, ContainerDiffError, ContainerDisposedError, ContainerError, ContainerExecError, type ContainerExecution, type ContainerFileSystem, type ContainerIdentity, type ContainerLifecycle, ContainerNotRunningError, type ContainerObservability, ContainerStartError, type ContainerStatus, type ContainerType, type ContentPart, type DockerBuildBase, type DockerBuildConfig, type DockerContainer, type DockerContainerBase, type DockerContainerConfig, type DockerProviderConfig, type E2BConnectConfig, type E2BConnectionConfig, type E2BContainer, type E2BContainerBase, type E2BContainerConfig, type E2BCreateConfig, type E2BProviderConfig, type EnsureDisjoint, type ExecOptions, type ExecResult, type FailedRunResult, type GeminiCliAgent, type GeminiCliAgentOptions, type GeminiCliPermissionMode, type GeminiCliRunOptions, type GeminiEvent, type ImageContentPart, type JsonSchema, type JsonSchemaRunRequest, type McpServerConfig, type MessageEvent, type OutputSchema, type PodmanBuildBase, type PodmanBuildConfig, type PodmanContainer, type PodmanContainerBase, type PodmanContainerConfig, type PodmanProviderConfig, type PortMapping, type ReasoningEvent, type RunError, type RunProcessInfo, type RunRequest, type RunResult, type RunResultBase, type RunStats, type RunStatus, type RunTiming, type Sandbox, type SandboxBase, type SandboxConfig, type SandboxConfigBase, type SandboxExecution, type SandboxIdentity, type SandboxLifecycle, type SandboxStatus, type SandboxType, type SessionEndEvent, type SessionStartEvent, type StderrEvent, type StopReason, type StructuredRunRequest, type TextContentPart, type ToolCallEvent, type ToolResultEvent, type VolumeMount, type WorkdirChangeKind, type WorkdirDiff, type WorkdirDiffStats, type WorkdirFileChange, type WorkdirSnapshot, type WorkdirSnapshotOptions, type ZodRunRequest, agentCapabilitiesSchema, createAgent, createContainer, createSandbox, eventSchema };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{n as e,t}from"./types-CwvWHEpy.mjs";import{a as n,i as r,n as i,o as a,r as o,s,t as c}from"./errors-XV0frS3r.mjs";import{createContainer as l}from"./container/index.mjs";import{t as u}from"./sandbox-DeKpyenZ.mjs";import{n as d,u as f}from"./schemas-BM6qORw3.mjs";const p=(e,t)=>{if(!(e instanceof Error)||!e.message.includes(t))return!1;let n=typeof e==`object`&&e&&`code`in e?e.code:void 0;return n===`ERR_MODULE_NOT_FOUND`||n===`MODULE_NOT_FOUND`},m=(t,n,r)=>{throw p(r,n)?new e(`Agent type "${t}" requires the optional peer dependency "${n}". Install it to use this adapter.`):r};async function h(t,n){switch(t){case`claude-code-cli`:{let{createClaudeCodeCliAgent:e}=await import(`./adapters/claude-code-cli/index.mjs`);return e(n)}case`claude-code-sdk`:{let e=n;try{let{createClaudeCodeSdkAgent:t}=await import(`./adapters/claude-code-sdk/index.mjs`);return t(e)}catch(e){return m(`claude-code-sdk`,`@anthropic-ai/claude-agent-sdk`,e)}}case`codex-cli`:{let{createCodexCliAgent:e}=await import(`./adapters/codex-cli/index.mjs`);return e(n)}case`codex-sdk`:{let e=n;try{let{createCodexSdkAgent:t}=await import(`./adapters/codex-sdk/index.mjs`);return t(e)}catch(e){return m(`codex-sdk`,`@openai/codex-sdk`,e)}}case`gemini-cli`:{let{createGeminiCliAgent:e}=await import(`./adapters/gemini-cli/index.mjs`);return e(n)}default:throw new e(`Unsupported agent type.`)}}export{t as AgentRunError,e as AgentValidationError,c as ContainerCreateError,i as ContainerDiffError,o as ContainerDisposedError,r as ContainerError,n as ContainerExecError,a as ContainerNotRunningError,s as ContainerStartError,f as agentCapabilitiesSchema,h as createAgent,l as createContainer,u as createSandbox,d as eventSchema};

package/dist/oci-C_S_FKHj.mjs

@@ -0,0 +1 @@
+import{t as e}from"./util-CGg8cK92.mjs";import{a as t,n,o as r,r as i,s as a,t as o}from"./errors-XV0frS3r.mjs";import{t as s}from"./spawner-BJesLc8I.mjs";import{i as c,n as l,r as u,t as d}from"./diff-BCfLDXNN.mjs";import{execFile as f}from"node:child_process";import{isAbsolute as p,join as m,posix as h}from"node:path";import{promisify as g}from"node:util";import{mkdtemp as _,rm as v,writeFile as y}from"node:fs/promises";import{tmpdir as b}from"node:os";import{randomBytes as x}from"node:crypto";const S=g(f),C=()=>`cw-${x(6).toString(`hex`)}`,w=async(e,t,n)=>{let r=await S(e,t,{encoding:`utf8`,timeout:n?.timeoutMs,signal:n?.signal,maxBuffer:50*1024*1024});return{stdout:r.stdout,stderr:r.stderr}},T=async(t,n)=>{let r=n.tag??`cw-build-${x(4).toString(`hex`)}`,i=[`build`,`-t`,r];if(n.args)for(let[e,t]of Object.entries(n.args))i.push(`--build-arg`,`${e}=${t}`);`dockerfile`in n&&n.dockerfile&&(i.push(`-f`,n.dockerfile),i.push(n.context??`.`));let a;if(`content`in n&&n.content){a=await _(m(b(),`cw-oci-build-`));let e=m(a,`Dockerfile`);await y(e,n.content,{encoding:`utf8`,mode:384}),i.push(`-f`,e),i.push(n.context??a)}try{await w(t,i)}catch(t){throw new o(`Image build failed: ${e(t)}`)}finally{a&&await v(a,{recursive:!0,force:!0}).catch(()=>{})}return r},E=async(e,t,n)=>{let r=await Promise.all(n.map(async n=>{try{let{container:r,protocol:i=`tcp`}=n,{stdout:a}=await w(e,[`port`,t,`${r}/${i}`]),o=/:(\d+)$/m.exec(a.trim());if(o?.[1])return[r,Number(o[1])]}catch{}})),i=new Map;for(let e of r)e&&i.set(e[0],e[1]);return i},D=(e,t)=>({spawn:(n,r,i={})=>{let a=[`exec`,`-i`];if(i.cwd&&a.push(`-w`,i.cwd),i.env)for(let[e,t]of Object.entries(i.env))a.push(`-e`,`${e}=${t}`);return a.push(e,n,...r),s.spawn(t,a,{stdio:i.stdio})}}),O=(e,t)=>{let n=h.relative(e,t);return n===``||!n.startsWith(`..`)&&!h.isAbsolute(n)},k=(e,t)=>{if(!e||e.length===0)return;let n=h.normalize(t),r;for(let t of e){if(!p(t.source))continue;let e=h.normalize(t.target);O(e,n)&&(!r||e.length>h.normalize(r.target).length)&&(r=t)}if(!r)return;let i=h.relative(h.normalize(r.target),n);return i===``?r.source:m(r.source,...i.split(`/`))},A=async(f,p,m)=>{let{binary:g,builtImage:_,containerName:v,workdir:y,user:b,network:x,platform:S,env:T,ports:O,mounts:A,extraArgs:j,image:M}=p,N=v??C(),P=[`create`,`--name`,N];if(b&&P.push(`--user`,b),x&&P.push(`--network`,x),S&&P.push(`--platform`,S),T)for(let[e,t]of Object.entries(T))P.push(`-e`,`${e}=${t}`);if(O)for(let e of O){let{host:t,container:n,protocol:r=`tcp`}=e;P.push(`-p`,`${t??``}:${n}/${r}`)}if(A)for(let e of A){let{readonly:t,source:n,target:r}=e,i=t?`ro`:`rw`;P.push(`-v`,`${n}:${r}:${i}`)}j&&P.push(...j),P.push(M,`sleep`,`infinity`);let F;try{let{stdout:e}=await w(g,P);F=e.trim()}catch(t){throw new o(`Container create failed: ${e(t)}`)}let I=`created`,L=new Map,R=()=>{if(I===`disposed`)throw new i},z=()=>{if(R(),I!==`running`)throw new r},B=D(F,g),V=l({owner:{},workdir:y,materialize:async(t,r)=>{R();let i=k(A,t);if(i){await d(i,r);return}z();try{await w(g,[`exec`,F,`sh`,`-c`,`test -d ${u(t)}`])}catch{throw new n(`Target path is not a directory: ${t}`)}try{await w(g,[`cp`,`${F}:${t}/.`,r])}catch(r){throw new n(`Failed to materialize container path ${t}: ${e(r)}`)}}}),H={get type(){return f},get id(){return F},get name(){return N},get config(){return m},get status(){return I},get workdir(){return y},get spawner(){return B},async start(){if(R(),I!==`running`){try{await w(g,[`start`,F])}catch(t){throw new a(`Container start failed: ${e(t)}`)}try{await w(g,[`exec`,F,`mkdir`,`-p`,y])}catch(t){try{await w(g,[`stop`,`-t`,`0`,F]),I=`stopped`}catch{try{let{stdout:e}=await w(g,[`inspect`,`--format`,`{{.State.Status}}`,F]);I=e.trim()===`running`?`running`:`stopped`}catch{I=`disposed`}}throw new a(`Container start failed: ${e(t)}`)}I=`running`,O?.length&&(L=await E(g,F,O))}},async stop(){if(R(),I===`running`){try{await w(g,[`stop`,`-t`,`2`,F])}catch{try{let{stdout:e}=await w(g,[`inspect`,`--format`,`{{.State.Status}}`,F]);if(e.trim()===`running`)return}catch{I=`disposed`;return}}I=`stopped`}},async dispose(){if(I!==`disposed`){try{await w(g,[`stop`,`-t`,`0`,F])}catch{}try{await w(g,[`rm`,`-f`,F])}catch{}_&&await w(g,[`rmi`,M]).catch(()=>{}),await V.disposeSnapshots().catch(()=>{}),I=`disposed`}},async exec(e,t,n={}){z();let r=[`exec`];if(n.cwd&&r.push(`-w`,n.cwd),n.env)for(let[e,t]of Object.entries(n.env))r.push(`-e`,`${e}=${t}`);r.push(F,e,...t);try{let{stdout:e,stderr:t}=await w(g,r,{timeoutMs:n.timeoutMs,signal:n.signal});return{exitCode:0,stdout:e,stderr:t}}catch(e){if(c(e))return{exitCode:typeof e.code==`number`?e.code:-1,stdout:String(e.stdout??``),stderr:String(e.stderr??``)};throw e}},async copyTo(e,t){z(),await w(g,[`cp`,e,`${F}:${t}`])},async copyFrom(e,t){z(),await w(g,[`cp`,`${F}:${e}`,t])},async writeFile(e,n){z();let r=h.isAbsolute(e)?e:h.resolve(y,e),i=h.dirname(r),a=typeof n==`string`?Buffer.from(n,`utf8`):n,o=[`exec`,`-i`];b&&o.push(`--user`,b),o.push(F,`sh`,`-c`,`mkdir -p ${u(i)} && cat > ${u(r)}`);let c=s.spawn(g,o,{stdio:[`pipe`,`ignore`,`ignore`]});c.stdin?.write?.(a),c.stdin?.end();let l=await c.wait();if(l.exitCode!==0)throw new t(`writeFile failed for ${r} (exit ${l.exitCode})`)},async readFile(e){z();let t=h.isAbsolute(e)?e:h.resolve(y,e),{stdout:n}=await w(g,[`exec`,F,`cat`,t]);return n},async fileExists(e){z();let t=h.isAbsolute(e)?e:h.resolve(y,e);try{return await w(g,[`exec`,F,`test`,`-e`,t]),!0}catch{return!1}},async mkdir(e){z();let t=h.isAbsolute(e)?e:h.resolve(y,e);await w(g,[`exec`,F,`mkdir`,`-p`,t])},async execShell(e,t={}){return H.exec(`sh`,[`-c`,e],t)},async logs(e={}){R();let t=[`logs`];e.tail!==void 0&&t.push(`--tail`,String(e.tail)),t.push(F);let{stdout:n}=await w(g,t);return n},async syncStatus(){R();try{let{stdout:e}=await w(g,[`inspect`,`--format`,`{{.State.Status}}`,F]),t=e.trim();I=t===`running`?`running`:t===`created`?`created`:`stopped`}catch{I=`disposed`}return I},async snapshotWorkdir(e={}){return V.snapshotWorkdir(e)},async diffWorkdir(e){return V.diffWorkdir(e)},async releaseWorkdirSnapshot(e){return V.releaseWorkdirSnapshot(e)},getMappedPort(e){return L.get(e)},[Symbol.asyncDispose](){return H.dispose()}};return H},j=async(e,t)=>{if(t.image)return t.image;if(t.build)return T(e,t.build);throw new o(`Either image or build must be provided.`)};export{j as n,A as t};

package/dist/sandbox/index.d.mts

@@ -0,0 +1,2 @@
+import { a as SandboxBase, c as SandboxExecution, d as SandboxStatus, f as SandboxType, i as Sandbox, l as SandboxIdentity, n as BubblewrapSandbox, o as SandboxConfig, r as BubblewrapSandboxConfig, s as SandboxConfigBase, t as createSandbox, u as SandboxLifecycle } from "../index-DCaZeLrI.mjs";
+export { BubblewrapSandbox, BubblewrapSandboxConfig, Sandbox, SandboxBase, SandboxConfig, SandboxConfigBase, SandboxExecution, SandboxIdentity, SandboxLifecycle, SandboxStatus, SandboxType, createSandbox };

package/dist/sandbox/index.mjs

@@ -0,0 +1 @@
+import{t as e}from"../sandbox-DeKpyenZ.mjs";export{e as createSandbox};

package/dist/sandbox-DeKpyenZ.mjs

@@ -0,0 +1 @@
+import{t as e}from"./util-CGg8cK92.mjs";import{t}from"./env-Dkd8Sgjf.mjs";import{t as n}from"./spawner-BJesLc8I.mjs";import{execFile as r}from"node:child_process";import{posix as i}from"node:path";import{promisify as a}from"node:util";const o=`bwrap`,s=[`/tmp`],c=a(r),l=(e,t)=>e.binds?.some(e=>e.target===t)??!1,u=(e,t)=>{let n=i.relative(e,t);return n===``||!n.startsWith(`..`)&&!i.isAbsolute(n)},d=(e,t)=>e.target.length-t.target.length,f=e=>{let t=l(e,e.workdir)?[...e.binds??[]]:[{source:e.workdir,target:e.workdir},...e.binds??[]],n=e.tmpfs??s,r=t.filter(e=>!n.some(t=>u(t,e.target))).toSorted(d),i=t.filter(e=>n.some(t=>u(t,e.target))).toSorted(d);return[...r,...i]},p=e=>{let t=[`--ro-bind`,`/`,`/`];for(let n of f(e))t.push(n.readonly?`--ro-bind`:`--bind`,n.source,n.target);return t},m=(e,t)=>{let n=[];(e.clearEnv??!0)&&n.push(`--clearenv`);for(let t of e.unsetEnv??[])n.push(`--unsetenv`,t);let r={...e.setEnv,...t.env};for(let[e,t]of Object.entries(r))n.push(`--setenv`,e,t);return n},h=e=>{let t=[`--die-with-parent`,`--new-session`];return(e.unshareAll??!0)&&t.push(`--unshare-all`),e.shareNetwork&&t.push(`--share-net`),e.uid!==void 0&&t.push(`--uid`,String(e.uid)),e.gid!==void 0&&t.push(`--gid`,String(e.gid)),e.hostname&&t.push(`--hostname`,e.hostname),t},g=e=>{let t=[`--ro-bind`,`/`,`/`];e.proc!==!1&&t.push(`--proc`,e.proc??`/proc`),e.dev!==!1&&t.push(`--dev`,e.dev??`/dev`);for(let n of e.tmpfs??s)t.push(`--tmpfs`,n);t.push(...p(e).slice(3));for(let n of e.remountReadonly??[])t.push(`--remount-ro`,n);return t},_=(e,t,n,r={})=>[...h(e),...g(e),...m(e,r),`--chdir`,r.cwd??e.workdir,...e.args??[],`--`,t,...n],v=async n=>{try{await c(n,[`--version`],{env:t(),encoding:`utf8`})}catch(t){throw Error(`Bubblewrap start failed: ${e(t)}`)}},y=(e,n,r,i)=>({spawn(a,s,c={}){return n(),r(i.spawn(e.binary??o,_(e,a,s,c),{env:t(),stdio:c.stdio}))}}),b=async(e,t=n)=>{let r=`created`,i=new Set,a=()=>{if(r===`disposed`)throw Error(`Bubblewrap sandbox has been disposed.`)},s=()=>{if(a(),r!==`running`)throw Error(`Bubblewrap sandbox is not running.`)},c=e=>{let t={process:e,waitPromise:e.wait().finally(()=>{i.delete(t)})};return i.add(t),{...e,wait:()=>t.waitPromise}},l=async()=>{let e=Array.from(i,e=>(e.process.kill(`SIGKILL`),e.waitPromise));await Promise.allSettled(e)},u=y(e,s,c,t),d={type:`bubblewrap`,config:e,get status(){return r},get workdir(){return e.workdir},get spawner(){return u},async start(){a(),r!==`running`&&(await v(e.binary??o),r=`running`)},async stop(){a(),r===`running`&&(r=`stopped`,await l())},async dispose(){r!==`disposed`&&(r=`disposed`,await l())},[Symbol.asyncDispose](){return d.dispose()}};return d};async function x(e){switch(e.type){case`bubblewrap`:return b(e)}throw Error(`Unsupported sandbox type.`)}export{x as t};

package/dist/schemas/index.d.mts

@@ -0,0 +1,2 @@
+import { C as OutputSchema, D as imageContentPartSchema, E as contentPartSchema, O as textContentPartSchema, S as McpServerConfig, T as agentCapabilitiesSchema, _ as toolResultEventSchema, a as SessionStartEvent, b as ImageContentPart, c as ToolResultEvent, d as messageEventSchema, f as reasoningEventSchema, g as toolCallEventSchema, h as stderrEventSchema, i as SessionEndEvent, l as baseEventSchema, m as sessionStartEventSchema, n as MessageEvent, o as StderrEvent, p as sessionEndEventSchema, r as ReasoningEvent, s as ToolCallEvent, t as AgentEvent, u as eventSchema, v as AgentCapabilities, w as TextContentPart, x as JsonSchema, y as ContentPart } from "../events-D31_b0sA.mjs";
+export { type AgentCapabilities, type AgentEvent, type ContentPart, type ImageContentPart, type JsonSchema, type McpServerConfig, type MessageEvent, type OutputSchema, type ReasoningEvent, type SessionEndEvent, type SessionStartEvent, type StderrEvent, type TextContentPart, type ToolCallEvent, type ToolResultEvent, agentCapabilitiesSchema, baseEventSchema, contentPartSchema, eventSchema, imageContentPartSchema, messageEventSchema, reasoningEventSchema, sessionEndEventSchema, sessionStartEventSchema, stderrEventSchema, textContentPartSchema, toolCallEventSchema, toolResultEventSchema };

package/dist/schemas/index.mjs

@@ -0,0 +1 @@
+import{a as e,c as t,d as n,f as r,i,l as a,n as o,o as s,p as c,r as l,s as u,t as d,u as f}from"../schemas-BM6qORw3.mjs";export{f as agentCapabilitiesSchema,d as baseEventSchema,n as contentPartSchema,o as eventSchema,r as imageContentPartSchema,l as messageEventSchema,i as reasoningEventSchema,e as sessionEndEventSchema,s as sessionStartEventSchema,u as stderrEventSchema,c as textContentPartSchema,t as toolCallEventSchema,a as toolResultEventSchema};

package/dist/schemas-BM6qORw3.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod/v4";const t=e.object({type:e.literal(`text`),text:e.string()}),n=e.object({type:e.literal(`image`),path:e.string(),mediaType:e.string().optional()}),r=e.discriminatedUnion(`type`,[t,n]),i=e.object({structuredOutput:e.boolean(),sessionResume:e.boolean(),imageInput:e.boolean(),mcp:e.boolean(),eventStreaming:e.boolean(),sessionFork:e.boolean().optional()}),a=e.object({id:e.string(),runId:e.string(),timestamp:e.date()}),o=a.extend({type:e.literal(`session-start`),requestedSessionId:e.string().optional(),sessionId:e.string().optional(),resumed:e.boolean()}),s=a.extend({type:e.literal(`message`),sessionId:e.string().optional(),model:e.string().nullable(),role:e.enum([`system`,`user`,`assistant`]),content:e.array(r),text:e.string().optional()}),c=a.extend({type:e.literal(`reasoning`),sessionId:e.string().optional(),model:e.string().nullable(),content:e.array(r),text:e.string().optional()}),l=a.extend({type:e.literal(`tool-call`),sessionId:e.string().optional(),model:e.string().nullable(),toolCallId:e.string(),toolName:e.string(),input:e.unknown().optional()}),u=a.extend({type:e.literal(`tool-result`),sessionId:e.string().optional(),toolCallId:e.string(),toolName:e.string().optional(),input:e.unknown().optional(),output:e.unknown(),isError:e.boolean().optional(),error:e.string().optional()}),d=a.extend({type:e.literal(`stderr`),sessionId:e.string().optional(),text:e.string()}),f=a.extend({type:e.literal(`session-end`),sessionId:e.string().optional(),status:e.enum([`completed`,`failed`,`cancelled`]),error:e.string().optional()}),p=e.discriminatedUnion(`type`,[o,s,c,l,u,d,f]);export{f as a,l as c,r as d,n as f,c as i,u as l,p as n,o,t as p,s as r,d as s,a as t,i as u};

package/dist/spawner-BJesLc8I.mjs

@@ -0,0 +1 @@
+import{spawn as e}from"node:child_process";const t=e=>({async*[Symbol.asyncIterator](){for await(let t of e){if(t instanceof Buffer){yield new Uint8Array(t);continue}if(typeof t==`string`){yield new TextEncoder().encode(t);continue}if(t instanceof Uint8Array){yield t;continue}throw Error(`Unsupported stdout/stderr chunk type: ${typeof t}`)}}}),n={spawn:(n,r,i={})=>{let a=e(n,r,{cwd:i.cwd,env:i.env,stdio:i.stdio}),o=new Promise((e,t)=>{let n=(t,n)=>{a.removeListener(`error`,r),e({exitCode:t,signal:n})},r=e=>{a.removeListener(`close`,n),t(e)};a.once(`error`,r),a.once(`close`,n)});return{stdout:a.stdout?t(a.stdout):null,stderr:a.stderr?t(a.stderr):null,stdin:a.stdin?{write:e=>a.stdin?.write(e),end:()=>a.stdin?.end()}:null,kill:e=>a.kill(e),wait:()=>o}}};export{n as t};

package/dist/structured-output-DEkBQ-1Z.mjs

@@ -0,0 +1 @@
+const e=e=>{let t;for(let[,n]of e)n.toolName===`StructuredOutput`&&n.input!==void 0&&(t=n.input);return t},t=(t,n,r,i)=>{if(t!==void 0)return{value:t};if(!n.schemaRequested)return{};let a=e(n.toolCalls);return a===void 0?r.isSuccess?{error:{kind:`parse`,message:i}}:{}:{value:a}};export{t};