coding-agents-sdk 0.0.1 → 0.2.0

package/dist/index-ByAOGMUM.d.mts

@@ -0,0 +1,224 @@
+import { E as ProcessSpawner } from "./types-Cb_EXIEe.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-C3ZxLAd0.d.mts

@@ -0,0 +1,315 @@
+import { S as McpServerConfig } from "./events-nxuRbYIu.mjs";
+import { E as ProcessSpawner, f as EnsureDisjoint, l as BaseAgent, t as AgentEventHandler } from "./types-Cb_EXIEe.mjs";
+import { t as Container } from "./index-ByAOGMUM.mjs";
+import { z } from "zod/v4";
+
+//#region src/adapters/claude-code-cli/events/schemas.d.ts
+declare const claudeSystemEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"system">;
+  session_id: z.ZodString;
+  subtype: z.ZodEnum<{
+    init: "init";
+    hook_response: "hook_response";
+    hook_started: "hook_started";
+    hook_finished: "hook_finished";
+    hook_failed: "hook_failed";
+    hook_skipped: "hook_skipped";
+  }>;
+  uuid: z.ZodString;
+  tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+      error: "error";
+      failed: "failed";
+      connected: "connected";
+      disconnected: "disconnected";
+    }>;
+  }, z.core.$strip>>>;
+  model: z.ZodOptional<z.ZodString>;
+  cwd: z.ZodOptional<z.ZodString>;
+  hook_name: z.ZodOptional<z.ZodString>;
+  hook_event: z.ZodOptional<z.ZodString>;
+  stdout: z.ZodOptional<z.ZodString>;
+  stderr: z.ZodOptional<z.ZodString>;
+  exit_code: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ClaudeSystemEvent = z.infer<typeof claudeSystemEventSchema>;
+declare const claudeAssistantEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"assistant">;
+  session_id: z.ZodString;
+  uuid: z.ZodString;
+  parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  message: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"message">;
+    role: z.ZodLiteral<"assistant">;
+    model: z.ZodString;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_use">;
+      id: z.ZodString;
+      name: z.ZodString;
+      input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"thinking">;
+      thinking: z.ZodString;
+      signature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    stop_reason: z.ZodNullable<z.ZodEnum<{
+      tool_use: "tool_use";
+      end_turn: "end_turn";
+      max_tokens: "max_tokens";
+      stop_sequence: "stop_sequence";
+    }>>;
+    stop_sequence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    context_management: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    usage: z.ZodObject<{
+      input_tokens: z.ZodNumber;
+      output_tokens: z.ZodNumber;
+      cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+      cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+      service_tier: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        premium: "premium";
+        standard: "standard";
+      }>>>;
+    }, z.core.$strip>;
+    ttftMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type ClaudeAssistantEvent = z.infer<typeof claudeAssistantEventSchema>;
+declare const claudeUserEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"user">;
+  session_id: z.ZodString;
+  message: z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"tool_result">;
+      tool_use_id: z.ZodString;
+      content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+      }, z.core.$strip>>]>;
+      is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>;
+  parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  uuid: z.ZodString;
+  isSynthetic: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ClaudeUserEvent = z.infer<typeof claudeUserEventSchema>;
+declare const claudeResultEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"result">;
+  session_id: z.ZodString;
+  uuid: z.ZodString;
+  subtype: z.ZodEnum<{
+    success: "success";
+    error_max_turns: "error_max_turns";
+    error_during_execution: "error_during_execution";
+  }>;
+  duration_ms: z.ZodNumber;
+  duration_api_ms: z.ZodNumber;
+  is_error: z.ZodBoolean;
+  num_turns: z.ZodNumber;
+  result: z.ZodOptional<z.ZodUnknown>;
+  structured_output: z.ZodOptional<z.ZodUnknown>;
+  total_cost_usd: z.ZodNumber;
+  usage: z.ZodOptional<z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodNumber;
+    server_tool_use: z.ZodOptional<z.ZodObject<{
+      web_search_requests: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ClaudeResultEvent = z.infer<typeof claudeResultEventSchema>;
+declare const claudeRateLimitEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rate_limit_event">;
+  uuid: z.ZodString;
+  session_id: z.ZodOptional<z.ZodString>;
+  rate_limit_info: z.ZodObject<{
+    status: z.ZodString;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+    rateLimitType: z.ZodOptional<z.ZodString>;
+    overageStatus: z.ZodOptional<z.ZodString>;
+    overageDisabledReason: z.ZodOptional<z.ZodString>;
+    isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type ClaudeRateLimitEvent = z.infer<typeof claudeRateLimitEventSchema>;
+declare const claudeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"system">;
+  session_id: z.ZodString;
+  subtype: z.ZodEnum<{
+    init: "init";
+    hook_response: "hook_response";
+    hook_started: "hook_started";
+    hook_finished: "hook_finished";
+    hook_failed: "hook_failed";
+    hook_skipped: "hook_skipped";
+  }>;
+  uuid: z.ZodString;
+  tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+      error: "error";
+      failed: "failed";
+      connected: "connected";
+      disconnected: "disconnected";
+    }>;
+  }, z.core.$strip>>>;
+  model: z.ZodOptional<z.ZodString>;
+  cwd: z.ZodOptional<z.ZodString>;
+  hook_name: z.ZodOptional<z.ZodString>;
+  hook_event: z.ZodOptional<z.ZodString>;
+  stdout: z.ZodOptional<z.ZodString>;
+  stderr: z.ZodOptional<z.ZodString>;
+  exit_code: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"assistant">;
+  session_id: z.ZodString;
+  uuid: z.ZodString;
+  parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  message: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"message">;
+    role: z.ZodLiteral<"assistant">;
+    model: z.ZodString;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_use">;
+      id: z.ZodString;
+      name: z.ZodString;
+      input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"thinking">;
+      thinking: z.ZodString;
+      signature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    stop_reason: z.ZodNullable<z.ZodEnum<{
+      tool_use: "tool_use";
+      end_turn: "end_turn";
+      max_tokens: "max_tokens";
+      stop_sequence: "stop_sequence";
+    }>>;
+    stop_sequence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    context_management: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    usage: z.ZodObject<{
+      input_tokens: z.ZodNumber;
+      output_tokens: z.ZodNumber;
+      cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+      cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+      service_tier: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        premium: "premium";
+        standard: "standard";
+      }>>>;
+    }, z.core.$strip>;
+    ttftMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"user">;
+  session_id: z.ZodString;
+  message: z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"tool_result">;
+      tool_use_id: z.ZodString;
+      content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+      }, z.core.$strip>>]>;
+      is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>;
+  parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  uuid: z.ZodString;
+  isSynthetic: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"result">;
+  session_id: z.ZodString;
+  uuid: z.ZodString;
+  subtype: z.ZodEnum<{
+    success: "success";
+    error_max_turns: "error_max_turns";
+    error_during_execution: "error_during_execution";
+  }>;
+  duration_ms: z.ZodNumber;
+  duration_api_ms: z.ZodNumber;
+  is_error: z.ZodBoolean;
+  num_turns: z.ZodNumber;
+  result: z.ZodOptional<z.ZodUnknown>;
+  structured_output: z.ZodOptional<z.ZodUnknown>;
+  total_cost_usd: z.ZodNumber;
+  usage: z.ZodOptional<z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodNumber;
+    server_tool_use: z.ZodOptional<z.ZodObject<{
+      web_search_requests: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rate_limit_event">;
+  uuid: z.ZodString;
+  session_id: z.ZodOptional<z.ZodString>;
+  rate_limit_info: z.ZodObject<{
+    status: z.ZodString;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+    rateLimitType: z.ZodOptional<z.ZodString>;
+    overageStatus: z.ZodOptional<z.ZodString>;
+    overageDisabledReason: z.ZodOptional<z.ZodString>;
+    isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type ClaudeEvent = z.infer<typeof claudeEventSchema>;
+//#endregion
+//#region src/adapters/claude-code-cli/types.d.ts
+type ClaudeCodeCliPermissionMode = "acceptEdits" | "bypassPermissions" | "default" | "dontAsk" | "plan";
+interface ClaudeCodeCliRunOptions {
+  allowedTools?: string[];
+  disallowedTools?: string[];
+  appendSystemPrompt?: string;
+  permissionMode?: ClaudeCodeCliPermissionMode;
+  mcpConfig?: string[] | string;
+  mcpServers?: Record<string, McpServerConfig>;
+  forkSession?: boolean;
+  extraArgs?: string[];
+}
+interface ClaudeCodeCliAgentOptions extends ClaudeCodeCliRunOptions {
+  command?: string[] | string;
+  cwd?: string;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  sessionId?: string;
+  model?: string;
+  systemPrompt?: string;
+  logPath?: string;
+  ci?: boolean;
+  container?: Container;
+  spawner?: ProcessSpawner;
+  onEvent?: AgentEventHandler;
+}
+interface ClaudeCodeCliAgent extends BaseAgent<EnsureDisjoint<ClaudeCodeCliRunOptions>> {
+  readonly type: "claude-code-cli";
+  fork: () => ClaudeCodeCliAgent;
+  dispose: () => Promise<void>;
+}
+//#endregion
+//#region src/adapters/claude-code-cli/adapter.d.ts
+declare const createClaudeCodeCliAgent: (options?: ClaudeCodeCliAgentOptions) => ClaudeCodeCliAgent;
+//#endregion
+export { ClaudeCodeCliRunOptions as a, ClaudeRateLimitEvent as c, ClaudeUserEvent as d, ClaudeCodeCliPermissionMode as i, ClaudeResultEvent as l, ClaudeCodeCliAgent as n, ClaudeAssistantEvent as o, ClaudeCodeCliAgentOptions as r, ClaudeEvent as s, createClaudeCodeCliAgent as t, ClaudeSystemEvent as u };

package/dist/index-CFpNOmdA.d.mts

@@ -0,0 +1,145 @@
+import { f as EnsureDisjoint, l as BaseAgent, t as AgentEventHandler } from "./types-Cb_EXIEe.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;
+  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 };