coding-agents-sdk 0.0.1 → 0.2.0

package/dist/index-dRVpEAr8.d.mts

@@ -0,0 +1,39 @@
+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/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[];
+}
+interface GeminiCliAgentOptions extends GeminiCliRunOptions {
+  command?: string[] | string;
+  cwd?: string;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  sessionId?: string;
+  model?: string;
+  systemPrompt?: string;
+  logPath?: string;
+  container?: Container;
+  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-nzo1sBiK.d.mts

@@ -0,0 +1,110 @@
+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/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 {
+  sandbox?: CodexCliSandboxMode;
+  additionalDirectories?: string[];
+  skipGitRepoCheck?: boolean;
+  permissionMode?: CodexCliPermissionMode;
+  ephemeral?: boolean;
+  mcpConfig?: string;
+  mcpServers?: Record<string, McpServerConfig>;
+  extraArgs?: string[];
+  systemPrompt?: never;
+}
+interface CodexCliAgentOptions extends CodexCliRunOptions {
+  command?: string[] | string;
+  cwd?: string;
+  env?: Record<string, string>;
+  propagateEnv?: boolean;
+  sessionId?: string;
+  model?: string;
+  logPath?: string;
+  container?: Container;
+  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.d.mts

@@ -0,0 +1,16 @@
+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-nxuRbYIu.mjs";
+import { C as StopReason, S as RunTiming, T as ZodRunRequest, _ as RunRequest, a as AgentValidationError, b as RunStats, c as AnyRunResult, d as CompletedRunResult, f as EnsureDisjoint, g as RunProcessInfo, h as RunError, i as AgentType, l as BaseAgent, m as JsonSchemaRunRequest, n as AgentMetrics, o as AnyCompletedRunResult, p as FailedRunResult, r as AgentRunError, s as AnyRunRequest, t as AgentEventHandler, u as CancelledRunResult, v as RunResult, w as StructuredRunRequest, x as RunStatus, y as RunResultBase } from "./types-Cb_EXIEe.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-ByAOGMUM.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-C3ZxLAd0.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-B3YqrgIp.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-nzo1sBiK.mjs";
+import { a as CodexSdkItem, i as CodexSdkEvent, n as CodexSdkAgent, o as CodexSdkPermissionMode, r as CodexSdkAgentOptions, s as CodexSdkRunOptions } from "./index-CFpNOmdA.mjs";
+import { a as GeminiCliRunOptions, i as GeminiCliPermissionMode, n as GeminiCliAgent, o as GeminiEvent, r as GeminiCliAgentOptions } from "./index-dRVpEAr8.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 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 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, eventSchema };

package/dist/index.mjs

@@ -0,0 +1,61 @@
+import { n as AgentValidationError, t as AgentRunError } from "./types-aNMD8h3x.mjs";
+import { a as ContainerExecError, i as ContainerError, n as ContainerDiffError, o as ContainerNotRunningError, r as ContainerDisposedError, s as ContainerStartError, t as ContainerCreateError } from "./errors-BAmHDQu8.mjs";
+import { createContainer } from "./container/index.mjs";
+import { n as eventSchema, u as agentCapabilitiesSchema } from "./schemas-DwD4pwJB.mjs";
+//#region src/core/agent/create-agent.ts
+function resolveContainerOptions(options) {
+	if (!options?.container) return options;
+	return {
+		...options,
+		cwd: options.cwd ?? options.container.workdir
+	};
+}
+const isMissingModuleError = (error, packageName) => {
+	if (!(error instanceof Error) || !error.message.includes(packageName)) return false;
+	const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+	return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+};
+const wrapMissingPeerDependency = (type, packageName, error) => {
+	if (isMissingModuleError(error, packageName)) throw new AgentValidationError(`Agent type "${type}" requires the optional peer dependency "${packageName}". Install it to use this adapter.`);
+	throw error;
+};
+async function createAgent(type, options) {
+	switch (type) {
+		case "claude-code-cli": {
+			const typedOptions = resolveContainerOptions(options);
+			const { createClaudeCodeCliAgent } = await import("./adapters/claude-code-cli/index.mjs");
+			return createClaudeCodeCliAgent(typedOptions);
+		}
+		case "claude-code-sdk": {
+			const typedOptions = options;
+			try {
+				const { createClaudeCodeSdkAgent } = await import("./adapters/claude-code-sdk/index.mjs");
+				return createClaudeCodeSdkAgent(typedOptions);
+			} catch (error) {
+				return wrapMissingPeerDependency("claude-code-sdk", "@anthropic-ai/claude-agent-sdk", error);
+			}
+		}
+		case "codex-cli": {
+			const typedOptions = resolveContainerOptions(options);
+			const { createCodexCliAgent } = await import("./adapters/codex-cli/index.mjs");
+			return createCodexCliAgent(typedOptions);
+		}
+		case "codex-sdk": {
+			const typedOptions = options;
+			try {
+				const { createCodexSdkAgent } = await import("./adapters/codex-sdk/index.mjs");
+				return createCodexSdkAgent(typedOptions);
+			} catch (error) {
+				return wrapMissingPeerDependency("codex-sdk", "@openai/codex-sdk", error);
+			}
+		}
+		case "gemini-cli": {
+			const typedOptions = resolveContainerOptions(options);
+			const { createGeminiCliAgent } = await import("./adapters/gemini-cli/index.mjs");
+			return createGeminiCliAgent(typedOptions);
+		}
+		default: throw new AgentValidationError("Unsupported agent type.");
+	}
+}
+//#endregion
+export { AgentRunError, AgentValidationError, ContainerCreateError, ContainerDiffError, ContainerDisposedError, ContainerError, ContainerExecError, ContainerNotRunningError, ContainerStartError, agentCapabilitiesSchema, createAgent, createContainer, eventSchema };

package/dist/oci-DMZZQZ47.mjs

@@ -0,0 +1,438 @@
+import { t as formatError } from "./util-B4RQZkKr.mjs";
+import { a as ContainerExecError, n as ContainerDiffError, o as ContainerNotRunningError, r as ContainerDisposedError, s as ContainerStartError, t as ContainerCreateError } from "./errors-BAmHDQu8.mjs";
+import { t as DEFAULT_SPAWNER } from "./spawner-Bw9UBEGX.mjs";
+import { i as isExecFileError, n as createWorkdirDiffApi, r as shellEscape, t as copyLocalDirectoryContents } from "./diff-De8d3MVb.mjs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, posix } from "node:path";
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { promisify } from "node:util";
+//#region src/container/oci.ts
+const execFileAsync = promisify(execFile);
+const generateContainerName = () => `cw-${randomBytes(6).toString("hex")}`;
+const runOci = async (binary, args, options) => {
+	const result = await execFileAsync(binary, args, {
+		encoding: "utf8",
+		timeout: options?.timeoutMs,
+		signal: options?.signal,
+		maxBuffer: 50 * 1024 * 1024
+	});
+	return {
+		stdout: result.stdout,
+		stderr: result.stderr
+	};
+};
+const buildOciImage = async (binary, build) => {
+	const tag = build.tag ?? `cw-build-${randomBytes(4).toString("hex")}`;
+	const args = [
+		"build",
+		"-t",
+		tag
+	];
+	if (build.args) for (const [key, value] of Object.entries(build.args)) args.push("--build-arg", `${key}=${value}`);
+	if ("dockerfile" in build && build.dockerfile) {
+		args.push("-f", build.dockerfile);
+		args.push(build.context ?? ".");
+	}
+	let tempDir;
+	if ("content" in build && build.content) {
+		tempDir = await mkdtemp(join(tmpdir(), "cw-oci-build-"));
+		const dockerfilePath = join(tempDir, "Dockerfile");
+		await writeFile(dockerfilePath, build.content, {
+			encoding: "utf8",
+			mode: 384
+		});
+		args.push("-f", dockerfilePath);
+		args.push(build.context ?? tempDir);
+	}
+	try {
+		await runOci(binary, args);
+	} catch (error) {
+		throw new ContainerCreateError(`Image build failed: ${formatError(error)}`);
+	} finally {
+		if (tempDir) await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+	return tag;
+};
+const resolvePortMappings = async (binary, containerId, ports) => {
+	const results = await Promise.all(ports.map(async (port) => {
+		try {
+			const { container: containerPort, protocol = "tcp" } = port;
+			const { stdout } = await runOci(binary, [
+				"port",
+				containerId,
+				`${containerPort}/${protocol}`
+			]);
+			const match = /:(\d+)$/m.exec(stdout.trim());
+			if (match?.[1]) return [containerPort, Number(match[1])];
+		} catch {}
+	}));
+	const mapped = /* @__PURE__ */ new Map();
+	for (const entry of results) if (entry) mapped.set(entry[0], entry[1]);
+	return mapped;
+};
+const createOciSpawner = (containerId, binary) => ({ spawn: (command, args, options = {}) => {
+	const execArgs = ["exec", "-i"];
+	if (options.cwd) execArgs.push("-w", options.cwd);
+	if (options.env) for (const [key, value] of Object.entries(options.env)) execArgs.push("-e", `${key}=${value}`);
+	execArgs.push(containerId, command, ...args);
+	return DEFAULT_SPAWNER.spawn(binary, execArgs, { stdio: options.stdio });
+} });
+const isWithinContainerMount = (mountTarget, cwd) => {
+	const relativePath = posix.relative(mountTarget, cwd);
+	return relativePath === "" || !relativePath.startsWith("..") && !posix.isAbsolute(relativePath);
+};
+const resolveHostMountPath = (mounts, cwd) => {
+	if (!mounts || mounts.length === 0) return;
+	const normalizedCwd = posix.normalize(cwd);
+	let bestMatch;
+	for (const mount of mounts) {
+		if (!isAbsolute(mount.source)) continue;
+		const normalizedTarget = posix.normalize(mount.target);
+		if (!isWithinContainerMount(normalizedTarget, normalizedCwd)) continue;
+		if (!bestMatch || normalizedTarget.length > posix.normalize(bestMatch.target).length) bestMatch = mount;
+	}
+	if (!bestMatch) return;
+	const relativePath = posix.relative(posix.normalize(bestMatch.target), normalizedCwd);
+	return relativePath === "" ? bestMatch.source : join(bestMatch.source, ...relativePath.split("/"));
+};
+const createOciContainer = async (type, params, config) => {
+	const { binary, builtImage, containerName: requestedContainerName, workdir, user, network, platform, env, ports, mounts, extraArgs, image } = params;
+	const containerName = requestedContainerName ?? generateContainerName();
+	const createArgs = [
+		"create",
+		"--name",
+		containerName
+	];
+	if (user) createArgs.push("--user", user);
+	if (network) createArgs.push("--network", network);
+	if (platform) createArgs.push("--platform", platform);
+	if (env) for (const [key, value] of Object.entries(env)) createArgs.push("-e", `${key}=${value}`);
+	if (ports) for (const port of ports) {
+		const { host, container, protocol = "tcp" } = port;
+		createArgs.push("-p", `${host ?? ""}:${container}/${protocol}`);
+	}
+	if (mounts) for (const mount of mounts) {
+		const { readonly: isReadonly, source, target } = mount;
+		const mode = isReadonly ? "ro" : "rw";
+		createArgs.push("-v", `${source}:${target}:${mode}`);
+	}
+	if (extraArgs) createArgs.push(...extraArgs);
+	createArgs.push(image, "sleep", "infinity");
+	let containerId;
+	try {
+		const { stdout } = await runOci(binary, createArgs);
+		containerId = stdout.trim();
+	} catch (error) {
+		throw new ContainerCreateError(`Container create failed: ${formatError(error)}`);
+	}
+	let status = "created";
+	let portMappings = /* @__PURE__ */ new Map();
+	const assertNotDisposed = () => {
+		if (status === "disposed") throw new ContainerDisposedError();
+	};
+	const assertRunning = () => {
+		assertNotDisposed();
+		if (status !== "running") throw new ContainerNotRunningError();
+	};
+	const spawner = createOciSpawner(containerId, binary);
+	const diffApi = createWorkdirDiffApi({
+		owner: {},
+		workdir,
+		materialize: async (cwd, targetDir) => {
+			assertNotDisposed();
+			const hostPath = resolveHostMountPath(mounts, cwd);
+			if (hostPath) {
+				await copyLocalDirectoryContents(hostPath, targetDir);
+				return;
+			}
+			assertRunning();
+			try {
+				await runOci(binary, [
+					"exec",
+					containerId,
+					"sh",
+					"-c",
+					`test -d ${shellEscape(cwd)}`
+				]);
+			} catch {
+				throw new ContainerDiffError(`Target path is not a directory: ${cwd}`);
+			}
+			try {
+				await runOci(binary, [
+					"cp",
+					`${containerId}:${cwd}/.`,
+					targetDir
+				]);
+			} catch (error) {
+				throw new ContainerDiffError(`Failed to materialize container path ${cwd}: ${formatError(error)}`);
+			}
+		}
+	});
+	const instance = {
+		get type() {
+			return type;
+		},
+		get id() {
+			return containerId;
+		},
+		get name() {
+			return containerName;
+		},
+		get config() {
+			return config;
+		},
+		get status() {
+			return status;
+		},
+		get workdir() {
+			return workdir;
+		},
+		get spawner() {
+			return spawner;
+		},
+		async start() {
+			assertNotDisposed();
+			if (status === "running") return;
+			try {
+				await runOci(binary, ["start", containerId]);
+			} catch (error) {
+				throw new ContainerStartError(`Container start failed: ${formatError(error)}`);
+			}
+			try {
+				await runOci(binary, [
+					"exec",
+					containerId,
+					"mkdir",
+					"-p",
+					workdir
+				]);
+			} catch (error) {
+				try {
+					await runOci(binary, [
+						"stop",
+						"-t",
+						"0",
+						containerId
+					]);
+					status = "stopped";
+				} catch {
+					try {
+						const { stdout } = await runOci(binary, [
+							"inspect",
+							"--format",
+							"{{.State.Status}}",
+							containerId
+						]);
+						status = stdout.trim() === "running" ? "running" : "stopped";
+					} catch {
+						status = "disposed";
+					}
+				}
+				throw new ContainerStartError(`Container start failed: ${formatError(error)}`);
+			}
+			status = "running";
+			if (ports?.length) portMappings = await resolvePortMappings(binary, containerId, ports);
+		},
+		async stop() {
+			assertNotDisposed();
+			if (status !== "running") return;
+			try {
+				await runOci(binary, [
+					"stop",
+					"-t",
+					"2",
+					containerId
+				]);
+			} catch {
+				try {
+					const { stdout } = await runOci(binary, [
+						"inspect",
+						"--format",
+						"{{.State.Status}}",
+						containerId
+					]);
+					if (stdout.trim() === "running") return;
+				} catch {
+					status = "disposed";
+					return;
+				}
+			}
+			status = "stopped";
+		},
+		async dispose() {
+			if (status === "disposed") return;
+			try {
+				await runOci(binary, [
+					"stop",
+					"-t",
+					"0",
+					containerId
+				]);
+			} catch {}
+			try {
+				await runOci(binary, [
+					"rm",
+					"-f",
+					containerId
+				]);
+			} catch {}
+			if (builtImage) await runOci(binary, ["rmi", image]).catch(() => {});
+			await diffApi.disposeSnapshots().catch(() => {});
+			status = "disposed";
+		},
+		async exec(command, args, options = {}) {
+			assertRunning();
+			const execArgs = ["exec"];
+			if (options.cwd) execArgs.push("-w", options.cwd);
+			if (options.env) for (const [key, value] of Object.entries(options.env)) execArgs.push("-e", `${key}=${value}`);
+			execArgs.push(containerId, command, ...args);
+			try {
+				const { stdout, stderr } = await runOci(binary, execArgs, {
+					timeoutMs: options.timeoutMs,
+					signal: options.signal
+				});
+				return {
+					exitCode: 0,
+					stdout,
+					stderr
+				};
+			} catch (error) {
+				if (isExecFileError(error)) return {
+					exitCode: typeof error.code === "number" ? error.code : -1,
+					stdout: String(error.stdout ?? ""),
+					stderr: String(error.stderr ?? "")
+				};
+				throw error;
+			}
+		},
+		async copyTo(hostPath, containerPath) {
+			assertRunning();
+			await runOci(binary, [
+				"cp",
+				hostPath,
+				`${containerId}:${containerPath}`
+			]);
+		},
+		async copyFrom(containerPath, hostPath) {
+			assertRunning();
+			await runOci(binary, [
+				"cp",
+				`${containerId}:${containerPath}`,
+				hostPath
+			]);
+		},
+		async writeFile(path, content) {
+			assertRunning();
+			const resolved = posix.isAbsolute(path) ? path : posix.resolve(workdir, path);
+			const dir = posix.dirname(resolved);
+			const encoded = typeof content === "string" ? Buffer.from(content, "utf8") : content;
+			const execArgs = ["exec", "-i"];
+			if (user) execArgs.push("--user", user);
+			execArgs.push(containerId, "sh", "-c", `mkdir -p ${shellEscape(dir)} && cat > ${shellEscape(resolved)}`);
+			const proc = DEFAULT_SPAWNER.spawn(binary, execArgs, { stdio: [
+				"pipe",
+				"ignore",
+				"ignore"
+			] });
+			proc.stdin?.write?.(encoded);
+			proc.stdin?.end();
+			const result = await proc.wait();
+			if (result.exitCode !== 0) throw new ContainerExecError(`writeFile failed for ${resolved} (exit ${result.exitCode})`);
+		},
+		async readFile(path) {
+			assertRunning();
+			const resolved = posix.isAbsolute(path) ? path : posix.resolve(workdir, path);
+			const { stdout } = await runOci(binary, [
+				"exec",
+				containerId,
+				"cat",
+				resolved
+			]);
+			return stdout;
+		},
+		async fileExists(path) {
+			assertRunning();
+			const resolved = posix.isAbsolute(path) ? path : posix.resolve(workdir, path);
+			try {
+				await runOci(binary, [
+					"exec",
+					containerId,
+					"test",
+					"-e",
+					resolved
+				]);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async mkdir(path) {
+			assertRunning();
+			const resolved = posix.isAbsolute(path) ? path : posix.resolve(workdir, path);
+			await runOci(binary, [
+				"exec",
+				containerId,
+				"mkdir",
+				"-p",
+				resolved
+			]);
+		},
+		async execShell(script, options = {}) {
+			return instance.exec("sh", ["-c", script], options);
+		},
+		async logs(options = {}) {
+			assertNotDisposed();
+			const args = ["logs"];
+			if (options.tail !== void 0) args.push("--tail", String(options.tail));
+			args.push(containerId);
+			const { stdout } = await runOci(binary, args);
+			return stdout;
+		},
+		async syncStatus() {
+			assertNotDisposed();
+			try {
+				const { stdout } = await runOci(binary, [
+					"inspect",
+					"--format",
+					"{{.State.Status}}",
+					containerId
+				]);
+				const raw = stdout.trim();
+				if (raw === "running") status = "running";
+				else if (raw === "created") status = "created";
+				else status = "stopped";
+			} catch {
+				status = "disposed";
+			}
+			return status;
+		},
+		async snapshotWorkdir(options = {}) {
+			return diffApi.snapshotWorkdir(options);
+		},
+		async diffWorkdir(snapshot) {
+			return diffApi.diffWorkdir(snapshot);
+		},
+		async releaseWorkdirSnapshot(snapshot) {
+			return diffApi.releaseWorkdirSnapshot(snapshot);
+		},
+		getMappedPort(containerPort) {
+			return portMappings.get(containerPort);
+		},
+		[Symbol.asyncDispose]() {
+			return instance.dispose();
+		}
+	};
+	return instance;
+};
+const resolveOciImage = async (binary, provider) => {
+	if (provider.image) return provider.image;
+	if (provider.build) return buildOciImage(binary, provider.build);
+	throw new ContainerCreateError("Either image or build must be provided.");
+};
+//#endregion
+export { resolveOciImage as n, createOciContainer 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-nxuRbYIu.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,2 @@
+import { a as sessionEndEventSchema, c as toolCallEventSchema, d as contentPartSchema, f as imageContentPartSchema, i as reasoningEventSchema, l as toolResultEventSchema, n as eventSchema, o as sessionStartEventSchema, p as textContentPartSchema, r as messageEventSchema, s as stderrEventSchema, t as baseEventSchema, u as agentCapabilitiesSchema } from "../schemas-DwD4pwJB.mjs";
+export { agentCapabilitiesSchema, baseEventSchema, contentPartSchema, eventSchema, imageContentPartSchema, messageEventSchema, reasoningEventSchema, sessionEndEventSchema, sessionStartEventSchema, stderrEventSchema, textContentPartSchema, toolCallEventSchema, toolResultEventSchema };