coding-agents-sdk 0.0.1 → 0.2.0

package/dist/diff-De8d3MVb.mjs

@@ -0,0 +1,333 @@
+import { t as formatError } from "./util-B4RQZkKr.mjs";
+import { n as ContainerDiffError, o as ContainerNotRunningError, r as ContainerDisposedError } from "./errors-BAmHDQu8.mjs";
+import { createReadStream } from "node:fs";
+import { copyFile, lstat, mkdir, mkdtemp, readdir, readlink, rm, stat, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, posix, relative, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promisify } from "node:util";
+import { pipeline } from "node:stream/promises";
+//#region src/core/process/errors.ts
+const isExecFileError = (error) => {
+	return error instanceof Error && "code" in error && ("stdout" in error || "stderr" in error);
+};
+//#endregion
+//#region src/core/process/shell.ts
+const shellEscape = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+//#endregion
+//#region src/container/diff.ts
+const execFileAsync = promisify(execFile);
+const isRelativePath = (value) => {
+	return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+};
+const toPosixRelativePath = (rootDir, absolutePath) => {
+	const relativePath = relative(rootDir, absolutePath);
+	if (!isRelativePath(relativePath)) return;
+	return relativePath.split(sep).join(posix.sep);
+};
+const relativizeGitPath = (absolutePath, beforeDir, afterDir) => {
+	const beforePath = toPosixRelativePath(beforeDir, absolutePath);
+	if (beforePath !== void 0) return beforePath;
+	const afterPath = toPosixRelativePath(afterDir, absolutePath);
+	if (afterPath !== void 0) return afterPath;
+	throw new ContainerDiffError(`Git diff produced a path outside the materialized trees: ${absolutePath}`);
+};
+const sortFileChanges = (changes) => changes.sort((left, right) => {
+	if (left.path === right.path) return (left.previousPath ?? "").localeCompare(right.previousPath ?? "");
+	return left.path.localeCompare(right.path);
+});
+const removeGitMetadataDirs = async (rootDir) => {
+	const entries = await readdir(rootDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(rootDir, entry.name);
+		if (entry.name === ".git") {
+			await rm(fullPath, {
+				recursive: true,
+				force: true
+			});
+			continue;
+		}
+		if (entry.isDirectory()) await removeGitMetadataDirs(fullPath);
+	}
+};
+const createTempTree = () => mkdtemp(join(tmpdir(), "cw-workdir-diff-"));
+const cleanupTempTree = async (path) => {
+	if (!path) return;
+	await rm(path, {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+};
+const createSnapshot = (meta, snapshotMetadata) => {
+	const snapshot = {
+		cwd: meta.cwd,
+		createdAt: /* @__PURE__ */ new Date()
+	};
+	snapshotMetadata.set(snapshot, meta);
+	return snapshot;
+};
+const getSnapshotMeta = (owner, snapshot, snapshotMetadata) => {
+	if (typeof snapshot !== "object" || snapshot === null) throw new ContainerDiffError("Invalid workdir snapshot.");
+	const meta = snapshotMetadata.get(snapshot);
+	if (!meta) throw new ContainerDiffError("Invalid workdir snapshot.");
+	if (meta.owner !== owner) throw new ContainerDiffError("Workdir snapshot was created by a different container instance.");
+	return meta;
+};
+const assertSnapshotActive = (snapshot, activeSnapshots) => {
+	if (!activeSnapshots.has(snapshot)) throw new ContainerDiffError("Workdir snapshot has been released.");
+};
+const createContentHash = (value) => createHash("sha256").update(value).digest("hex");
+const toBuffer = (value) => Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
+const hashFileStream = async (path) => {
+	const hash = createHash("sha256");
+	await pipeline(createReadStream(path), hash);
+	return hash.digest("hex");
+};
+const getFileMetadata = async (rootDir, relativePath, cache) => {
+	const cacheKey = `${rootDir}:${relativePath}`;
+	if (cache.has(cacheKey)) return cache.get(cacheKey);
+	const absolutePath = join(rootDir, ...relativePath.split(posix.sep));
+	try {
+		const entry = await lstat(absolutePath);
+		let hash;
+		let size;
+		if (entry.isSymbolicLink()) {
+			const linkTarget = Buffer.from(await readlink(absolutePath));
+			hash = createContentHash(linkTarget);
+			size = linkTarget.byteLength;
+		} else if (entry.isFile()) {
+			hash = await hashFileStream(absolutePath);
+			size = entry.size;
+		} else throw new ContainerDiffError(`Unsupported filesystem entry in diff metadata: ${absolutePath}`);
+		const metadata = {
+			hash,
+			size
+		};
+		cache.set(cacheKey, metadata);
+		return metadata;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+			cache.set(cacheKey, void 0);
+			return;
+		}
+		throw error;
+	}
+};
+const parseGitDiffOutput = (stdout, beforeDir, afterDir) => {
+	if (stdout.byteLength === 0) return [];
+	const fields = stdout.toString("utf8").split("\0");
+	if (fields[fields.length - 1] === "") fields.pop();
+	const changes = [];
+	for (let index = 0; index < fields.length;) {
+		const status = fields[index++];
+		if (!status) continue;
+		if (status.startsWith("R")) {
+			const previousPath = fields[index++];
+			const path = fields[index++];
+			if (!previousPath || !path) throw new ContainerDiffError("Failed to parse git rename entry.");
+			changes.push({
+				kind: "renamed",
+				previousPath: relativizeGitPath(previousPath, beforeDir, afterDir),
+				path: relativizeGitPath(path, beforeDir, afterDir)
+			});
+			continue;
+		}
+		const path = fields[index++];
+		if (!path) throw new ContainerDiffError("Failed to parse git diff entry.");
+		switch (status) {
+			case "A":
+				changes.push({
+					kind: "added",
+					path: relativizeGitPath(path, beforeDir, afterDir)
+				});
+				break;
+			case "D":
+				changes.push({
+					kind: "deleted",
+					path: relativizeGitPath(path, beforeDir, afterDir)
+				});
+				break;
+			case "M":
+				changes.push({
+					kind: "modified",
+					path: relativizeGitPath(path, beforeDir, afterDir)
+				});
+				break;
+			case "T":
+				changes.push({
+					kind: "modified",
+					path: relativizeGitPath(path, beforeDir, afterDir)
+				});
+				break;
+			default: throw new ContainerDiffError(`Unsupported git diff change kind: ${status}`);
+		}
+	}
+	return changes;
+};
+const runGitDiff = async (beforeDir, afterDir) => {
+	try {
+		return parseGitDiffOutput(toBuffer((await execFileAsync("git", [
+			"diff",
+			"--no-index",
+			"-z",
+			"--name-status",
+			"-M",
+			"--find-renames=100%",
+			beforeDir,
+			afterDir
+		], {
+			cwd: tmpdir(),
+			encoding: "buffer",
+			maxBuffer: 50 * 1024 * 1024
+		})).stdout), beforeDir, afterDir);
+	} catch (error) {
+		if (!isExecFileError(error)) throw new ContainerDiffError(`Failed to run git diff: ${formatError(error)}`);
+		const code = error.code ?? 1;
+		const stdout = Buffer.isBuffer(error.stdout) ? error.stdout : Buffer.from(String(error.stdout ?? ""), "utf8");
+		const stderr = Buffer.isBuffer(error.stderr) ? error.stderr : Buffer.from(String(error.stderr ?? ""), "utf8");
+		if (code === 0 || code === 1) return parseGitDiffOutput(stdout, beforeDir, afterDir);
+		throw new ContainerDiffError(`Failed to run git diff: ${stderr.toString("utf8").trim() || stdout.toString("utf8").trim() || `exit code ${code}`}`);
+	}
+};
+const enrichFileChanges = async (changes, beforeDir, afterDir) => {
+	const metadataCache = /* @__PURE__ */ new Map();
+	return sortFileChanges(await Promise.all(changes.map(async (change) => {
+		let beforePath;
+		if (change.kind === "added") beforePath = void 0;
+		else if (change.kind === "renamed") beforePath = change.previousPath;
+		else beforePath = change.path;
+		const afterPath = change.kind === "deleted" ? void 0 : change.path;
+		const [beforeMetadata, afterMetadata] = await Promise.all([beforePath === void 0 ? void 0 : getFileMetadata(beforeDir, beforePath, metadataCache), afterPath === void 0 ? void 0 : getFileMetadata(afterDir, afterPath, metadataCache)]);
+		return {
+			path: change.path,
+			previousPath: change.previousPath,
+			kind: change.kind,
+			beforeHash: beforeMetadata?.hash,
+			afterHash: afterMetadata?.hash,
+			beforeSize: beforeMetadata?.size,
+			afterSize: afterMetadata?.size
+		};
+	})));
+};
+const buildChangedFiles = (fileChanges) => {
+	const changedFiles = /* @__PURE__ */ new Set();
+	for (const change of fileChanges) {
+		changedFiles.add(change.path);
+		if (change.kind === "renamed" && change.previousPath) changedFiles.add(change.previousPath);
+	}
+	return [...changedFiles].sort((left, right) => left.localeCompare(right));
+};
+const wrapMaterializeError = (action, error) => {
+	if (error instanceof ContainerDiffError || error instanceof ContainerDisposedError || error instanceof ContainerNotRunningError) throw error;
+	throw new ContainerDiffError(`${action}: ${formatError(error)}`);
+};
+const copyLocalDirectoryContents = async (sourceDir, targetDir) => {
+	if (!(await stat(sourceDir)).isDirectory()) throw new ContainerDiffError(`Target path is not a directory: ${sourceDir}`);
+	await mkdir(targetDir, { recursive: true });
+	const entries = await readdir(sourceDir, { withFileTypes: true });
+	await Promise.all(entries.filter((entry) => entry.name !== ".git").map(async (entry) => {
+		const sourcePath = join(sourceDir, entry.name);
+		const targetPath = join(targetDir, entry.name);
+		if (entry.isDirectory()) {
+			await copyLocalDirectoryContents(sourcePath, targetPath);
+			return;
+		}
+		if (entry.isSymbolicLink()) {
+			await mkdir(dirname(targetPath), { recursive: true });
+			await symlink(await readlink(sourcePath), targetPath);
+			return;
+		}
+		if (entry.isFile()) {
+			await mkdir(dirname(targetPath), { recursive: true });
+			await copyFile(sourcePath, targetPath);
+			return;
+		}
+		throw new ContainerDiffError(`Unsupported filesystem entry in workdir diff: ${sourcePath}`);
+	}));
+};
+const createWorkdirDiffApi = (options) => {
+	const activeSnapshots = /* @__PURE__ */ new Set();
+	const snapshotMetadata = /* @__PURE__ */ new WeakMap();
+	const snapshotWorkdir = async (snapshotOptions = {}) => {
+		const cwd = snapshotOptions.cwd ?? options.workdir;
+		let tempDir;
+		try {
+			tempDir = await createTempTree();
+			await options.materialize(cwd, tempDir);
+			await removeGitMetadataDirs(tempDir);
+			const snapshotMeta = {
+				owner: options.owner,
+				tempDir,
+				cwd,
+				inFlightDiffs: 0,
+				released: false
+			};
+			activeSnapshots.add(snapshotMeta);
+			tempDir = void 0;
+			return createSnapshot(snapshotMeta, snapshotMetadata);
+		} catch (error) {
+			await cleanupTempTree(tempDir);
+			return wrapMaterializeError("Failed to materialize workdir snapshot", error);
+		}
+	};
+	const diffWorkdir = async (snapshot) => {
+		const startedAt = Date.now();
+		const snapshotMeta = getSnapshotMeta(options.owner, snapshot, snapshotMetadata);
+		assertSnapshotActive(snapshotMeta, activeSnapshots);
+		snapshotMeta.inFlightDiffs++;
+		let currentTempDir;
+		try {
+			currentTempDir = await createTempTree();
+			await options.materialize(snapshotMeta.cwd, currentTempDir);
+			await removeGitMetadataDirs(currentTempDir);
+			const fileChanges = await enrichFileChanges(await runGitDiff(snapshotMeta.tempDir, currentTempDir), snapshotMeta.tempDir, currentTempDir);
+			const changedFiles = buildChangedFiles(fileChanges);
+			return {
+				cwd: snapshotMeta.cwd,
+				changedFiles,
+				fileChanges,
+				stats: {
+					durationMs: Date.now() - startedAt,
+					filesCompared: changedFiles.length
+				}
+			};
+		} catch (error) {
+			return wrapMaterializeError("Failed to diff workdir snapshot", error);
+		} finally {
+			snapshotMeta.inFlightDiffs--;
+			if (snapshotMeta.inFlightDiffs === 0) {
+				snapshotMeta.resolveIdle?.();
+				snapshotMeta.resolveIdle = void 0;
+			}
+			await cleanupTempTree(currentTempDir);
+		}
+	};
+	const releaseSnapshot = (snapshotMeta) => {
+		const meta = snapshotMeta;
+		if (meta.releasePromise) return meta.releasePromise;
+		meta.released = true;
+		activeSnapshots.delete(meta);
+		meta.releasePromise = (async () => {
+			if (meta.inFlightDiffs > 0) await new Promise((resolve) => {
+				meta.resolveIdle = resolve;
+			});
+			await cleanupTempTree(meta.tempDir);
+		})();
+		return meta.releasePromise;
+	};
+	const releaseWorkdirSnapshot = async (snapshot) => {
+		await releaseSnapshot(getSnapshotMeta(options.owner, snapshot, snapshotMetadata));
+	};
+	const disposeSnapshots = async () => {
+		await Promise.all(Array.from(activeSnapshots).map(releaseSnapshot));
+	};
+	return {
+		snapshotWorkdir,
+		diffWorkdir,
+		releaseWorkdirSnapshot,
+		disposeSnapshots
+	};
+};
+//#endregion
+export { isExecFileError as i, createWorkdirDiffApi as n, shellEscape as r, copyLocalDirectoryContents as t };

package/dist/errors-BAmHDQu8.mjs

@@ -0,0 +1,45 @@
+//#region src/container/errors.ts
+var ContainerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerError";
+	}
+};
+var ContainerCreateError = class extends ContainerError {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerCreateError";
+	}
+};
+var ContainerStartError = class extends ContainerError {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerStartError";
+	}
+};
+var ContainerExecError = class extends ContainerError {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerExecError";
+	}
+};
+var ContainerNotRunningError = class extends ContainerError {
+	constructor(message = "Container is not running.") {
+		super(message);
+		this.name = "ContainerNotRunningError";
+	}
+};
+var ContainerDisposedError = class extends ContainerError {
+	constructor(message = "Container has been disposed.") {
+		super(message);
+		this.name = "ContainerDisposedError";
+	}
+};
+var ContainerDiffError = class extends ContainerError {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerDiffError";
+	}
+};
+//#endregion
+export { ContainerExecError as a, ContainerError as i, ContainerDiffError as n, ContainerNotRunningError as o, ContainerDisposedError as r, ContainerStartError as s, ContainerCreateError as t };

package/dist/events-nxuRbYIu.d.mts

@@ -0,0 +1,239 @@
+import { ZodType, z } from "zod/v4";
+
+//#region src/schemas/agent.d.ts
+declare const textContentPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+}, z.core.$strip>;
+type TextContentPart = z.infer<typeof textContentPartSchema>;
+declare const imageContentPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"image">;
+  path: z.ZodString;
+  mediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ImageContentPart = z.infer<typeof imageContentPartSchema>;
+declare const contentPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"image">;
+  path: z.ZodString;
+  mediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type ContentPart = z.infer<typeof contentPartSchema>;
+declare const agentCapabilitiesSchema: z.ZodObject<{
+  structuredOutput: z.ZodBoolean;
+  sessionResume: z.ZodBoolean;
+  imageInput: z.ZodBoolean;
+  mcp: z.ZodBoolean;
+  eventStreaming: z.ZodBoolean;
+  sessionFork: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type AgentCapabilities = z.infer<typeof agentCapabilitiesSchema>;
+type JsonSchema = Record<string, unknown> | ReturnType<typeof z.toJSONSchema>;
+type OutputSchema = JsonSchema | ZodType;
+interface McpServerConfig {
+  command?: string;
+  args?: string[];
+  url?: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+}
+//#endregion
+//#region src/schemas/events.d.ts
+declare const baseEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+}, z.core.$strip>;
+declare const sessionStartEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"session-start">;
+  requestedSessionId: z.ZodOptional<z.ZodString>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  resumed: z.ZodBoolean;
+}, z.core.$strip>;
+type SessionStartEvent = z.infer<typeof sessionStartEventSchema>;
+declare const messageEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"message">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  role: z.ZodEnum<{
+    system: "system";
+    user: "user";
+    assistant: "assistant";
+  }>;
+  content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>;
+  text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MessageEvent = z.infer<typeof messageEventSchema>;
+declare const reasoningEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"reasoning">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>;
+  text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ReasoningEvent = z.infer<typeof reasoningEventSchema>;
+declare const toolCallEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"tool-call">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type ToolCallEvent = z.infer<typeof toolCallEventSchema>;
+declare const toolResultEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"tool-result">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  toolCallId: z.ZodString;
+  toolName: z.ZodOptional<z.ZodString>;
+  input: z.ZodOptional<z.ZodUnknown>;
+  output: z.ZodUnknown;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ToolResultEvent = z.infer<typeof toolResultEventSchema>;
+declare const stderrEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"stderr">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  text: z.ZodString;
+}, z.core.$strip>;
+type StderrEvent = z.infer<typeof stderrEventSchema>;
+declare const sessionEndEventSchema: z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"session-end">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+  }>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SessionEndEvent = z.infer<typeof sessionEndEventSchema>;
+declare const eventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"session-start">;
+  requestedSessionId: z.ZodOptional<z.ZodString>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  resumed: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"message">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  role: z.ZodEnum<{
+    system: "system";
+    user: "user";
+    assistant: "assistant";
+  }>;
+  content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>;
+  text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"reasoning">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>;
+  text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"tool-call">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  model: z.ZodNullable<z.ZodString>;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"tool-result">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  toolCallId: z.ZodString;
+  toolName: z.ZodOptional<z.ZodString>;
+  input: z.ZodOptional<z.ZodUnknown>;
+  output: z.ZodUnknown;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"stderr">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  runId: z.ZodString;
+  timestamp: z.ZodDate;
+  type: z.ZodLiteral<"session-end">;
+  sessionId: z.ZodOptional<z.ZodString>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+  }>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type AgentEvent = z.infer<typeof eventSchema>;
+//#endregion
+export { OutputSchema as C, imageContentPartSchema as D, contentPartSchema as E, textContentPartSchema as O, McpServerConfig as S, agentCapabilitiesSchema as T, toolResultEventSchema as _, SessionStartEvent as a, ImageContentPart as b, ToolResultEvent as c, messageEventSchema as d, reasoningEventSchema as f, toolCallEventSchema as g, stderrEventSchema as h, SessionEndEvent as i, baseEventSchema as l, sessionStartEventSchema as m, MessageEvent as n, StderrEvent as o, sessionEndEventSchema as p, ReasoningEvent as r, ToolCallEvent as s, AgentEvent as t, eventSchema as u, AgentCapabilities as v, TextContentPart as w, JsonSchema as x, ContentPart as y };

package/dist/index-B3YqrgIp.d.mts

@@ -0,0 +1,45 @@
+import { S as McpServerConfig } from "./events-nxuRbYIu.mjs";
+import { f as EnsureDisjoint, l as BaseAgent, t as AgentEventHandler } from "./types-Cb_EXIEe.mjs";
+//#region src/adapters/claude-code-sdk/types.d.ts
+type ClaudeCodeSdkPermissionMode = "acceptEdits" | "bypassPermissions" | "default" | "dontAsk" | "plan";
+type ClaudeCodeSdkExecutable = "bun" | "deno" | "node";
+type ClaudeCodeSdkSettingSource = "local" | "project" | "user";
+type ClaudeCodeSdkSettings = Record<string, unknown> | string;
+interface ClaudeCodeSdkRunOptions {
+  allowedTools?: string[];
+  disallowedTools?: string[];
+  appendSystemPrompt?: string;
+  permissionMode?: ClaudeCodeSdkPermissionMode;
+  mcpServers?: Record<string, McpServerConfig>;
+  forkSession?: boolean;
+  maxTurns?: number;
+}
+interface ClaudeCodeSdkAgentOptions extends ClaudeCodeSdkRunOptions {
+  command?: string;
+  env?: Record<string, string | undefined>;
+  propagateEnv?: boolean;
+  executable?: ClaudeCodeSdkExecutable;
+  executableArgs?: string[];
+  settings?: ClaudeCodeSdkSettings;
+  settingSources?: ClaudeCodeSdkSettingSource[];
+  container?: never;
+  cwd?: string;
+  sessionId?: string;
+  model?: string;
+  systemPrompt?: string;
+  onEvent?: AgentEventHandler;
+}
+interface ClaudeCodeSdkAgent extends BaseAgent<EnsureDisjoint<ClaudeCodeSdkRunOptions>> {
+  readonly type: "claude-code-sdk";
+  fork: () => ClaudeCodeSdkAgent;
+}
+interface ClaudeCodeSdkEvent {
+  type: string;
+  session_id?: string;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/adapters/claude-code-sdk/adapter.d.ts
+declare const createClaudeCodeSdkAgent: (options?: ClaudeCodeSdkAgentOptions) => ClaudeCodeSdkAgent;
+//#endregion
+export { ClaudeCodeSdkExecutable as a, ClaudeCodeSdkSettingSource as c, ClaudeCodeSdkEvent as i, ClaudeCodeSdkSettings as l, ClaudeCodeSdkAgent as n, ClaudeCodeSdkPermissionMode as o, ClaudeCodeSdkAgentOptions as r, ClaudeCodeSdkRunOptions as s, createClaudeCodeSdkAgent as t };