coding-agents-sdk 0.0.1 → 0.2.0

package/dist/classify-error-pL6jeu4T.mjs

@@ -0,0 +1,456 @@
+import { n as AgentValidationError, t as AgentRunError } from "./types-aNMD8h3x.mjs";
+import { z } from "zod/v4";
+import { delimiter } from "node:path";
+//#region src/core/events.ts
+const generateRunId = () => crypto.randomUUID();
+const generateEventId = () => `evt_${crypto.randomUUID()}`;
+const toTextPart = (text) => ({
+	type: "text",
+	text
+});
+const getTextFromContent = (content) => {
+	return content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+};
+const getInputText = (input) => {
+	return input.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n\n");
+};
+const createEventParser = (schema) => (raw) => {
+	const result = schema.safeParse(raw);
+	return result.success ? result.data : null;
+};
+const createAgentEvent = (runId, type, fields) => {
+	return {
+		id: fields.id ?? generateEventId(),
+		runId,
+		timestamp: /* @__PURE__ */ new Date(),
+		type,
+		...fields
+	};
+};
+//#endregion
+//#region src/core/process/env.ts
+const resolvePathKey = (env) => Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+const buildBaseProcessEnv = (options = {}) => {
+	const env = options.propagateEnv === false ? {} : Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0));
+	const extraPaths = options.extraPaths ?? [];
+	if (extraPaths.length > 0) {
+		const pathKey = resolvePathKey(env);
+		const basePath = env[pathKey] ?? "";
+		env[pathKey] = [...extraPaths, basePath].filter(Boolean).join(delimiter);
+	}
+	return env;
+};
+//#endregion
+//#region src/core/agent/request.ts
+const isZodSchema = (schema) => schema instanceof z.ZodType;
+const normalizeSchema = (request) => {
+	if (!("schema" in request)) return { kind: "none" };
+	const { schema } = request;
+	if (isZodSchema(schema)) return {
+		kind: "zod",
+		jsonSchema: z.toJSONSchema(schema),
+		zodSchema: schema
+	};
+	return {
+		kind: "json-schema",
+		jsonSchema: schema
+	};
+};
+const normalizeRunRequest = (type, capabilities, defaults, request) => {
+	const input = typeof request.input === "string" ? [{
+		type: "text",
+		text: request.input
+	}] : request.input;
+	if (input.length === 0) throw new AgentValidationError("Run input cannot be empty.");
+	if (input.every((part) => part.type === "text" && part.text.trim() === "")) throw new AgentValidationError("Run input cannot be empty.");
+	if (!capabilities.imageInput && input.some((part) => part.type === "image")) throw new AgentValidationError(`${type} does not support image input.`);
+	const schema = normalizeSchema(request);
+	if (!capabilities.structuredOutput && schema.kind !== "none") throw new AgentValidationError(`${type} does not support structured output.`);
+	if (request.timeoutMs !== void 0 && (!Number.isFinite(request.timeoutMs) || request.timeoutMs <= 0)) throw new AgentValidationError("timeoutMs must be a positive finite number.");
+	return {
+		input,
+		schema,
+		cwd: request.cwd ?? defaults?.cwd,
+		model: request.model ?? defaults?.model,
+		systemPrompt: request.systemPrompt ?? defaults?.systemPrompt,
+		timeoutMs: request.timeoutMs,
+		signal: request.signal
+	};
+};
+//#endregion
+//#region src/core/agent/run-state.ts
+const finalizeStats = (run, endedAt) => {
+	if (!run.stats) return;
+	const durationMs = Math.max(0, endedAt.getTime() - run.startedAt.getTime());
+	run.stats = {
+		...run.stats,
+		durationMs: run.stats.durationMs ?? durationMs,
+		apiDurationMs: run.stats.apiDurationMs ?? durationMs
+	};
+};
+const applyStructuredOutput = (run, structuredOutput) => {
+	const schema = run.normalizedRequest.schema;
+	if (schema.kind === "none") return;
+	if (schema.kind === "zod") {
+		const parsed = schema.zodSchema.safeParse(structuredOutput);
+		if (!parsed.success) {
+			run.status = "failed";
+			run.error = {
+				kind: "parse",
+				message: parsed.error.message
+			};
+			return;
+		}
+		run.output.value = parsed.data;
+		return;
+	}
+	run.output.value = structuredOutput;
+};
+const recordRunEvent = (run, event) => {
+	run.events.push(event);
+	if (event.type !== "message" || event.role !== "assistant") return;
+	const text = event.text ?? getTextFromContent(event.content);
+	if (text) run.assistantTexts.push(text);
+};
+const applyMappedEventBatch = (run, batch, options = {}) => {
+	if (batch.sessionId) {
+		run.sessionId = batch.sessionId;
+		options.onSessionId?.(batch.sessionId);
+	}
+	for (const toolCall of batch.toolCalls ?? []) run.toolCalls.set(toolCall.toolCallId, {
+		toolName: toolCall.toolName,
+		input: toolCall.input
+	});
+	if (!batch.state) return;
+	const patch = batch.state;
+	if (patch.output) {
+		if ("text" in patch.output) run.output.text = patch.output.text;
+		if ("value" in patch.output) applyStructuredOutput(run, patch.output.value);
+	}
+	if ("stats" in patch) run.stats = patch.stats;
+	if ("status" in patch) run.status = patch.status;
+	if ("error" in patch) run.error = patch.error;
+};
+const hasMeaningfulEvent = (run) => {
+	return run.events.some((event) => event.type === "message" || event.type === "reasoning" || event.type === "tool-call" || event.type === "tool-result");
+};
+const resolveRunStatus = (run) => {
+	const missingStructuredOutput = run.normalizedRequest.schema.kind !== "none" && run.output.value === void 0;
+	if (run.stopReason === "user" || run.stopReason === "abort" || run.stopReason === "timeout") return "cancelled";
+	if (run.error) return run.error.kind === "abort" ? "cancelled" : "failed";
+	if (run.status) {
+		if (run.status === "completed" && missingStructuredOutput) return "failed";
+		return run.status;
+	}
+	if (run.processResult && run.processResult.exitCode !== null && run.processResult.exitCode !== 0) return "failed";
+	if (!hasMeaningfulEvent(run) && run.stderrLines.length > 0) return "failed";
+	if (missingStructuredOutput) return "failed";
+	return "completed";
+};
+const resolveRunError = (run, status) => {
+	const processResult = run.processResult;
+	const stderrText = run.stderrLines.join("\n");
+	if (run.stopReason === "user") return {
+		kind: "abort",
+		message: "Run stopped by user."
+	};
+	if (run.stopReason === "abort") return {
+		kind: "abort",
+		message: "Run aborted."
+	};
+	if (run.stopReason === "timeout") return {
+		kind: "abort",
+		message: `Run timed out after ${run.normalizedRequest.timeoutMs}ms.`
+	};
+	if (run.error) return run.error;
+	if (processResult && processResult.exitCode !== null && processResult.exitCode !== 0) return {
+		kind: "process",
+		message: stderrText || `Process exited with code ${processResult.exitCode}.`
+	};
+	if (status === "failed" && run.stderrLines.length > 0) return {
+		kind: "process",
+		message: stderrText
+	};
+	if (status === "failed" && run.normalizedRequest.schema.kind !== "none" && run.output.value === void 0) return {
+		kind: "parse",
+		message: "Structured output was requested but no structured output value was produced."
+	};
+};
+const buildRunResult = (type, run, endedAt, status, error) => {
+	const stderrText = run.stderrLines.join("\n");
+	const base = {
+		type,
+		runId: run.runId,
+		sessionId: run.sessionId,
+		text: run.output.text ?? run.assistantTexts.join("\n\n"),
+		events: [...run.events],
+		stats: run.stats,
+		timing: {
+			startedAt: run.startedAt,
+			endedAt,
+			durationMs: endedAt.getTime() - run.startedAt.getTime()
+		},
+		process: run.processResult ? {
+			exitCode: run.processResult.exitCode,
+			signal: run.processResult.signal,
+			stderr: stderrText
+		} : void 0
+	};
+	switch (status) {
+		case "completed":
+			if (run.normalizedRequest.schema.kind === "none") return {
+				...base,
+				status,
+				error: void 0,
+				cancelReason: void 0
+			};
+			return {
+				...base,
+				status,
+				output: run.output.value,
+				error: void 0,
+				cancelReason: void 0
+			};
+		case "failed": return {
+			...base,
+			status,
+			output: void 0,
+			error: error ?? {
+				kind: "process",
+				message: "Unknown error."
+			},
+			cancelReason: void 0
+		};
+		case "cancelled": return {
+			...base,
+			status,
+			output: void 0,
+			error: error ?? {
+				kind: "abort",
+				message: "Run cancelled."
+			},
+			cancelReason: run.stopReason ?? "user"
+		};
+		default: throw new Error("Unsupported run status.");
+	}
+};
+//#endregion
+//#region src/core/agent/AgentCore.ts
+const createInitialMetrics = () => {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		runCount: 0,
+		messagesReceived: 0,
+		toolCalls: 0,
+		errors: 0,
+		startedAt: now,
+		lastActivityAt: now
+	};
+};
+var AgentCore = class {
+	type;
+	capabilities;
+	currentRun;
+	eventHandlers = [];
+	_sessionId;
+	_metrics;
+	constructor(options) {
+		this.type = options.type;
+		this.capabilities = options.capabilities;
+		this._sessionId = options.sessionId;
+		this._metrics = createInitialMetrics();
+		if (options.onEvent) this.onEvent(options.onEvent);
+	}
+	onValidateRun(_request, _normalizedRequest) {}
+	async onDispose() {}
+	onHandlerError(_error) {}
+	get sessionId() {
+		return this._sessionId;
+	}
+	get metrics() {
+		return this._metrics;
+	}
+	get isRunning() {
+		return this.currentRun?.running ?? false;
+	}
+	onEvent(handler) {
+		this.eventHandlers.push(handler);
+		return () => {
+			const index = this.eventHandlers.indexOf(handler);
+			if (index >= 0) this.eventHandlers.splice(index, 1);
+		};
+	}
+	async run(request) {
+		if (this.currentRun?.running) throw new AgentValidationError("This agent is already running. Wait for it to finish first.");
+		const normalizedRequest = normalizeRunRequest(this.type, this.capabilities, this.runRequestDefaults, request);
+		this.onValidateRun(request, normalizedRequest);
+		const context = {
+			runId: generateRunId(),
+			startedAt: /* @__PURE__ */ new Date(),
+			requestedSessionId: this._sessionId,
+			sessionId: this._sessionId,
+			normalizedRequest,
+			events: [],
+			stderrLines: [],
+			assistantTexts: [],
+			toolCalls: /* @__PURE__ */ new Map(),
+			output: {}
+		};
+		const activeRun = {
+			context,
+			running: true,
+			promise: new Promise(() => {})
+		};
+		this._metrics.runCount++;
+		const promise = Promise.resolve().then(() => this.executeRunCore(context, request)).finally(() => {
+			activeRun.running = false;
+		});
+		activeRun.promise = promise;
+		this.currentRun = activeRun;
+		return promise;
+	}
+	async runOrThrow(request) {
+		const result = await this.run(request);
+		if (result.status !== "completed") throw new AgentRunError(result);
+		return result;
+	}
+	async stop() {
+		const run = this.currentRun?.context;
+		if (!run || !this.currentRun?.running) return void 0;
+		this.requestStop(run, "user");
+		try {
+			return await this.currentRun.promise;
+		} catch {
+			return;
+		}
+	}
+	reset() {
+		if (this.currentRun?.running) throw new AgentValidationError("Cannot reset agent state while a run is active. Call stop() and wait() first.");
+		this.currentRun = void 0;
+		this._sessionId = void 0;
+		this._metrics = createInitialMetrics();
+	}
+	wait() {
+		if (!this.currentRun) throw new AgentValidationError("There is no run to wait for.");
+		return this.currentRun.promise;
+	}
+	async dispose() {
+		if (this.currentRun?.running) {
+			this.requestStop(this.currentRun.context, "user");
+			try {
+				await this.currentRun.promise;
+			} catch {}
+		}
+		await this.onDispose();
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+	applyBatch(run, batch) {
+		applyMappedEventBatch(run, batch, { onSessionId: (sessionId) => {
+			this.setSessionId(sessionId);
+		} });
+		for (const event of batch.events) this.emit(run, event);
+	}
+	setupRunLifecycle(run) {
+		let runSettled = false;
+		const abortHandler = () => {
+			if (!runSettled) this.requestStop(run, "abort");
+		};
+		const timeoutHandle = run.normalizedRequest.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+			if (!runSettled) this.requestStop(run, "timeout");
+		}, run.normalizedRequest.timeoutMs);
+		timeoutHandle?.unref?.();
+		run.normalizedRequest.signal?.addEventListener("abort", abortHandler, { once: true });
+		const abortedBeforeStart = run.normalizedRequest.signal?.aborted === true;
+		if (abortedBeforeStart) this.requestStop(run, "abort");
+		const cleanup = () => {
+			runSettled = true;
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+			run.normalizedRequest.signal?.removeEventListener("abort", abortHandler);
+		};
+		return {
+			abortedBeforeStart,
+			cleanup
+		};
+	}
+	emitSessionStart(run) {
+		if (run.sessionStarted) return;
+		run.sessionStarted = true;
+		this.emit(run, createAgentEvent(run.runId, "session-start", {
+			requestedSessionId: run.requestedSessionId,
+			sessionId: run.sessionId,
+			resumed: run.requestedSessionId !== void 0
+		}));
+	}
+	emit(run, event) {
+		recordRunEvent(run, event);
+		this.updateMetrics(event);
+		for (const handler of this.eventHandlers) try {
+			handler(event);
+		} catch (error) {
+			this.onHandlerError(error);
+		}
+	}
+	requestStop(run, reason) {
+		if (run.stopReason) return;
+		run.stopReason = reason;
+		this.onStopRequested(run);
+	}
+	buildResult(run, endedAt) {
+		finalizeStats(run, endedAt);
+		const status = resolveRunStatus(run);
+		const error = resolveRunError(run, status);
+		if (run.sessionStarted) this.emit(run, createAgentEvent(run.runId, "session-end", {
+			sessionId: run.sessionId,
+			status,
+			error: error?.message
+		}));
+		return buildRunResult(this.type, run, endedAt, status, error);
+	}
+	setSessionId(sessionId) {
+		this._sessionId = sessionId;
+	}
+	updateMetrics(event) {
+		this._metrics.lastActivityAt = event.timestamp;
+		switch (event.type) {
+			case "message":
+				if (event.role === "assistant") this._metrics.messagesReceived++;
+				break;
+			case "tool-call":
+				this._metrics.toolCalls++;
+				break;
+			case "session-end":
+				if (event.status === "failed") this._metrics.errors++;
+				break;
+			default: break;
+		}
+	}
+};
+//#endregion
+//#region src/core/agent/classify-error.ts
+const SPAWN_CODES = new Set(["ENOENT", "ERR_MODULE_NOT_FOUND"]);
+const hasCode = (error) => "code" in error;
+const classifyRunError = (error, message) => {
+	const msg = message ?? (error instanceof Error ? error.message : String(error));
+	if (error instanceof Error) {
+		if (error.name === "AbortError") return {
+			kind: "abort",
+			message: msg
+		};
+		if (hasCode(error) && SPAWN_CODES.has(String(error.code))) return {
+			kind: "spawn",
+			message: msg
+		};
+		if (error instanceof SyntaxError) return {
+			kind: "parse",
+			message: msg
+		};
+	}
+	return {
+		kind: "provider",
+		message: msg
+	};
+};
+//#endregion
+export { buildBaseProcessEnv as a, getInputText as c, hasMeaningfulEvent as i, toTextPart as l, AgentCore as n, createAgentEvent as o, applyMappedEventBatch as r, createEventParser as s, classifyRunError as t };

package/dist/container/index.d.mts

@@ -0,0 +1,2 @@
+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";
+export { Container, ContainerBase, ContainerConfig, ContainerConfigBase, ContainerCreateError, ContainerDiffError, ContainerDisposedError, ContainerError, ContainerExecError, ContainerExecution, ContainerFileSystem, ContainerIdentity, ContainerLifecycle, ContainerNotRunningError, ContainerObservability, ContainerStartError, ContainerStatus, ContainerType, DockerBuildBase, DockerBuildConfig, DockerContainer, DockerContainerBase, DockerContainerConfig, DockerProviderConfig, E2BConnectConfig, E2BConnectionConfig, E2BContainer, E2BContainerBase, E2BContainerConfig, E2BCreateConfig, E2BProviderConfig, ExecOptions, ExecResult, PodmanBuildBase, PodmanBuildConfig, PodmanContainer, PodmanContainerBase, PodmanContainerConfig, PodmanProviderConfig, PortMapping, VolumeMount, WorkdirChangeKind, WorkdirDiff, WorkdirDiffStats, WorkdirFileChange, WorkdirSnapshot, WorkdirSnapshotOptions, createContainer };

package/dist/container/index.mjs

@@ -0,0 +1,24 @@
+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";
+//#region src/container/index.ts
+async function createContainer(config) {
+	switch (config.type) {
+		case "docker": {
+			const { createDockerContainer } = await import("../container-2UmPZ0CI.mjs");
+			return createDockerContainer(config);
+		}
+		case "e2b": try {
+			const { createE2BContainer } = await import("../container-CHxKIonn.mjs");
+			return await createE2BContainer(config);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("e2b") && (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND")) throw new ContainerCreateError("Container type \"e2b\" requires the optional peer dependency \"e2b\". Install it to use this provider.");
+			throw error;
+		}
+		case "podman": {
+			const { createPodmanContainer } = await import("../container-D2Z0ITDJ.mjs");
+			return createPodmanContainer(config);
+		}
+		default: throw new ContainerCreateError("Unsupported container type.");
+	}
+}
+//#endregion
+export { ContainerCreateError, ContainerDiffError, ContainerDisposedError, ContainerError, ContainerExecError, ContainerNotRunningError, ContainerStartError, createContainer };

package/dist/container-2UmPZ0CI.mjs

@@ -0,0 +1,22 @@
+import { n as resolveOciImage, t as createOciContainer } from "./oci-DMZZQZ47.mjs";
+//#region src/container/docker/container.ts
+const createDockerContainer = async (config) => {
+	const binary = config.binary ?? "docker";
+	const image = await resolveOciImage(binary, config);
+	return createOciContainer("docker", {
+		binary,
+		containerName: config.name,
+		workdir: config.workdir,
+		user: config.user,
+		network: config.network,
+		platform: config.platform,
+		env: config.env,
+		ports: config.ports,
+		mounts: config.mounts,
+		extraArgs: config.extraArgs,
+		image,
+		builtImage: config.build !== void 0 && !config.build.tag
+	}, config);
+};
+//#endregion
+export { createDockerContainer };