coding-agents-sdk 0.0.1 → 0.2.0

package/dist/adapters/claude-code-cli/index.mjs

@@ -0,0 +1,490 @@
+import { n as AgentValidationError } from "../../types-aNMD8h3x.mjs";
+import { a as toArray, i as sumTokens } from "../../util-B4RQZkKr.mjs";
+import { a as buildBaseProcessEnv, c as getInputText, l as toTextPart, o as createAgentEvent, s as createEventParser } from "../../classify-error-pL6jeu4T.mjs";
+import { t as Agent } from "../../Agent-D8WkUilj.mjs";
+import { t as extractClaudeStructuredOutput } from "../../structured-output-BHtr_zpz.mjs";
+import { z } from "zod/v4";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+//#region src/adapters/claude-code-cli/events/mappers.ts
+const getClaudeSessionId = (event) => {
+	return "session_id" in event ? event.session_id : void 0;
+};
+const getToolResultOutput = (content) => {
+	if (typeof content.content === "string") return content.content;
+	return content.content.map((part) => part.text).join("\n");
+};
+const getClaudeResultError = (event) => {
+	if (typeof event.result === "string" && event.result.trim() !== "") return event.result;
+	return event.subtype;
+};
+const mapSystemEvent = (event, context) => {
+	const parts = [`[${event.subtype}]`];
+	if (event.subtype === "init") {
+		if (event.tools) parts.push(`tools: ${event.tools.length}`);
+		if (event.mcp_servers) {
+			const connected = event.mcp_servers.filter((server) => server.status === "connected").length;
+			parts.push(`mcp: ${connected}/${event.mcp_servers.length} connected`);
+		}
+	} else if (event.hook_name) {
+		parts.push(event.hook_name);
+		if (event.exit_code !== void 0) parts.push(`exit: ${event.exit_code}`);
+	}
+	const text = parts.join(" ");
+	return { events: [createAgentEvent(context.runId, "message", {
+		sessionId: context.sessionId,
+		model: event.model ?? null,
+		role: "system",
+		content: [toTextPart(text)],
+		text
+	})] };
+};
+const mapAssistantEvent = (event, context) => {
+	const events = [];
+	const toolCalls = [];
+	for (const block of event.message.content) switch (block.type) {
+		case "text":
+			events.push(createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model: event.message.model ?? null,
+				role: "assistant",
+				content: [toTextPart(block.text)],
+				text: block.text
+			}));
+			break;
+		case "thinking":
+			events.push(createAgentEvent(context.runId, "reasoning", {
+				sessionId: context.sessionId,
+				model: event.message.model ?? null,
+				content: [toTextPart(block.thinking)],
+				text: block.thinking
+			}));
+			break;
+		case "tool_use":
+			toolCalls.push({
+				toolCallId: block.id,
+				toolName: block.name,
+				input: block.input
+			});
+			events.push(createAgentEvent(context.runId, "tool-call", {
+				sessionId: context.sessionId,
+				model: event.message.model ?? null,
+				toolCallId: block.id,
+				toolName: block.name,
+				input: block.input
+			}));
+			break;
+		default: break;
+	}
+	return {
+		events,
+		toolCalls
+	};
+};
+const mapUserEvent = (event, context) => {
+	const events = [];
+	for (const block of event.message.content) switch (block.type) {
+		case "text":
+			events.push(createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model: null,
+				role: "user",
+				content: [toTextPart(block.text)],
+				text: block.text
+			}));
+			break;
+		case "tool_result": {
+			const tool = context.toolCalls.get(block.tool_use_id);
+			const output = getToolResultOutput(block);
+			events.push(createAgentEvent(context.runId, "tool-result", {
+				sessionId: context.sessionId,
+				toolCallId: block.tool_use_id,
+				toolName: tool?.toolName,
+				input: tool?.input,
+				output,
+				isError: block.is_error,
+				error: block.is_error ? output : void 0
+			}));
+			break;
+		}
+		default: break;
+	}
+	return { events };
+};
+const mapResultEvent = (event, context) => {
+	const inputTokens = event.usage?.input_tokens;
+	const cacheCreationInputTokens = event.usage?.cache_creation_input_tokens;
+	const cacheReadInputTokens = event.usage?.cache_read_input_tokens;
+	const outputTokens = event.usage?.output_tokens;
+	const totalTokens = sumTokens(inputTokens, cacheCreationInputTokens, cacheReadInputTokens, outputTokens);
+	const state = { stats: {
+		durationMs: event.duration_ms,
+		apiDurationMs: event.duration_api_ms,
+		turns: event.num_turns,
+		inputTokens,
+		cacheCreationInputTokens,
+		cacheReadInputTokens,
+		outputTokens,
+		totalTokens,
+		costUsd: event.total_cost_usd
+	} };
+	if (typeof event.result === "string") state.output = {
+		...state.output,
+		text: event.result
+	};
+	const extraction = extractClaudeStructuredOutput(event.structured_output, context, { isSuccess: !event.is_error && event.subtype === "success" }, "Structured output was requested but Claude did not return structured_output.");
+	if (extraction.value !== void 0) state.output = {
+		...state.output,
+		value: extraction.value
+	};
+	if (extraction.error) state.error = extraction.error;
+	if (event.is_error || event.subtype !== "success") {
+		state.status = "failed";
+		state.error = {
+			kind: "provider",
+			message: getClaudeResultError(event)
+		};
+	} else if (!state.error) state.status = "completed";
+	return {
+		events: [],
+		state
+	};
+};
+const mapRateLimitEvent = (event, context) => {
+	const text = `rate limited: ${event.rate_limit_info.status}`;
+	return { events: [createAgentEvent(context.runId, "message", {
+		sessionId: context.sessionId,
+		model: null,
+		role: "system",
+		content: [toTextPart(text)],
+		text
+	})] };
+};
+const mapClaudeEvent = (event, context) => {
+	switch (event.type) {
+		case "system": return mapSystemEvent(event, context);
+		case "assistant": return mapAssistantEvent(event, context);
+		case "user": return mapUserEvent(event, context);
+		case "result": return mapResultEvent(event, context);
+		case "rate_limit_event": return mapRateLimitEvent(event, context);
+		default: return { events: [] };
+	}
+};
+//#endregion
+//#region src/adapters/claude-code-cli/events/schemas.ts
+const systemEventSubtypeSchema = z.enum([
+	"init",
+	"hook_response",
+	"hook_started",
+	"hook_finished",
+	"hook_failed",
+	"hook_skipped"
+]);
+const claudeSystemEventSchema = z.object({
+	type: z.literal("system"),
+	session_id: z.string(),
+	subtype: systemEventSubtypeSchema,
+	uuid: z.string(),
+	tools: z.array(z.string()).optional(),
+	mcp_servers: z.array(z.object({
+		name: z.string(),
+		status: z.enum([
+			"connected",
+			"disconnected",
+			"error",
+			"failed"
+		])
+	})).optional(),
+	model: z.string().optional(),
+	cwd: z.string().optional(),
+	hook_name: z.string().optional(),
+	hook_event: z.string().optional(),
+	stdout: z.string().optional(),
+	stderr: z.string().optional(),
+	exit_code: z.number().optional()
+});
+const claudeAssistantEventSchema = z.object({
+	type: z.literal("assistant"),
+	session_id: z.string(),
+	uuid: z.string(),
+	parent_tool_use_id: z.string().nullable().optional(),
+	message: z.object({
+		id: z.string(),
+		type: z.literal("message"),
+		role: z.literal("assistant"),
+		model: z.string(),
+		content: z.array(z.union([
+			z.object({
+				type: z.literal("text"),
+				text: z.string()
+			}),
+			z.object({
+				type: z.literal("tool_use"),
+				id: z.string(),
+				name: z.string(),
+				input: z.record(z.string(), z.unknown())
+			}),
+			z.object({
+				type: z.literal("thinking"),
+				thinking: z.string(),
+				signature: z.string().optional()
+			})
+		])),
+		stop_reason: z.enum([
+			"end_turn",
+			"max_tokens",
+			"tool_use",
+			"stop_sequence"
+		]).nullable(),
+		stop_sequence: z.string().nullable().optional(),
+		context_management: z.unknown().nullable().optional(),
+		usage: z.object({
+			input_tokens: z.number(),
+			output_tokens: z.number(),
+			cache_creation_input_tokens: z.number().optional(),
+			cache_read_input_tokens: z.number().optional(),
+			service_tier: z.enum(["premium", "standard"]).nullable().optional()
+		}),
+		ttftMs: z.number().optional()
+	})
+});
+const claudeUserEventSchema = z.object({
+	type: z.literal("user"),
+	session_id: z.string(),
+	message: z.object({
+		role: z.literal("user"),
+		content: z.array(z.union([z.object({
+			type: z.literal("tool_result"),
+			tool_use_id: z.string(),
+			content: z.union([z.string(), z.array(z.object({
+				type: z.literal("text"),
+				text: z.string()
+			}))]),
+			is_error: z.boolean().optional()
+		}), z.object({
+			type: z.literal("text"),
+			text: z.string()
+		})]))
+	}),
+	parent_tool_use_id: z.string().nullable().optional(),
+	uuid: z.string(),
+	isSynthetic: z.boolean().optional()
+});
+const claudeResultEventSchema = z.object({
+	type: z.literal("result"),
+	session_id: z.string(),
+	uuid: z.string(),
+	subtype: z.enum([
+		"success",
+		"error_max_turns",
+		"error_during_execution"
+	]),
+	duration_ms: z.number(),
+	duration_api_ms: z.number(),
+	is_error: z.boolean(),
+	num_turns: z.number(),
+	result: z.unknown().optional(),
+	structured_output: z.unknown().optional(),
+	total_cost_usd: z.number(),
+	usage: z.object({
+		input_tokens: z.number(),
+		cache_creation_input_tokens: z.number().optional(),
+		cache_read_input_tokens: z.number().optional(),
+		output_tokens: z.number(),
+		server_tool_use: z.object({ web_search_requests: z.number() }).optional()
+	}).optional()
+});
+const claudeRateLimitEventSchema = z.object({
+	type: z.literal("rate_limit_event"),
+	uuid: z.string(),
+	session_id: z.string().optional(),
+	rate_limit_info: z.object({
+		status: z.string(),
+		resetsAt: z.number().optional(),
+		rateLimitType: z.string().optional(),
+		overageStatus: z.string().optional(),
+		overageDisabledReason: z.string().optional(),
+		isUsingOverage: z.boolean().optional()
+	})
+});
+//#endregion
+//#region src/adapters/claude-code-cli/events/parser.ts
+const parseClaudeEvent = createEventParser(z.discriminatedUnion("type", [
+	claudeSystemEventSchema,
+	claudeAssistantEventSchema,
+	claudeUserEventSchema,
+	claudeResultEventSchema,
+	claudeRateLimitEventSchema
+]));
+//#endregion
+//#region src/adapters/claude-code-cli/adapter.ts
+const CLAUDE_CODE_CLI_CAPABILITIES = {
+	structuredOutput: true,
+	sessionResume: true,
+	imageInput: false,
+	mcp: true,
+	eventStreaming: true,
+	sessionFork: true
+};
+const toClaudeJsonSchema = (schema) => {
+	const { $schema, ...rest } = schema;
+	return rest;
+};
+var ClaudeCodeCliAgentImpl = class ClaudeCodeCliAgentImpl extends Agent {
+	type = "claude-code-cli";
+	creationOptions;
+	runDefaults;
+	forkOnNextRun;
+	mcpTempDir;
+	constructor(options = {}) {
+		super({
+			type: "claude-code-cli",
+			capabilities: CLAUDE_CODE_CLI_CAPABILITIES,
+			defaults: {
+				cwd: options.cwd,
+				env: options.env,
+				command: options.command ? toArray(options.command) : void 0,
+				sessionId: options.sessionId,
+				model: options.model,
+				systemPrompt: options.systemPrompt
+			},
+			spawner: options.spawner,
+			container: options.container,
+			logPath: options.logPath,
+			onEvent: options.onEvent
+		});
+		this.creationOptions = {
+			...options,
+			command: options.command ? [...toArray(options.command)] : void 0,
+			env: options.env ? { ...options.env } : void 0,
+			allowedTools: options.allowedTools ? [...options.allowedTools] : void 0,
+			disallowedTools: options.disallowedTools ? [...options.disallowedTools] : void 0,
+			mcpConfig: Array.isArray(options.mcpConfig) ? [...options.mcpConfig] : options.mcpConfig,
+			mcpServers: options.mcpServers ? { ...options.mcpServers } : void 0,
+			extraArgs: options.extraArgs ? [...options.extraArgs] : void 0
+		};
+		this.runDefaults = {
+			allowedTools: options.allowedTools ? [...options.allowedTools] : void 0,
+			disallowedTools: options.disallowedTools ? [...options.disallowedTools] : void 0,
+			appendSystemPrompt: options.appendSystemPrompt,
+			permissionMode: options.permissionMode,
+			mcpConfig: Array.isArray(options.mcpConfig) ? [...options.mcpConfig] : options.mcpConfig,
+			mcpServers: options.mcpServers ? { ...options.mcpServers } : void 0,
+			forkSession: options.forkSession,
+			extraArgs: options.extraArgs ? [...options.extraArgs] : void 0
+		};
+		this.forkOnNextRun = options.forkOnNextRun ?? false;
+	}
+	fork() {
+		if (!this.sessionId) throw new AgentValidationError("Cannot fork a Claude Code CLI agent before it has a sessionId.");
+		return new ClaudeCodeCliAgentImpl({
+			...this.creationOptions,
+			sessionId: this.sessionId,
+			forkSession: void 0,
+			forkOnNextRun: true
+		});
+	}
+	onValidateRun(request, _normalizedRequest) {
+		if ((request.forkSession ?? this.runDefaults.forkSession ?? this.forkOnNextRun) && !this.sessionId) throw new AgentValidationError("forkSession requires an existing sessionId on the agent.");
+	}
+	async onRunFinished(run) {
+		await super.onRunFinished(run);
+		await this.cleanupMcpTempDir();
+	}
+	async onDispose() {
+		await super.onDispose();
+		await this.cleanupMcpTempDir();
+	}
+	async cleanupMcpTempDir() {
+		if (this.mcpTempDir) {
+			const dir = this.mcpTempDir;
+			this.mcpTempDir = void 0;
+			await rm(dir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+	ensureMcpTempFile(servers) {
+		if (this.mcpTempDir) {
+			rmSync(this.mcpTempDir, {
+				recursive: true,
+				force: true
+			});
+			this.mcpTempDir = void 0;
+		}
+		this.mcpTempDir = mkdtempSync(join(tmpdir(), "cw-mcp-"));
+		const configPath = join(this.mcpTempDir, "mcp.json");
+		writeFileSync(configPath, JSON.stringify({ mcpServers: servers }), {
+			encoding: "utf8",
+			mode: 384
+		});
+		return configPath;
+	}
+	buildArgs(request, run) {
+		const args = [
+			"--verbose",
+			"--output-format",
+			"stream-json"
+		];
+		const inputText = getInputText(request.input);
+		const permissionMode = request.permissionMode ?? this.runDefaults.permissionMode;
+		const appendSystemPrompt = request.appendSystemPrompt ?? this.runDefaults.appendSystemPrompt;
+		const allowedTools = request.allowedTools ?? this.runDefaults.allowedTools;
+		const disallowedTools = request.disallowedTools ?? this.runDefaults.disallowedTools;
+		const mcpConfig = request.mcpConfig ?? this.runDefaults.mcpConfig;
+		const mcpServers = request.mcpServers ?? this.runDefaults.mcpServers;
+		const extraArgs = request.extraArgs ?? this.runDefaults.extraArgs;
+		const forkSession = request.forkSession ?? this.runDefaults.forkSession ?? this.forkOnNextRun;
+		if (request.model) args.push("--model", request.model);
+		if (request.systemPrompt) args.push("--system-prompt", request.systemPrompt);
+		if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+		if (permissionMode) args.push("--permission-mode", permissionMode);
+		if (allowedTools && allowedTools.length > 0) args.push("--allowed-tools", allowedTools.join(","));
+		if (disallowedTools && disallowedTools.length > 0) args.push("--disallowed-tools", disallowedTools.join(","));
+		if (mcpConfig) for (const config of toArray(mcpConfig)) args.push("--mcp-config", config);
+		if (mcpServers) args.push("--mcp-config", this.ensureMcpTempFile(mcpServers));
+		if (request.schema.kind !== "none") args.push("--json-schema", JSON.stringify(toClaudeJsonSchema(request.schema.jsonSchema)));
+		if (run.requestedSessionId) {
+			args.push("--resume", run.requestedSessionId);
+			if (forkSession) args.push("--fork-session");
+		}
+		if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
+		args.push("--print", inputText);
+		return args;
+	}
+	buildEnv(_request, _run) {
+		const env = buildBaseProcessEnv({ propagateEnv: this.creationOptions.propagateEnv });
+		if (this.creationOptions.ci !== false) env.CI = env.CI ?? "true";
+		if (this.defaults.env) Object.assign(env, this.defaults.env);
+		delete env.CLAUDECODE;
+		return env;
+	}
+	mapRawEvent(raw, context) {
+		this.appendRawLog(raw);
+		const parsed = parseClaudeEvent(raw);
+		if (!parsed) {
+			this.onParseError(JSON.stringify(raw).slice(0, 200), /* @__PURE__ */ new Error("schema validation failed"));
+			return { events: [] };
+		}
+		const sessionId = getClaudeSessionId(parsed) ?? context.sessionId;
+		if (this.forkOnNextRun && context.requestedSessionId && sessionId && sessionId !== context.requestedSessionId) this.forkOnNextRun = false;
+		const batch = mapClaudeEvent(parsed, {
+			...context,
+			sessionId
+		});
+		if (sessionId && batch.sessionId === void 0) batch.sessionId = sessionId;
+		return batch;
+	}
+};
+const createClaudeCodeCliAgent = (options) => {
+	if (!options?.container) return new ClaudeCodeCliAgentImpl(options);
+	return new ClaudeCodeCliAgentImpl({
+		...options,
+		spawner: options.container.spawner
+	});
+};
+//#endregion
+export { createClaudeCodeCliAgent };

package/dist/adapters/claude-code-sdk/index.d.mts

@@ -0,0 +1,2 @@
+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, t as createClaudeCodeSdkAgent } from "../../index-B3YqrgIp.mjs";
+export { ClaudeCodeSdkAgent, ClaudeCodeSdkAgentOptions, ClaudeCodeSdkEvent, ClaudeCodeSdkExecutable, ClaudeCodeSdkPermissionMode, ClaudeCodeSdkRunOptions, ClaudeCodeSdkSettingSource, ClaudeCodeSdkSettings, createClaudeCodeSdkAgent };