coding-agents-sdk 0.2.0 → 0.3.0

package/dist/oci-DMZZQZ47.mjs

@@ -1,438 +0,0 @@
-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-DwD4pwJB.mjs

@@ -1,96 +0,0 @@
-import { z } from "zod/v4";
-//#region src/schemas/agent.ts
-const textContentPartSchema = z.object({
-	type: z.literal("text"),
-	text: z.string()
-});
-const imageContentPartSchema = z.object({
-	type: z.literal("image"),
-	path: z.string(),
-	mediaType: z.string().optional()
-});
-const contentPartSchema = z.discriminatedUnion("type", [textContentPartSchema, imageContentPartSchema]);
-const agentCapabilitiesSchema = z.object({
-	structuredOutput: z.boolean(),
-	sessionResume: z.boolean(),
-	imageInput: z.boolean(),
-	mcp: z.boolean(),
-	eventStreaming: z.boolean(),
-	sessionFork: z.boolean().optional()
-});
-//#endregion
-//#region src/schemas/events.ts
-const baseEventSchema = z.object({
-	id: z.string(),
-	runId: z.string(),
-	timestamp: z.date()
-});
-const sessionStartEventSchema = baseEventSchema.extend({
-	type: z.literal("session-start"),
-	requestedSessionId: z.string().optional(),
-	sessionId: z.string().optional(),
-	resumed: z.boolean()
-});
-const messageEventSchema = baseEventSchema.extend({
-	type: z.literal("message"),
-	sessionId: z.string().optional(),
-	model: z.string().nullable(),
-	role: z.enum([
-		"system",
-		"user",
-		"assistant"
-	]),
-	content: z.array(contentPartSchema),
-	text: z.string().optional()
-});
-const reasoningEventSchema = baseEventSchema.extend({
-	type: z.literal("reasoning"),
-	sessionId: z.string().optional(),
-	model: z.string().nullable(),
-	content: z.array(contentPartSchema),
-	text: z.string().optional()
-});
-const toolCallEventSchema = baseEventSchema.extend({
-	type: z.literal("tool-call"),
-	sessionId: z.string().optional(),
-	model: z.string().nullable(),
-	toolCallId: z.string(),
-	toolName: z.string(),
-	input: z.unknown().optional()
-});
-const toolResultEventSchema = baseEventSchema.extend({
-	type: z.literal("tool-result"),
-	sessionId: z.string().optional(),
-	toolCallId: z.string(),
-	toolName: z.string().optional(),
-	input: z.unknown().optional(),
-	output: z.unknown(),
-	isError: z.boolean().optional(),
-	error: z.string().optional()
-});
-const stderrEventSchema = baseEventSchema.extend({
-	type: z.literal("stderr"),
-	sessionId: z.string().optional(),
-	text: z.string()
-});
-const sessionEndEventSchema = baseEventSchema.extend({
-	type: z.literal("session-end"),
-	sessionId: z.string().optional(),
-	status: z.enum([
-		"completed",
-		"failed",
-		"cancelled"
-	]),
-	error: z.string().optional()
-});
-const eventSchema = z.discriminatedUnion("type", [
-	sessionStartEventSchema,
-	messageEventSchema,
-	reasoningEventSchema,
-	toolCallEventSchema,
-	toolResultEventSchema,
-	stderrEventSchema,
-	sessionEndEventSchema
-]);
-//#endregion
-export { sessionEndEventSchema as a, toolCallEventSchema as c, contentPartSchema as d, imageContentPartSchema as f, reasoningEventSchema as i, toolResultEventSchema as l, eventSchema as n, sessionStartEventSchema as o, textContentPartSchema as p, messageEventSchema as r, stderrEventSchema as s, baseEventSchema as t, agentCapabilitiesSchema as u };

package/dist/spawner-Bw9UBEGX.mjs

@@ -1,54 +0,0 @@
-import { spawn } from "node:child_process";
-//#region src/core/process/spawner.ts
-const streamToAsyncIterable = (stream) => ({ async *[Symbol.asyncIterator]() {
-	for await (const chunk of stream) {
-		if (chunk instanceof Buffer) {
-			yield new Uint8Array(chunk);
-			continue;
-		}
-		if (typeof chunk === "string") {
-			yield new TextEncoder().encode(chunk);
-			continue;
-		}
-		if (chunk instanceof Uint8Array) {
-			yield chunk;
-			continue;
-		}
-		throw new Error(`Unsupported stdout/stderr chunk type: ${typeof chunk}`);
-	}
-} });
-const spawnProcess = (command, args, options = {}) => {
-	const child = spawn(command, args, {
-		cwd: options.cwd,
-		env: options.env,
-		stdio: options.stdio
-	});
-	const waitPromise = new Promise((resolve, reject) => {
-		const onClose = (exitCode, signal) => {
-			child.removeListener("error", onError);
-			resolve({
-				exitCode,
-				signal
-			});
-		};
-		const onError = (err) => {
-			child.removeListener("close", onClose);
-			reject(err);
-		};
-		child.once("error", onError);
-		child.once("close", onClose);
-	});
-	return {
-		stdout: child.stdout ? streamToAsyncIterable(child.stdout) : null,
-		stderr: child.stderr ? streamToAsyncIterable(child.stderr) : null,
-		stdin: child.stdin ? {
-			write: (chunk) => child.stdin?.write(chunk),
-			end: () => child.stdin?.end()
-		} : null,
-		kill: (signal) => child.kill(signal),
-		wait: () => waitPromise
-	};
-};
-const DEFAULT_SPAWNER = { spawn: spawnProcess };
-//#endregion
-export { DEFAULT_SPAWNER as t };

package/dist/structured-output-BHtr_zpz.mjs

@@ -1,19 +0,0 @@
-//#region src/core/structured-output.ts
-const findStructuredOutputToolCallInput = (toolCalls) => {
-	let latestInput;
-	for (const [, record] of toolCalls) if (record.toolName === "StructuredOutput" && record.input !== void 0) latestInput = record.input;
-	return latestInput;
-};
-const extractClaudeStructuredOutput = (structuredOutput, context, eventMeta, errorMessage) => {
-	if (structuredOutput !== void 0) return { value: structuredOutput };
-	if (!context.schemaRequested) return {};
-	const toolCallOutput = findStructuredOutputToolCallInput(context.toolCalls);
-	if (toolCallOutput !== void 0) return { value: toolCallOutput };
-	if (eventMeta.isSuccess) return { error: {
-		kind: "parse",
-		message: errorMessage
-	} };
-	return {};
-};
-//#endregion
-export { extractClaudeStructuredOutput as t };

package/dist/types-aNMD8h3x.mjs

@@ -1,19 +0,0 @@
-//#region src/core/agent/types.ts
-/** Thrown by `runOrThrow()` when the run does not complete successfully. carries the full `RunResult` on `.result`. */
-var AgentRunError = class extends Error {
-	result;
-	constructor(result) {
-		super(result.error.message);
-		this.name = "AgentRunError";
-		this.result = result;
-	}
-};
-/** Thrown when agent configuration or request parameters are invalid (e.g. unsupported capability, empty input) */
-var AgentValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "AgentValidationError";
-	}
-};
-//#endregion
-export { AgentValidationError as n, AgentRunError as t };

package/dist/util-B4RQZkKr.mjs

@@ -1,77 +0,0 @@
-//#region src/core/util.ts
-const toArray = (value) => {
-	return Array.isArray(value) ? value : [value];
-};
-const formatError = (error) => error instanceof Error ? error.message : String(error);
-const isRecord = (value) => typeof value === "object" && value !== null;
-const sumTokens = (...values) => values.reduce((sum, v) => sum + (v ?? 0), 0);
-const stripMarkdownCodeFence = (value) => {
-	const trimmed = value.trim();
-	if (!trimmed.startsWith("```")) return trimmed;
-	return trimmed.replace(/^```[\w-]*\s*/i, "").replace(/\s*```$/i, "").trim();
-};
-const extractMarkdownCodeBlock = (value) => {
-	return /```[\w-]*\s*([\S\s]*?)\s*```/i.exec(value)?.[1]?.trim();
-};
-const extractBalancedJson = (value) => {
-	let start = -1;
-	const stack = [];
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < value.length; index++) {
-		const char = value[index];
-		if (!char) continue;
-		if (start === -1) {
-			if (char === "{" || char === "[") {
-				start = index;
-				stack.push(char);
-			}
-			continue;
-		}
-		if (inString) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			continue;
-		}
-		if (char === "{" || char === "[") {
-			stack.push(char);
-			continue;
-		}
-		if (char === "}" || char === "]") {
-			const open = stack.pop();
-			if (open === "{" && char !== "}" || open === "[" && char !== "]") return;
-			if (stack.length === 0) return value.slice(start, index + 1).trim();
-		}
-	}
-};
-const parseJsonResponseText = (value) => {
-	const trimmed = value.trim();
-	const candidates = [
-		stripMarkdownCodeFence(trimmed),
-		extractMarkdownCodeBlock(trimmed),
-		extractBalancedJson(trimmed)
-	];
-	let lastError;
-	for (const candidate of new Set(candidates)) {
-		if (!candidate) continue;
-		try {
-			return JSON.parse(candidate);
-		} catch (error) {
-			lastError = error;
-		}
-	}
-	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new SyntaxError("Failed to parse JSON response text.");
-};
-//#endregion
-export { toArray as a, sumTokens as i, isRecord as n, parseJsonResponseText as r, formatError as t };