@demicodes/provider-claude-code 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1166 @@
+import { errorMessage, isRecord, nonEmptyString, numberOrNull, stringOrNull } from "@demicodes/utils";
+import { randomUUID } from "node:crypto";
+import { applyModelPolicy, defineProvider } from "@demicodes/provider";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { spawn } from "node:child_process";
+import { appendFileSync, mkdirSync, statSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process$1 from "node:process";
+//#region src/models.ts
+const DEFAULT_MODELS_DEV_URL = "https://models.dev/api.json";
+const DEFAULT_MINIMUM_MODEL_VERSION = "4.6";
+const MODELS_DEV_CACHE_TTL_MS = 1440 * 60 * 1e3;
+let memoryCache = null;
+async function listClaudeCodeModels(options = {}) {
+	const fetchImpl = options.fetch ?? fetch;
+	const nowDate = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+	const minimum = parseMinimumModelVersion(options.minimumModelVersion ?? DEFAULT_MINIMUM_MODEL_VERSION);
+	const modelsDevUrl = options.modelsDevUrl ?? DEFAULT_MODELS_DEV_URL;
+	const cacheKey = claudeCatalogCacheKey(modelsDevUrl, minimum);
+	const headers = new Headers({ accept: "application/json" });
+	if (memoryCache?.cacheKey === cacheKey && nowDate.getTime() - memoryCache.fetchedAtMs < MODELS_DEV_CACHE_TTL_MS) return cloneModelList(markModelListCache(memoryCache.list, false));
+	if (memoryCache?.cacheKey === cacheKey && memoryCache.etag) headers.set("if-none-match", memoryCache.etag);
+	if (memoryCache?.cacheKey === cacheKey && memoryCache.lastModified) headers.set("if-modified-since", memoryCache.lastModified);
+	try {
+		const response = await fetchImpl(modelsDevUrl, { headers });
+		if (response.status === 304 && memoryCache?.cacheKey === cacheKey) {
+			memoryCache = {
+				...memoryCache,
+				fetchedAtMs: nowDate.getTime()
+			};
+			return cloneModelList(markModelListCache(memoryCache.list, false));
+		}
+		if (!response.ok) throw new Error(`models.dev catalog request failed with HTTP ${response.status}`);
+		const list = modelsDevAnthropicCatalogToModelList(await response.json(), {
+			minimumModelVersion: minimum,
+			sourceFetchedAt: nowDate.toISOString(),
+			stale: false,
+			warnings: []
+		});
+		memoryCache = {
+			cacheKey,
+			etag: response.headers.get("etag"),
+			lastModified: response.headers.get("last-modified"),
+			fetchedAtMs: nowDate.getTime(),
+			list
+		};
+		return cloneModelList(list);
+	} catch (error) {
+		if (!memoryCache || memoryCache.cacheKey !== cacheKey) throw error;
+		const list = markModelListCache(memoryCache.list, true);
+		return {
+			...cloneModelList(list),
+			warnings: [...list.warnings, `Using stale models.dev catalog: ${errorMessage(error)}`]
+		};
+	}
+}
+function modelsDevAnthropicCatalogToModelList(value, options = {}) {
+	const sourceFetchedAt = options.sourceFetchedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const minimum = typeof options.minimumModelVersion === "string" ? parseMinimumModelVersion(options.minimumModelVersion) : options.minimumModelVersion ?? parseMinimumModelVersion(DEFAULT_MINIMUM_MODEL_VERSION);
+	const warnings = [...options.warnings ?? []];
+	const anthropic = isRecord(value) && isRecord(value.anthropic) ? value.anthropic : null;
+	const rawModels = anthropic && isRecord(anthropic.models) ? anthropic.models : null;
+	if (!rawModels) throw new Error("models.dev response does not contain anthropic.models");
+	const models = [];
+	for (const [id, rawModel] of Object.entries(rawModels)) {
+		if (!id.startsWith("claude-")) continue;
+		const version = parseClaudeModelVersion(id);
+		if (!version) {
+			warnings.push(`Skipped Claude model with unparseable version: ${id}`);
+			continue;
+		}
+		if (!versionGte(version, minimum)) continue;
+		if (!isRecord(rawModel)) {
+			warnings.push(`Skipped Claude model with invalid metadata: ${id}`);
+			continue;
+		}
+		models.push(modelFromModelsDevEntry(id, rawModel, sourceFetchedAt, options.stale === true));
+	}
+	models.sort(compareClaudeModels);
+	return {
+		providerId: "claude-code",
+		models,
+		defaultModelId: null,
+		warnings,
+		sourceFetchedAt,
+		stale: options.stale === true
+	};
+}
+const CLAUDE_FAMILY_RANK = {
+	opus: 0,
+	sonnet: 1,
+	haiku: 2
+};
+function claudeFamilyRank(id) {
+	return CLAUDE_FAMILY_RANK[id.slice(7).split("-")[0] ?? ""] ?? 3;
+}
+/** Canonical catalog order: flagship family first (Opus > Sonnet > Haiku > others), newest version first. */
+function compareClaudeModels(a, b) {
+	const familyDelta = claudeFamilyRank(a.id) - claudeFamilyRank(b.id);
+	if (familyDelta !== 0) return familyDelta;
+	const versionA = parseClaudeModelVersion(a.id);
+	const versionB = parseClaudeModelVersion(b.id);
+	if (versionA && versionB) {
+		if (versionA.major !== versionB.major) return versionB.major - versionA.major;
+		if (versionA.minor !== versionB.minor) return versionB.minor - versionA.minor;
+	}
+	return a.id.localeCompare(b.id);
+}
+function parseClaudeModelVersion(id) {
+	if (!id.startsWith("claude-")) return null;
+	const parts = id.slice(7).split("-");
+	const isInteger = (value) => value !== void 0 && /^\d+$/.test(value);
+	const isDate = (value) => value !== void 0 && /^\d{8}$/.test(value);
+	if (isInteger(parts[0])) return {
+		major: Number(parts[0]),
+		minor: isInteger(parts[1]) ? Number(parts[1]) : 0
+	};
+	if (!isInteger(parts[1])) return null;
+	return {
+		major: Number(parts[1]),
+		minor: isInteger(parts[2]) && !isDate(parts[2]) ? Number(parts[2]) : 0
+	};
+}
+function modelFromModelsDevEntry(id, raw, sourceFetchedAt, stale) {
+	const limit = isRecord(raw.limit) ? raw.limit : null;
+	const cost = isRecord(raw.cost) ? raw.cost : null;
+	return {
+		providerId: "claude-code",
+		id,
+		displayName: nonEmptyString(raw.name) ?? id,
+		description: nonEmptyString(raw.description),
+		contextWindow: numberOrNull(limit?.context),
+		outputLimit: numberOrNull(limit?.output),
+		supportsTools: booleanOrNull(isRecord(raw.tool) ? raw.tool.call : raw.tool_call),
+		supportsAttachments: booleanOrNull(raw.attachment),
+		supportsReasoning: booleanOrNull(raw.reasoning),
+		supportedThinkingEfforts: reasoningEfforts(raw.reasoning_options),
+		defaultThinkingEffort: null,
+		canDisableThinking: false,
+		...cost ? { cost: {
+			input: numberOrNull(cost.input),
+			output: numberOrNull(cost.output),
+			cacheRead: numberOrNull(cost.cache_read),
+			cacheWrite: numberOrNull(cost.cache_write)
+		} } : {},
+		sourceFetchedAt,
+		stale
+	};
+}
+function parseMinimumModelVersion(value) {
+	const match = /^(\d+)(?:\.(\d+))?$/.exec(value);
+	if (!match) throw new Error(`Invalid minimum Claude model version: ${value}`);
+	return {
+		major: Number(match[1]),
+		minor: match[2] ? Number(match[2]) : 0
+	};
+}
+function versionGte(version, minimum) {
+	return version.major > minimum.major || version.major === minimum.major && version.minor >= minimum.minor;
+}
+function claudeCatalogCacheKey(modelsDevUrl, minimum) {
+	return `${modelsDevUrl}\0${minimum.major}.${minimum.minor}`;
+}
+function markModelListCache(list, stale) {
+	return {
+		...list,
+		sourceFetchedAt: list.sourceFetchedAt,
+		stale,
+		models: list.models.map((model) => ({
+			...model,
+			stale
+		}))
+	};
+}
+function cloneModelList(list) {
+	return {
+		...list,
+		warnings: [...list.warnings],
+		models: list.models.map((model) => ({
+			...model,
+			...model.cost ? { cost: { ...model.cost } } : {},
+			supportedThinkingEfforts: model.supportedThinkingEfforts ? [...model.supportedThinkingEfforts] : null
+		}))
+	};
+}
+function booleanOrNull(value) {
+	return typeof value === "boolean" ? value : null;
+}
+function reasoningEfforts(value) {
+	if (!Array.isArray(value)) return null;
+	const effortOption = value.find((option) => isRecord(option) && option.type === "effort");
+	if (!isRecord(effortOption) || !Array.isArray(effortOption.values)) return null;
+	const efforts = effortOption.values.map((effort) => nonEmptyString(effort)).filter((effort) => effort !== void 0);
+	return efforts.length > 0 ? efforts : [];
+}
+//#endregion
+//#region src/jsonl.ts
+/**
+* Builds the input messages used to prime a *fresh* Claude CLI process with prior
+* conversation history — i.e. on a cold start: the first turn, a resume after the process
+* died, or a restart forced by compaction.
+*
+* Two invariants:
+*
+* 1. Prior tool calls/results are rendered as plain TEXT, never structured `tool_use` /
+*    `tool_result` blocks. Replaying a structured MCP `tool_use` into a freshly-initialized
+*    SDK-MCP session is exactly what makes Claude reject the request with
+*    `API Error: 400 ... tool use concurrency`.
+* 2. A `user` message contains ONLY real user input. Both the tool call and its result are
+*    folded into the *assistant* narrative ("I ran X, it returned Y"), so we never synthesize
+*    a user turn the human did not type, and never merge a tool result into the next real
+*    prompt. This keeps the conversation cleanly alternating without fabricated user messages.
+*
+* The live, in-process path never calls this: there the CLI keeps the structured tool history
+* in its own native context, so no replay happens at all.
+*/
+function coldStartInputMessages(items) {
+	const messages = [];
+	let pending = null;
+	const toolNames = /* @__PURE__ */ new Map();
+	const flush = () => {
+		if (pending && pending.content.length > 0) messages.push({
+			type: pending.role,
+			message: {
+				role: pending.role,
+				content: pending.content
+			}
+		});
+		pending = null;
+	};
+	const append = (role, blocks) => {
+		if (blocks.length === 0) return;
+		if (!pending || pending.role !== role) {
+			flush();
+			pending = {
+				role,
+				content: []
+			};
+		}
+		pending.content.push(...blocks);
+	};
+	for (const item of items) switch (item.type) {
+		case "user_message":
+		case "user_steer":
+			append("user", userContentToClaude(item.content));
+			break;
+		case "assistant_text":
+			append("assistant", item.text ? [{
+				type: "text",
+				text: item.text
+			}] : []);
+			break;
+		case "tool_use":
+			toolNames.set(item.toolUseId, item.toolName);
+			append("assistant", [{
+				type: "text",
+				text: renderToolUseText(item.toolName, item.input)
+			}]);
+			break;
+		case "tool_result":
+			append("assistant", [{
+				type: "text",
+				text: renderToolResultText(toolNames.get(item.toolUseId), item)
+			}]);
+			break;
+	}
+	flush();
+	return messages;
+}
+function renderToolUseText(toolName, input) {
+	return `[Earlier in this conversation I called the tool ${toolName} with input: ${safeJson(input)}.`;
+}
+function renderToolResultText(toolName, item) {
+	const body = toolResultToText(item.output);
+	const suffix = toolName ? ` from ${toolName}` : "";
+	return item.isError ? `It returned an error${suffix}: ${body}]` : `It returned${suffix}: ${body}]`;
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function inferenceItemToClaudeMessage(item) {
+	switch (item.type) {
+		case "user_message":
+		case "user_steer": return {
+			type: "user",
+			message: {
+				role: "user",
+				content: userContentToClaude(item.content)
+			}
+		};
+		case "assistant_text":
+		case "assistant_thinking":
+		case "assistant_redacted_thinking":
+		case "tool_use": {
+			const content = assistantItemToClaudeContent(item);
+			if (content === null) return null;
+			return {
+				type: "assistant",
+				message: {
+					role: "assistant",
+					content: [content]
+				}
+			};
+		}
+		case "tool_result": return toolResultsToClaudeMessage([item]);
+	}
+	return null;
+}
+function toolResultsToClaudeMessage(results) {
+	return {
+		type: "user",
+		message: {
+			role: "user",
+			content: results.map(toolResultToClaudeContent)
+		}
+	};
+}
+function controlResponse(id, response) {
+	return {
+		type: "control_response",
+		id,
+		response
+	};
+}
+function userContentToClaude(content) {
+	return content.map((block) => {
+		if (block.type === "text") return {
+			type: "text",
+			text: block.text
+		};
+		if (block.type === "image") return {
+			type: "image",
+			source: imageSourceToClaude(block.source)
+		};
+		if (block.type === "document") return documentSourceToClaude(block.source);
+		return {
+			type: "text",
+			text: block.reference
+		};
+	});
+}
+function assistantItemToClaudeContent(item) {
+	if (item.type === "assistant_text") return {
+		type: "text",
+		text: item.text
+	};
+	if (item.type === "assistant_thinking") {
+		if (!item.signature) return null;
+		return {
+			type: "thinking",
+			thinking: item.text,
+			signature: item.signature
+		};
+	}
+	if (item.type === "assistant_redacted_thinking") return {
+		type: "redacted_thinking",
+		data: item.data
+	};
+	return {
+		type: "tool_use",
+		id: item.toolUseId,
+		name: toolNameToClaude(item.toolName),
+		input: item.input
+	};
+}
+function toolResultToClaudeContent(item) {
+	return {
+		type: "tool_result",
+		tool_use_id: item.toolUseId,
+		is_error: item.isError,
+		content: toolResultToText(item.output)
+	};
+}
+function imageSourceToClaude(source) {
+	if (source.type === "url") return {
+		type: "url",
+		url: source.url
+	};
+	return {
+		type: "base64",
+		media_type: source.mediaType,
+		data: bytesToBase64(source.data)
+	};
+}
+function documentSourceToClaude(source) {
+	return {
+		type: "document",
+		source: {
+			type: "base64",
+			media_type: source.mediaType,
+			data: bytesToBase64(source.data)
+		},
+		title: source.fileName
+	};
+}
+function toolResultToText(output) {
+	return output.map((block) => block.type === "text" ? block.text : `[image:${block.source.mediaType}]`).join("\n");
+}
+function bytesToBase64(data) {
+	return Buffer$1.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
+}
+function toolNameToClaude(name) {
+	if (/^mcp__[^_]+__.+$/.test(name)) return name;
+	return `mcp__main__${name}`;
+}
+//#endregion
+//#region src/output.ts
+function mapClaudeStdoutMessage(message, options = {}) {
+	const events = [];
+	if (!isRecord(message)) return {
+		events,
+		terminal: false
+	};
+	if (message.type === "assistant" && isRecord(message.message) && !options.ignoreAssistantContent) events.push(...mapContentArray(message.message.content, options));
+	if (message.type === "stream_event" && isRecord(message.event)) events.push(...mapStreamEvent(message.event));
+	if (message.type === "control_request") {
+		const request = parseControlRequest(message);
+		if (request) return {
+			events,
+			controlRequest: request,
+			terminal: false
+		};
+	}
+	if (message.type === "result") {
+		if (message.is_error === true) {
+			const errorMessage = resultErrorMessage(message);
+			events.push({
+				type: "error",
+				message: errorMessage,
+				code: classifyProviderError(errorMessage)
+			});
+		}
+		events.push({
+			type: "response",
+			usage: mapUsage(message.usage)
+		});
+		return {
+			events,
+			terminal: true
+		};
+	}
+	if (message.type === "error") {
+		const errorMessage = String(message.message ?? "Claude Code error");
+		events.push({
+			type: "error",
+			message: errorMessage,
+			code: stringOrNull(message.code) ?? classifyProviderError(errorMessage)
+		});
+	}
+	return {
+		events,
+		terminal: false
+	};
+}
+function controlRequestToToolCall(request) {
+	if (request.method !== "tools/call") return null;
+	if (!isRecord(request.params)) return null;
+	const name = typeof request.params.name === "string" ? request.params.name : null;
+	if (!name) return null;
+	return {
+		type: "tool_call_requested",
+		toolUseId: request.toolUseId ?? String(request.id),
+		toolName: stripMcpToolPrefix(name),
+		input: request.params.arguments ?? request.params.input ?? {}
+	};
+}
+function mapContentArray(content, options) {
+	if (!Array.isArray(content)) return [];
+	const events = [];
+	for (const block of content) {
+		if (!isRecord(block)) continue;
+		if (block.type === "text") events.push({
+			type: "text_delta",
+			text: String(block.text ?? "")
+		});
+		else if (block.type === "thinking") {
+			events.push({ type: "thinking_start" });
+			events.push({
+				type: "thinking_delta",
+				text: String(block.thinking ?? block.text ?? "")
+			});
+			if (typeof block.signature === "string") events.push({
+				type: "thinking_signature",
+				signature: block.signature
+			});
+		} else if (block.type === "redacted_thinking") events.push({
+			type: "redacted_thinking",
+			data: String(block.data ?? "")
+		});
+		else if (block.type === "tool_use" && !options.ignoreAssistantToolUse) events.push(mapToolUseBlock(block));
+	}
+	return events;
+}
+function mapToolUseBlock(block) {
+	const id = typeof block.id === "string" || typeof block.id === "number" ? String(block.id) : null;
+	const name = typeof block.name === "string" && block.name.length > 0 ? block.name : null;
+	if (!id || !name) return {
+		type: "error",
+		message: "Invalid tool_use block from Claude Code",
+		code: null
+	};
+	return {
+		type: "tool_call_requested",
+		toolUseId: id,
+		toolName: stripMcpToolPrefix(name),
+		input: block.input ?? {}
+	};
+}
+function mapStreamEvent(event) {
+	if (event.type === "content_block_start" && isRecord(event.content_block)) {
+		const block = event.content_block;
+		if (block.type === "thinking") return [{ type: "thinking_start" }];
+		if (block.type === "text" && typeof block.text === "string") return [{
+			type: "text_delta",
+			text: block.text
+		}];
+	}
+	if (event.type === "content_block_delta" && isRecord(event.delta)) {
+		const delta = event.delta;
+		if (delta.type === "text_delta") return [{
+			type: "text_delta",
+			text: String(delta.text ?? "")
+		}];
+		if (delta.type === "thinking_delta") return [{
+			type: "thinking_delta",
+			text: String(delta.thinking ?? "")
+		}];
+		if (delta.type === "signature_delta") return [{
+			type: "thinking_signature",
+			signature: String(delta.signature ?? "")
+		}];
+	}
+	return [];
+}
+function parseControlRequest(message) {
+	if (typeof message.request_id === "string" && isRecord(message.request)) {
+		const request = message.request;
+		if (request.subtype !== "mcp_message") return null;
+		if (request.server_name !== "main") return null;
+		if (!isRecord(request.message)) return null;
+		const inner = request.message;
+		const id = typeof inner.id === "string" || typeof inner.id === "number" ? inner.id : 0;
+		const method = typeof inner.method === "string" ? inner.method : void 0;
+		if (!method) return null;
+		return {
+			protocol: "sdk-mcp",
+			outerRequestId: message.request_id,
+			serverName: request.server_name,
+			id,
+			method,
+			params: inner.params
+		};
+	}
+	const id = typeof message.id === "string" || typeof message.id === "number" ? message.id : void 0;
+	const method = typeof message.method === "string" ? message.method : void 0;
+	if (id === void 0 || !method) return null;
+	return {
+		protocol: "legacy",
+		id,
+		method,
+		params: message.params
+	};
+}
+function mapUsage(usage) {
+	if (!isRecord(usage)) return {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	};
+	return {
+		inputTokens: numberValue(usage.input_tokens ?? usage.inputTokens),
+		outputTokens: numberValue(usage.output_tokens ?? usage.outputTokens),
+		cacheReadTokens: numberValue(usage.cache_read_input_tokens ?? usage.cacheReadTokens),
+		cacheWriteTokens: numberValue(usage.cache_creation_input_tokens ?? usage.cacheWriteTokens)
+	};
+}
+function numberValue(value) {
+	return typeof value === "number" ? value : 0;
+}
+function resultErrorMessage(message) {
+	const parts = [];
+	if (typeof message.result === "string" && message.result.trim()) parts.push(message.result.trim());
+	if (Array.isArray(message.errors)) for (const error of message.errors) {
+		const text = String(error).trim();
+		if (text) parts.push(text);
+	}
+	return parts.join("\n") || "Claude Code returned an error";
+}
+function classifyProviderError(message) {
+	const lower = message.toLowerCase();
+	if (lower.includes("context_length_exceeded") || lower.includes("context window") || lower.includes("context length") || lower.includes("maximum context") || lower.includes("input is too long")) return "context_length_exceeded";
+	if (lower.includes("rate_limit") || lower.includes("rate limit") || lower.includes("rate-limit") || lower.includes("rate limited") || lower.includes("too many requests") || /\b429\b/.test(lower)) return "rate_limit";
+	if (lower.includes("auth_expired") || lower.includes("auth expired") || lower.includes("authentication expired") || lower.includes("auth failed") || lower.includes("authentication failed") || lower.includes("not logged in") || lower.includes("login required") || lower.includes("unauthorized")) return "auth_expired";
+	return null;
+}
+function stripMcpToolPrefix(name) {
+	return /^mcp__[^_]+__(.+)$/.exec(name)?.[1] ?? name;
+}
+//#endregion
+//#region src/cli.ts
+function buildClaudeArgs(params) {
+	const args = [
+		"--print",
+		"--output-format",
+		"stream-json",
+		"--verbose",
+		"--input-format",
+		"stream-json",
+		"--include-partial-messages",
+		"--no-session-persistence",
+		"--safe-mode",
+		"--disable-slash-commands",
+		"--tools",
+		"",
+		"--permission-mode",
+		"bypassPermissions",
+		"--allow-dangerously-skip-permissions",
+		"--model",
+		params.modelId,
+		"--system-prompt",
+		params.systemPrompt
+	];
+	if (params.thinkingEffort) args.push("--effort", params.thinkingEffort);
+	return args;
+}
+function buildClaudeEnv(base = process.env) {
+	const env = {
+		...base,
+		DISABLE_AUTO_COMPACT: "1",
+		MAX_MCP_OUTPUT_TOKENS: "1000000"
+	};
+	delete env.CLAUDECODE;
+	return env;
+}
+//#endregion
+//#region src/wire-log.ts
+const NULL_WIRE_LOG = {
+	path: null,
+	record() {}
+};
+/**
+* Resolves the directory the claude-code wire log is written to. Default-on so the raw
+* provider request/response stream is always retained for diagnostics; set
+* `DEMI_CLAUDE_WIRE_LOG=0` to disable, or `DEMI_CLAUDE_WIRE_LOG_DIR` to relocate.
+*/
+function resolveWireLogDir() {
+	if (process$1.env.DEMI_CLAUDE_WIRE_LOG === "0") return null;
+	return process$1.env.DEMI_CLAUDE_WIRE_LOG_DIR ?? join(tmpdir(), "demi-claude-wire");
+}
+function createClaudeWireLog(sessionId) {
+	const dir = resolveWireLogDir();
+	if (!dir) return NULL_WIRE_LOG;
+	try {
+		mkdirSync(dir, { recursive: true });
+	} catch {
+		return NULL_WIRE_LOG;
+	}
+	const path = join(dir, `claude-${sessionId.replace(/[^a-zA-Z0-9_-]/g, "_") || "session"}.jsonl`);
+	return {
+		path,
+		record(direction, data) {
+			const entry = {
+				ts: (/* @__PURE__ */ new Date()).toISOString(),
+				dir: direction,
+				data
+			};
+			try {
+				appendFileSync(path, `${JSON.stringify(entry)}\n`);
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region src/transport.ts
+function resolveSpawnCwd(cwd) {
+	try {
+		if (statSync(cwd).isDirectory()) return cwd;
+	} catch {}
+	return process.cwd();
+}
+var ClaudeCliTransportFactory = class {
+	claudePath;
+	constructor(options = {}) {
+		if (typeof options === "string") this.claudePath = options;
+		else this.claudePath = options.claudePath ?? "claude";
+	}
+	async start(request) {
+		const args = buildClaudeArgsForRequest(request);
+		const wireLog = createClaudeWireLog(request.sessionId);
+		wireLog.record("spawn", {
+			requestId: request.requestId,
+			turnId: request.turnId,
+			model: request.modelId,
+			cwd: request.cwd,
+			args
+		});
+		return new ChildProcessClaudeTransport(spawn(this.claudePath, args, {
+			cwd: resolveSpawnCwd(request.cwd),
+			env: buildClaudeEnv(),
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}), wireLog);
+	}
+};
+function buildClaudeArgsForRequest(request) {
+	return buildClaudeArgs({
+		modelId: request.modelId,
+		systemPrompt: request.systemPrompt,
+		thinkingEffort: thinkingEffort(request.thinking)
+	});
+}
+var ChildProcessClaudeTransport = class {
+	child;
+	wireLog;
+	stderr = "";
+	waitPromise;
+	constructor(child, wireLog) {
+		this.child = child;
+		this.wireLog = wireLog;
+		this.waitPromise = new Promise((resolve) => {
+			child.once("close", (exitCode, signal) => {
+				this.wireLog.record("exit", {
+					exitCode,
+					signal: signal ?? null
+				});
+				resolve({
+					exitCode,
+					signal: signal ?? void 0
+				});
+			});
+			child.once("error", (error) => {
+				this.wireLog.record("exit", { error: error.message });
+				resolve({ exitCode: null });
+			});
+		});
+		this.collectStderr();
+	}
+	async writeJson(value) {
+		this.wireLog.record("in", value);
+		const line = `${JSON.stringify(value)}\n`;
+		await new Promise((resolve, reject) => {
+			this.child.stdin.write(line, (error) => {
+				if (error) reject(error);
+				else resolve();
+			});
+		});
+	}
+	async *messages() {
+		const rl = createInterface({ input: this.child.stdout });
+		for await (const line of rl) {
+			if (String(line).trim() === "") continue;
+			const parsed = JSON.parse(String(line));
+			this.wireLog.record("out", parsed);
+			yield parsed;
+		}
+	}
+	async kill() {
+		if (!this.child.killed) this.child.kill("SIGTERM");
+	}
+	wait() {
+		return this.waitPromise;
+	}
+	stderrText() {
+		return this.stderr;
+	}
+	async collectStderr() {
+		for await (const chunk of this.child.stderr) {
+			const text = Buffer.from(chunk).toString("utf8");
+			this.stderr += text;
+			this.wireLog.record("err", text);
+		}
+	}
+};
+function thinkingEffort(thinking) {
+	if (!thinking) return null;
+	if (thinking.type === "adaptive") return thinking.effort;
+	if (thinking.type === "effort") return thinking.effort;
+	return null;
+}
+//#endregion
+//#region src/provider.ts
+var ClaudeCodeProvider = class {
+	transportFactory;
+	active = null;
+	constructor(options = {}) {
+		this.transportFactory = options.transportFactory ?? new ClaudeCliTransportFactory({ claudePath: options.claudePath });
+	}
+	async *run(request) {
+		let active = null;
+		let keepActiveForContinuation = false;
+		const signal = request.cancel;
+		let abortListener = null;
+		try {
+			active = await this.ensureActiveForRequest(request);
+			const run = active;
+			const onAbort = async () => {
+				await run.transport.kill();
+				if (this.active === run) this.active = null;
+			};
+			const abort = new Promise((resolve) => {
+				if (signal.aborted) {
+					onAbort().then(() => resolve({
+						done: true,
+						value: void 0
+					}));
+					return;
+				}
+				abortListener = () => {
+					onAbort().finally(() => resolve({
+						done: true,
+						value: void 0
+					}));
+				};
+				signal.addEventListener("abort", abortListener, { once: true });
+			});
+			while (true) {
+				const next = await Promise.race([this.nextMessage(run), abort]);
+				if (next.done) {
+					const wasAborted = signal.aborted;
+					const exit = await active.transport.wait();
+					if (this.active === active) this.active = null;
+					if (!wasAborted && exit.exitCode !== 0) yield {
+						type: "error",
+						message: active.transport.stderrText() || `Claude Code exited with code ${exit.exitCode}`,
+						code: exit.signal ?? null
+					};
+					return;
+				}
+				const raw = next.value;
+				const mapped = mapClaudeStdoutMessage(raw, {
+					ignoreAssistantContent: active.hasStreamed && isMessageType(raw, "assistant"),
+					ignoreAssistantToolUse: active.sdkMcpEnabled
+				});
+				if (isMessageType(raw, "stream_event")) active.hasStreamed = true;
+				if (mapped.controlRequest) {
+					if (await this.handleControlRequest(active, mapped.controlRequest, request) === "tool-call") {
+						const event = active.pendingControlRequest ? controlRequestToToolCall(active.pendingControlRequest) : null;
+						keepActiveForContinuation = true;
+						if (event) yield event;
+						return;
+					}
+					continue;
+				}
+				const toolUseIds = mapped.events.filter(isToolCallRequested).map((event) => event.toolUseId);
+				if (toolUseIds.length > 0) active.pendingToolUseIds = toolUseIds;
+				for (const event of mapped.events) {
+					if (event.type === "tool_call_requested") keepActiveForContinuation = true;
+					yield event;
+				}
+				if (toolUseIds.length > 0) return;
+				if (mapped.terminal) {
+					keepActiveForContinuation = true;
+					return;
+				}
+			}
+		} catch (error) {
+			const cleanup = active ?? this.active;
+			if (cleanup) {
+				if (this.active === cleanup) this.active = null;
+				await cleanup.transport.kill();
+				await cleanup.transport.wait();
+			}
+			throw error;
+		} finally {
+			if (abortListener) signal.removeEventListener("abort", abortListener);
+			if (!keepActiveForContinuation && active && this.active === active) {
+				this.active = null;
+				await active.transport.kill();
+				await active.transport.wait();
+			}
+		}
+	}
+	async dispose() {
+		const active = this.active;
+		if (!active) return;
+		this.active = null;
+		await active.transport.kill();
+		await active.transport.wait();
+	}
+	/**
+	* Returns the live process for this request, reusing the one kept alive from the previous
+	* turn whenever possible. Reuse delivers only the *new* input (a pending tool result and/or
+	* a freshly appended user message); a cold start is taken only when there is no live process,
+	* the session changed, or the transcript was rewritten underneath us (compaction).
+	*/
+	async ensureActiveForRequest(request) {
+		const existing = this.active;
+		if (existing && existing.sessionId === request.sessionId && existing.modelId === request.modelId && existing.thinkingSig === thinkingSignature(request)) {
+			if (existing.pendingControlRequest !== null || existing.pendingToolUseIds.length > 0 || !itemsDiverged(existing, request.items)) {
+				await this.sendContinuation(existing, request);
+				return existing;
+			}
+		}
+		if (existing) await this.disposeActive(existing);
+		return this.coldStart(request);
+	}
+	async coldStart(request) {
+		const transport = await this.transportFactory.start(request);
+		const active = {
+			transport,
+			iterator: transport.messages()[Symbol.asyncIterator](),
+			pendingControlRequest: null,
+			pendingToolUseIds: [],
+			bufferedMessages: [],
+			sdkMcpEnabled: request.tools.length > 0,
+			hasStreamed: false,
+			sessionId: request.sessionId,
+			modelId: request.modelId,
+			thinkingSig: thinkingSignature(request),
+			sentUserMessageCount: 0,
+			firstUserSig: null
+		};
+		this.active = active;
+		if (request.tools.length > 0) await this.initializeSdkMcp(active, request.systemPrompt);
+		for (const message of coldStartInputMessages(request.items)) await transport.writeJson(message);
+		active.sentUserMessageCount = countUserMessages(request.items);
+		active.firstUserSig = firstUserSignature(request.items);
+		return active;
+	}
+	/** Feeds a reused process only the input it has not seen: pending tool results, then any new user turns. */
+	async sendContinuation(active, request) {
+		if (active.pendingControlRequest) {
+			await this.writeToolResults(request, active.pendingControlRequest);
+			active.pendingControlRequest = null;
+		}
+		if (active.pendingToolUseIds.length > 0) {
+			await this.writeToolResultMessages(request, active.pendingToolUseIds);
+			active.pendingToolUseIds = [];
+		}
+		const userCount = countUserMessages(request.items);
+		if (userCount > active.sentUserMessageCount) {
+			const userItems = request.items.filter((item) => item.type === "user_message" || item.type === "user_steer");
+			for (const item of userItems.slice(active.sentUserMessageCount)) {
+				const message = inferenceItemToClaudeMessage(item);
+				if (message) await active.transport.writeJson(message);
+			}
+			active.sentUserMessageCount = userCount;
+			if (active.firstUserSig === null) active.firstUserSig = firstUserSignature(request.items);
+		}
+	}
+	async disposeActive(active) {
+		if (this.active === active) this.active = null;
+		await active.transport.kill();
+		await active.transport.wait();
+	}
+	async handleControlRequest(active, request, inference) {
+		if (request.method === "initialize") {
+			await this.writeControlResponse(active, request, {
+				protocolVersion: "2024-11-05",
+				capabilities: { tools: {} },
+				serverInfo: {
+					name: "demi",
+					version: "0.0.0"
+				}
+			});
+			return "handled";
+		}
+		if (request.method === "ping") {
+			await this.writeControlResponse(active, request, {});
+			return "handled";
+		}
+		if (request.method === "notifications/initialized") {
+			await this.writeControlResponse(active, request, {});
+			return "handled";
+		}
+		if (request.method === "tools/list") {
+			await this.writeControlResponse(active, request, { tools: inference.tools.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema
+			})) });
+			return "handled";
+		}
+		if (request.method === "tools/call") {
+			if (!controlRequestToToolCall(request)) {
+				await this.writeControlError(active, request, "Invalid tools/call request");
+				return "handled";
+			}
+			active.pendingControlRequest = {
+				...request,
+				toolUseId: `mcp-control-${randomUUID()}`
+			};
+			return "tool-call";
+		}
+		await this.writeControlError(active, request, `Unsupported method: ${request.method}`);
+		return "handled";
+	}
+	async writeToolResults(request, controlRequest) {
+		if (!this.active) throw new Error("No active Claude transport");
+		const expectedToolUseId = controlRequest.toolUseId ?? String(controlRequest.id);
+		const results = request.items.filter((item) => {
+			return item.type === "tool_result" && item.toolUseId === expectedToolUseId;
+		});
+		if (results.length === 0) throw new Error(`Claude Code provider missing tool_result for control_request ${String(controlRequest.id)}`);
+		const latest = results[results.length - 1];
+		if (controlRequest.protocol === "sdk-mcp") {
+			await this.writeControlResponse(this.active, controlRequest, {
+				content: toolResultContentToMcp(latest.output),
+				isError: latest.isError
+			});
+			return;
+		}
+		await this.writeControlResponse(this.active, controlRequest, {
+			content: toolResultContentToText(latest.output),
+			isError: latest.isError
+		});
+	}
+	async writeToolResultMessages(request, toolUseIds) {
+		if (!this.active) throw new Error("No active Claude transport");
+		const pending = new Set(toolUseIds);
+		const results = request.items.filter((item) => {
+			return item.type === "tool_result" && pending.has(item.toolUseId);
+		});
+		const found = new Set(results.map((item) => item.toolUseId));
+		const missing = toolUseIds.filter((id) => !found.has(id));
+		if (missing.length > 0) throw new Error(`Claude Code provider missing tool_result for tool_use ${missing.join(", ")}`);
+		await this.active.transport.writeJson(toolResultsToClaudeMessage(results));
+	}
+	async initializeSdkMcp(active, systemPrompt) {
+		const requestId = randomUUID();
+		await active.transport.writeJson({
+			type: "control_request",
+			request_id: requestId,
+			request: {
+				subtype: "initialize",
+				sdkMcpServers: ["main"],
+				systemPrompt
+			}
+		});
+		while (true) {
+			const next = await active.iterator.next();
+			if (next.done) throw new Error("Claude Code exited before SDK MCP initialization completed");
+			if (isControlResponseFor(next.value, requestId)) return;
+			active.bufferedMessages.push(next.value);
+		}
+	}
+	nextMessage(active) {
+		const value = active.bufferedMessages.shift();
+		if (value !== void 0) return Promise.resolve({
+			done: false,
+			value
+		});
+		return active.iterator.next();
+	}
+	async writeControlResponse(active, request, result) {
+		if (request.protocol === "sdk-mcp") {
+			await active.transport.writeJson({
+				type: "control_response",
+				response: {
+					subtype: "success",
+					request_id: request.outerRequestId,
+					response: { mcp_response: {
+						jsonrpc: "2.0",
+						id: request.id,
+						result
+					} }
+				}
+			});
+			return;
+		}
+		await active.transport.writeJson(controlResponse(request.id, result));
+	}
+	async writeControlError(active, request, message) {
+		if (request.protocol === "sdk-mcp") {
+			await active.transport.writeJson({
+				type: "control_response",
+				response: {
+					subtype: "success",
+					request_id: request.outerRequestId,
+					response: { mcp_response: {
+						jsonrpc: "2.0",
+						id: request.id,
+						error: {
+							code: -32601,
+							message
+						}
+					} }
+				}
+			});
+			return;
+		}
+		await active.transport.writeJson(controlResponse(request.id, { error: { message } }));
+	}
+};
+function createClaudeCodeProvider(options = {}) {
+	const id = options.id ?? "claude-code";
+	const displayName = options.displayName ?? "Claude Code";
+	const runtimeOptions = { claudePath: options.claudePath };
+	return defineProvider({
+		id,
+		displayName,
+		auth: { status: () => ({
+			status: "unknown",
+			message: "Auth is checked when a Claude Code request runs"
+		}) },
+		state: () => ({
+			status: "unknown",
+			message: "Runtime is checked when a Claude Code request runs"
+		}),
+		listModels: async () => {
+			return applyModelPolicy(await listClaudeCodeModels(), id, options.models);
+		},
+		createRuntime: () => new ClaudeCodeProvider(runtimeOptions)
+	});
+}
+function isToolCallRequested(event) {
+	return event.type === "tool_call_requested";
+}
+function isControlResponseFor(value, requestId) {
+	if (!isRecord(value) || value.type !== "control_response" || !isRecord(value.response)) return false;
+	return value.response.request_id === requestId && value.response.subtype === "success";
+}
+function toolResultContentToText(output) {
+	return output.map((block) => block.type === "text" ? block.text : `[image:${block.source.mediaType}]`).join("\n");
+}
+function toolResultContentToMcp(output) {
+	return output.map((block) => {
+		if (block.type === "text") return {
+			type: "text",
+			text: block.text
+		};
+		return {
+			type: "image",
+			data: Buffer.from(block.source.data).toString("base64"),
+			mimeType: block.source.mediaType
+		};
+	});
+}
+function isMessageType(value, type) {
+	return isRecord(value) && value.type === type;
+}
+function thinkingSignature(request) {
+	return JSON.stringify(request.thinking ?? null);
+}
+function countUserMessages(items) {
+	let count = 0;
+	for (const item of items) if (item.type === "user_message" || item.type === "user_steer") count += 1;
+	return count;
+}
+function firstUserSignature(items) {
+	const first = items.find((item) => item.type === "user_message");
+	if (!first || first.type !== "user_message") return null;
+	return first.content.map((block) => block.type === "text" ? `t:${block.text}` : block.type).join("|");
+}
+/**
+* True when the transcript no longer extends what the live process has already consumed —
+* i.e. user turns were removed or the leading user message changed (compaction rewrote the
+* history). In that case the process must be cold-restarted from the rewritten transcript.
+*/
+function itemsDiverged(active, items) {
+	if (countUserMessages(items) < active.sentUserMessageCount) return true;
+	if (active.firstUserSig !== null && firstUserSignature(items) !== active.firstUserSig) return true;
+	return false;
+}
+//#endregion
+export { createClaudeCodeProvider, listClaudeCodeModels, resolveWireLogDir };