coding-agents-sdk 0.0.1 → 0.2.0

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

@@ -0,0 +1,483 @@
+import { n as AgentValidationError } from "../../types-aNMD8h3x.mjs";
+import { i as sumTokens, n as isRecord, r as parseJsonResponseText } from "../../util-B4RQZkKr.mjs";
+import { a as buildBaseProcessEnv, c as getInputText, l as toTextPart, o as createAgentEvent } from "../../classify-error-pL6jeu4T.mjs";
+import { t as extractClaudeStructuredOutput } from "../../structured-output-BHtr_zpz.mjs";
+import { t as SdkAgent } from "../../SdkAgent-B47mJiIE.mjs";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+//#region src/adapters/claude-code-sdk/events/mappers.ts
+const getString = (value, key) => {
+	if (!isRecord(value) || typeof value[key] !== "string") return;
+	return value[key];
+};
+const getNumber = (value, key) => {
+	if (!isRecord(value) || typeof value[key] !== "number") return;
+	return value[key];
+};
+const isTextBlock = (value) => {
+	return isRecord(value) && value.type === "text" && typeof value.text === "string";
+};
+const isThinkingBlock = (value) => {
+	return isRecord(value) && value.type === "thinking" && typeof value.thinking === "string";
+};
+const isToolUseBlock = (value) => {
+	return isRecord(value) && value.type === "tool_use" && typeof value.id === "string" && typeof value.name === "string";
+};
+const isToolResultBlock = (value) => {
+	return isRecord(value) && value.type === "tool_result" && typeof value.tool_use_id === "string";
+};
+const getAssistantBlocks = (event) => {
+	const content = isRecord(event.message) ? event.message.content : void 0;
+	return Array.isArray(content) ? content : [];
+};
+const getAssistantModel = (event, options) => {
+	return getString(event.message, "model") ?? options.model ?? null;
+};
+const getUserBlocks = (event) => {
+	const content = isRecord(event.message) ? event.message.content : void 0;
+	if (typeof content === "string") return [content];
+	return Array.isArray(content) ? content : [];
+};
+const getToolResultOutput = (content) => {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return content;
+	const textParts = content.flatMap((part) => isTextBlock(part) ? [part.text] : []);
+	if (textParts.length === content.length) return textParts.join("\n");
+	return content;
+};
+const toErrorText = (value) => {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+};
+const toStats = (event) => {
+	const inputTokens = getNumber(event.usage, "input_tokens");
+	const cacheCreationInputTokens = getNumber(event.usage, "cache_creation_input_tokens");
+	const cacheReadInputTokens = getNumber(event.usage, "cache_read_input_tokens");
+	const outputTokens = getNumber(event.usage, "output_tokens");
+	const totalTokens = sumTokens(inputTokens, cacheCreationInputTokens, cacheReadInputTokens, outputTokens);
+	return {
+		durationMs: event.duration_ms,
+		apiDurationMs: event.duration_api_ms,
+		turns: event.num_turns,
+		costUsd: event.total_cost_usd,
+		inputTokens,
+		cacheCreationInputTokens,
+		cacheReadInputTokens,
+		outputTokens,
+		totalTokens
+	};
+};
+const getResultErrorMessage = (event) => {
+	if ("errors" in event && Array.isArray(event.errors)) {
+		const messages = event.errors.filter((value) => typeof value === "string" && value.trim() !== "");
+		if (messages.length > 0) return messages.join("\n");
+	}
+	if (event.subtype === "error_max_structured_output_retries") return "Structured output retries were exhausted.";
+	return event.subtype;
+};
+const getClaudeCodeSdkSessionId = (event) => "session_id" in event ? event.session_id : void 0;
+const createSystemNoticeEvent = (runId, sessionId, text) => createAgentEvent(runId, "message", {
+	sessionId,
+	model: null,
+	role: "system",
+	content: [toTextPart(text)],
+	text
+});
+const mapAssistantEvent = (event, context, options) => {
+	const events = [];
+	const toolCalls = [];
+	const model = getAssistantModel(event, options);
+	for (const block of getAssistantBlocks(event)) {
+		if (isTextBlock(block)) {
+			events.push(createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model,
+				role: "assistant",
+				content: [toTextPart(block.text)],
+				text: block.text
+			}));
+			continue;
+		}
+		if (isThinkingBlock(block)) {
+			events.push(createAgentEvent(context.runId, "reasoning", {
+				sessionId: context.sessionId,
+				model,
+				content: [toTextPart(block.thinking)],
+				text: block.thinking
+			}));
+			continue;
+		}
+		if (isToolUseBlock(block)) {
+			toolCalls.push({
+				toolCallId: block.id,
+				toolName: block.name,
+				input: block.input
+			});
+			events.push(createAgentEvent(context.runId, "tool-call", {
+				sessionId: context.sessionId,
+				model,
+				toolCallId: block.id,
+				toolName: block.name,
+				input: block.input
+			}));
+		}
+	}
+	return {
+		events,
+		toolCalls
+	};
+};
+const mapUserEvent = (event, context) => {
+	const events = [];
+	for (const block of getUserBlocks(event)) {
+		if (typeof block === "string") {
+			events.push(createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model: null,
+				role: "user",
+				content: [toTextPart(block)],
+				text: block
+			}));
+			continue;
+		}
+		if (isTextBlock(block)) {
+			events.push(createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model: null,
+				role: "user",
+				content: [toTextPart(block.text)],
+				text: block.text
+			}));
+			continue;
+		}
+		if (isToolResultBlock(block)) {
+			const tool = context.toolCalls.get(block.tool_use_id);
+			const output = getToolResultOutput(block.content);
+			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 ? toErrorText(output) : void 0
+			}));
+		}
+	}
+	return { events };
+};
+const mapToolProgressEvent = (event, context, options) => {
+	if (context.toolCalls.has(event.tool_use_id)) return { events: [] };
+	return {
+		events: [createAgentEvent(context.runId, "tool-call", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			toolCallId: event.tool_use_id,
+			toolName: event.tool_name,
+			input: void 0
+		})],
+		toolCalls: [{
+			toolCallId: event.tool_use_id,
+			toolName: event.tool_name
+		}]
+	};
+};
+const getSystemNoticeText = (event) => {
+	switch (event.subtype) {
+		case "init": return;
+		case "status": return `status: ${event.status ?? "idle"}`;
+		case "local_command_output": return event.content;
+		case "hook_started": return `[hook_started] ${event.hook_name}`;
+		case "hook_progress": return `[hook_progress] ${event.hook_name}`;
+		case "hook_response": return `[hook_response] ${event.hook_name}: ${event.outcome}`;
+		case "task_started": return `[task_started] ${event.description}`;
+		case "task_progress": return `[task_progress] ${event.summary ?? event.description}`;
+		case "task_notification": return `[task_${event.status}] ${event.summary}`;
+		case "compact_boundary": return `[compact_boundary] ${event.compact_metadata.trigger}`;
+		case "files_persisted": return `[files_persisted] ${event.files.length} file${event.files.length === 1 ? "" : "s"}`;
+		default: return;
+	}
+};
+const mapSystemEvent = (event, context) => {
+	const text = getSystemNoticeText(event);
+	if (!text) return { events: [] };
+	return { events: [createSystemNoticeEvent(context.runId, context.sessionId, text)] };
+};
+const mapNoticeEvent = (event, context) => {
+	switch (event.type) {
+		case "auth_status": {
+			let text = "authenticated";
+			if (event.error) text = `auth error: ${event.error}`;
+			else if (event.isAuthenticating) text = "authenticating";
+			return { events: [createSystemNoticeEvent(context.runId, context.sessionId, text)] };
+		}
+		case "prompt_suggestion": return { events: [createSystemNoticeEvent(context.runId, context.sessionId, `prompt suggestion: ${event.suggestion}`)] };
+		case "rate_limit_event": return { events: [createSystemNoticeEvent(context.runId, context.sessionId, `rate limited: ${event.rate_limit_info.status}`)] };
+		case "tool_use_summary": return { events: [createSystemNoticeEvent(context.runId, context.sessionId, event.summary)] };
+		default: return { events: [] };
+	}
+};
+const mapResultEvent = (event, context) => {
+	const state = { stats: toStats(event) };
+	const resultText = "result" in event ? event.result : void 0;
+	const isSuccess = event.subtype === "success" && !event.is_error;
+	if (typeof resultText === "string") state.output = {
+		...state.output,
+		text: resultText
+	};
+	const extraction = extractClaudeStructuredOutput("structured_output" in event ? event.structured_output : void 0, context, { isSuccess }, "Structured output was requested but Claude Agent SDK did not return structured_output.");
+	if (extraction.value === void 0 && isSuccess && context.schemaRequested && typeof resultText === "string") try {
+		extraction.value = parseJsonResponseText(resultText);
+		extraction.error = void 0;
+	} catch {}
+	if (extraction.value !== void 0) state.output = {
+		...state.output,
+		value: extraction.value
+	};
+	if (extraction.error) {
+		state.status = "failed";
+		state.error = extraction.error;
+	}
+	if (!isSuccess) {
+		state.status = "failed";
+		state.error = {
+			kind: "provider",
+			message: getResultErrorMessage(event)
+		};
+	} else if (!state.error) state.status = "completed";
+	return {
+		events: [],
+		state
+	};
+};
+const mapClaudeCodeSdkEvent = (event, context, options = {}) => {
+	let batch;
+	switch (event.type) {
+		case "assistant":
+			batch = mapAssistantEvent(event, context, options);
+			break;
+		case "result":
+			batch = mapResultEvent(event, context);
+			break;
+		case "system":
+			batch = mapSystemEvent(event, context);
+			break;
+		case "tool_progress":
+			batch = mapToolProgressEvent(event, context, options);
+			break;
+		case "user":
+			batch = mapUserEvent(event, context);
+			break;
+		case "auth_status":
+		case "prompt_suggestion":
+		case "rate_limit_event":
+		case "tool_use_summary":
+			batch = mapNoticeEvent(event, context);
+			break;
+		default:
+			batch = { events: [] };
+			break;
+	}
+	const sessionId = getClaudeCodeSdkSessionId(event);
+	if (sessionId && batch.sessionId === void 0) batch.sessionId = sessionId;
+	return batch;
+};
+//#endregion
+//#region src/adapters/claude-code-sdk/adapter.ts
+const CLAUDE_CODE_SDK_CAPABILITIES = {
+	structuredOutput: true,
+	sessionResume: true,
+	imageInput: false,
+	mcp: true,
+	eventStreaming: true,
+	sessionFork: true
+};
+const resolveSystemPrompt = (systemPrompt, appendSystemPrompt) => {
+	if (!systemPrompt) return appendSystemPrompt ? {
+		type: "preset",
+		preset: "claude_code",
+		append: appendSystemPrompt
+	} : void 0;
+	return appendSystemPrompt ? `${systemPrompt}\n\n${appendSystemPrompt}` : systemPrompt;
+};
+const defaultCreateQuery = ({ prompt, options }) => query({
+	prompt,
+	options
+});
+const toClaudeSdkSettings = (settings) => {
+	if (settings === void 0 || typeof settings === "string") return settings;
+	if (Array.isArray(settings)) throw new AgentValidationError("settings must be an object or a path string.");
+	return settings;
+};
+const toClaudeSdkMcpServerConfig = (name, server) => {
+	if (server.command) {
+		if (server.url) throw new AgentValidationError(`mcpServers.${name} cannot set both command and url.`);
+		if (server.headers) throw new AgentValidationError(`mcpServers.${name}.headers is only supported with url transports.`);
+		if (server.cwd) throw new AgentValidationError(`mcpServers.${name}.cwd is not supported by claude-code-sdk.`);
+		return {
+			type: "stdio",
+			command: server.command,
+			args: server.args,
+			env: server.env
+		};
+	}
+	if (server.url) {
+		if (server.args) throw new AgentValidationError(`mcpServers.${name}.args is only supported with command transports.`);
+		if (server.env) throw new AgentValidationError(`mcpServers.${name}.env is only supported with command transports.`);
+		if (server.cwd) throw new AgentValidationError(`mcpServers.${name}.cwd is not supported by claude-code-sdk.`);
+		return {
+			type: "http",
+			url: server.url,
+			headers: server.headers
+		};
+	}
+	throw new AgentValidationError(`mcpServers.${name} must set either command or url.`);
+};
+const toClaudeSdkMcpServers = (servers) => {
+	if (!servers) return;
+	return Object.fromEntries(Object.entries(servers).map(([name, server]) => [name, toClaudeSdkMcpServerConfig(name, server)]));
+};
+var ClaudeCodeSdkAgentImpl = class ClaudeCodeSdkAgentImpl extends SdkAgent {
+	type = "claude-code-sdk";
+	defaults;
+	creationOptions;
+	runDefaults;
+	createQueryFn;
+	command;
+	forkOnNextRun;
+	currentQuery;
+	constructor(options = {}) {
+		super({
+			type: "claude-code-sdk",
+			capabilities: CLAUDE_CODE_SDK_CAPABILITIES,
+			sessionId: options.sessionId,
+			onEvent: options.onEvent
+		});
+		this.command = options.command;
+		this.defaults = {
+			cwd: options.cwd,
+			model: options.model,
+			systemPrompt: options.systemPrompt
+		};
+		this.creationOptions = {
+			...options,
+			command: options.command,
+			env: options.env ? { ...options.env } : void 0,
+			executableArgs: options.executableArgs ? [...options.executableArgs] : void 0,
+			mcpServers: options.mcpServers ? { ...options.mcpServers } : void 0,
+			settingSources: options.settingSources ? [...options.settingSources] : void 0
+		};
+		this.runDefaults = {
+			allowedTools: options.allowedTools ? [...options.allowedTools] : void 0,
+			disallowedTools: options.disallowedTools ? [...options.disallowedTools] : void 0,
+			appendSystemPrompt: options.appendSystemPrompt,
+			permissionMode: options.permissionMode,
+			mcpServers: options.mcpServers ? { ...options.mcpServers } : void 0,
+			forkSession: options.forkSession,
+			maxTurns: options.maxTurns
+		};
+		this.createQueryFn = options.createQuery ?? defaultCreateQuery;
+		this.forkOnNextRun = options.forkOnNextRun ?? false;
+	}
+	fork() {
+		if (!this.sessionId) throw new AgentValidationError("Cannot fork a Claude Code SDK agent before it has a sessionId.");
+		return new ClaudeCodeSdkAgentImpl({
+			...this.creationOptions,
+			sessionId: this.sessionId,
+			forkSession: void 0,
+			forkOnNextRun: true
+		});
+	}
+	get runRequestDefaults() {
+		return this.defaults;
+	}
+	onValidateRun(request, _normalizedRequest) {
+		if ((request.forkSession ?? this.runDefaults.forkSession ?? this.forkOnNextRun) && !this.sessionId) throw new AgentValidationError("forkSession requires an existing sessionId on the agent.");
+		if (request.maxTurns !== void 0 && (!Number.isInteger(request.maxTurns) || request.maxTurns <= 0)) throw new AgentValidationError("maxTurns must be a positive integer.");
+	}
+	onStopRequested(run) {
+		this.currentQuery?.interrupt?.().catch(() => {});
+		super.onStopRequested(run);
+	}
+	async onDispose() {
+		this.currentQuery?.close?.();
+		this.currentQuery = void 0;
+	}
+	cleanupSdkResources() {
+		if (this.currentQuery) {
+			this.currentQuery.close?.();
+			this.currentQuery = void 0;
+		}
+	}
+	async executeSdkRun(run, request, abortController) {
+		const activeQuery = this.createQueryFn({
+			prompt: getInputText(run.normalizedRequest.input),
+			options: this.buildQueryOptions(request, run, abortController)
+		});
+		this.currentQuery = activeQuery;
+		for await (const message of activeQuery) {
+			const sessionId = getClaudeCodeSdkSessionId(message) ?? run.sessionId;
+			if (sessionId && run.sessionId !== sessionId) {
+				run.sessionId = sessionId;
+				this.setSessionId(sessionId);
+				if (this.forkOnNextRun && run.requestedSessionId && sessionId !== run.requestedSessionId) this.forkOnNextRun = false;
+			}
+			const batch = mapClaudeCodeSdkEvent(message, {
+				runId: run.runId,
+				requestedSessionId: run.requestedSessionId,
+				sessionId: run.sessionId,
+				schemaRequested: run.normalizedRequest.schema.kind !== "none",
+				toolCalls: run.toolCalls
+			}, { model: run.normalizedRequest.model });
+			this.applyBatch(run, batch);
+		}
+	}
+	buildQueryOptions(request, run, abortController) {
+		const permissionMode = request.permissionMode ?? this.runDefaults.permissionMode;
+		const forkSession = request.forkSession ?? this.runDefaults.forkSession ?? this.forkOnNextRun;
+		const appendSystemPrompt = request.appendSystemPrompt ?? this.runDefaults.appendSystemPrompt;
+		const env = buildBaseProcessEnv({ propagateEnv: this.creationOptions.propagateEnv });
+		if (this.creationOptions.env) Object.assign(env, this.creationOptions.env);
+		delete env.CLAUDECODE;
+		return {
+			abortController,
+			cwd: run.normalizedRequest.cwd,
+			model: run.normalizedRequest.model,
+			systemPrompt: resolveSystemPrompt(run.normalizedRequest.systemPrompt, appendSystemPrompt),
+			allowedTools: request.allowedTools ?? this.runDefaults.allowedTools,
+			disallowedTools: request.disallowedTools ?? this.runDefaults.disallowedTools,
+			mcpServers: toClaudeSdkMcpServers(request.mcpServers ?? this.runDefaults.mcpServers),
+			maxTurns: request.maxTurns ?? this.runDefaults.maxTurns,
+			outputFormat: run.normalizedRequest.schema.kind === "none" ? void 0 : {
+				type: "json_schema",
+				schema: run.normalizedRequest.schema.jsonSchema
+			},
+			permissionMode,
+			allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : void 0,
+			resume: run.requestedSessionId,
+			forkSession: run.requestedSessionId ? forkSession : void 0,
+			env,
+			executable: this.creationOptions.executable,
+			executableArgs: this.creationOptions.executableArgs,
+			pathToClaudeCodeExecutable: this.command,
+			settings: toClaudeSdkSettings(this.creationOptions.settings),
+			settingSources: this.creationOptions.settingSources,
+			stderr: (data) => {
+				for (const line of data.split("\n")) {
+					if (!line) continue;
+					run.stderrLines.push(line);
+					this.emit(run, createAgentEvent(run.runId, "stderr", {
+						sessionId: run.sessionId,
+						text: line
+					}));
+				}
+			}
+		};
+	}
+};
+const createClaudeCodeSdkAgent = (options) => new ClaudeCodeSdkAgentImpl(options);
+//#endregion
+export { createClaudeCodeSdkAgent };

package/dist/adapters/codex-cli/index.d.mts

@@ -0,0 +1,2 @@
+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, t as createCodexCliAgent, u as CodexItemStartedEvent } from "../../index-nzo1sBiK.mjs";
+export { CodexCliAgent, CodexCliAgentOptions, CodexCliPermissionMode, CodexCliRunOptions, CodexCliSandboxMode, CodexErrorEvent, CodexEvent, CodexItemCompletedEvent, CodexItemStartedEvent, CodexItemUpdatedEvent, CodexThreadStartedEvent, CodexTurnCompletedEvent, CodexTurnFailedEvent, createCodexCliAgent };