coding-agents-sdk 0.0.1 → 0.2.0

package/dist/adapters/codex-sdk/index.mjs

@@ -0,0 +1,286 @@
+import { r as parseJsonResponseText } from "../../util-B4RQZkKr.mjs";
+import { a as buildBaseProcessEnv, l as toTextPart, o as createAgentEvent, r as applyMappedEventBatch } from "../../classify-error-pL6jeu4T.mjs";
+import { t as SdkAgent } from "../../SdkAgent-B47mJiIE.mjs";
+import { Codex } from "@openai/codex-sdk";
+//#region src/adapters/codex-sdk/events/mappers.ts
+const toStats = (usage) => ({
+	turns: 1,
+	costUsd: 0,
+	inputTokens: usage.input_tokens,
+	cacheReadInputTokens: usage.cached_input_tokens,
+	outputTokens: usage.output_tokens,
+	totalTokens: usage.input_tokens + usage.cached_input_tokens + usage.output_tokens
+});
+const getCommandToolRecord = (item) => ({
+	toolCallId: item.id,
+	toolName: "Bash",
+	input: { command: item.command }
+});
+const getMcpToolRecord = (item) => ({
+	toolCallId: item.id,
+	toolName: item.tool,
+	input: {
+		server: item.server,
+		arguments: item.arguments
+	}
+});
+const getWebSearchToolRecord = (item) => ({
+	toolCallId: item.id,
+	toolName: "WebSearch",
+	input: { query: item.query }
+});
+const mapToolCallStart = (toolRecord, context, options) => ({
+	events: [createAgentEvent(context.runId, "tool-call", {
+		sessionId: context.sessionId,
+		model: options.model ?? null,
+		toolCallId: toolRecord.toolCallId,
+		toolName: toolRecord.toolName,
+		input: toolRecord.input
+	})],
+	toolCalls: [{
+		toolCallId: toolRecord.toolCallId,
+		toolName: toolRecord.toolName,
+		input: toolRecord.input
+	}]
+});
+const mapToolResultCompletion = (toolRecord, output, errorState, context, options) => {
+	const priorToolCall = context.toolCalls.get(toolRecord.toolCallId);
+	const resolvedTool = priorToolCall ?? toolRecord;
+	const events = [];
+	const toolCalls = [];
+	if (!priorToolCall) {
+		events.push(createAgentEvent(context.runId, "tool-call", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			toolCallId: toolRecord.toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		}));
+		toolCalls.push({
+			toolCallId: toolRecord.toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		});
+	}
+	events.push(createAgentEvent(context.runId, "tool-result", {
+		sessionId: context.sessionId,
+		toolCallId: toolRecord.toolCallId,
+		toolName: resolvedTool.toolName,
+		input: resolvedTool.input,
+		output,
+		isError: errorState.isError || void 0,
+		error: errorState.error
+	}));
+	return {
+		events,
+		toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+	};
+};
+const getCommandErrorState = (item) => {
+	const isError = item.status === "failed" || item.exit_code !== void 0 && item.exit_code !== 0;
+	return {
+		isError,
+		error: isError ? `Command exited with code ${item.exit_code ?? 1}.` : void 0
+	};
+};
+const getMcpOutput = (item) => item.result?.structured_content ?? item.result?.content ?? item.error?.message ?? "";
+const getMcpErrorState = (item) => ({
+	isError: item.status === "failed" || item.error !== void 0,
+	error: item.error?.message
+});
+const mapErrorItem = (item, context) => ({
+	events: [createAgentEvent(context.runId, "stderr", {
+		sessionId: context.sessionId,
+		text: item.message
+	})],
+	state: { error: {
+		kind: "provider",
+		message: item.message
+	} }
+});
+const mapItemStartedEvent = (event, context, options) => {
+	switch (event.item.type) {
+		case "command_execution": return mapToolCallStart(getCommandToolRecord(event.item), context, options);
+		case "mcp_tool_call": return mapToolCallStart(getMcpToolRecord(event.item), context, options);
+		case "web_search": return mapToolCallStart(getWebSearchToolRecord(event.item), context, options);
+		default: return { events: [] };
+	}
+};
+const mapItemCompletedEvent = (event, context, options) => {
+	switch (event.item.type) {
+		case "agent_message": return {
+			events: [createAgentEvent(context.runId, "message", {
+				sessionId: context.sessionId,
+				model: options.model ?? null,
+				role: "assistant",
+				content: [toTextPart(event.item.text)],
+				text: event.item.text
+			})],
+			state: { output: { text: event.item.text } }
+		};
+		case "reasoning": return { events: [createAgentEvent(context.runId, "reasoning", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			content: [toTextPart(event.item.text)],
+			text: event.item.text
+		})] };
+		case "command_execution": return mapToolResultCompletion(getCommandToolRecord(event.item), event.item.aggregated_output, getCommandErrorState(event.item), context, options);
+		case "mcp_tool_call": return mapToolResultCompletion(getMcpToolRecord(event.item), getMcpOutput(event.item), getMcpErrorState(event.item), context, options);
+		case "web_search": return mapToolResultCompletion(getWebSearchToolRecord(event.item), "", { isError: false }, context, options);
+		case "error": return mapErrorItem(event.item, context);
+		default: return { events: [] };
+	}
+};
+const mapCodexSdkEvent = (event, context, options = {}) => {
+	switch (event.type) {
+		case "thread.started": return {
+			events: [],
+			sessionId: event.thread_id
+		};
+		case "turn.started": return { events: [] };
+		case "turn.completed": return {
+			events: [],
+			state: {
+				stats: toStats(event.usage),
+				status: "completed",
+				error: void 0
+			}
+		};
+		case "turn.failed": return {
+			events: [],
+			state: {
+				status: "failed",
+				error: {
+					kind: "provider",
+					message: event.error.message
+				}
+			}
+		};
+		case "item.started": return mapItemStartedEvent(event, context, options);
+		case "item.updated": return { events: [] };
+		case "item.completed": return mapItemCompletedEvent(event, context, options);
+		case "error": return {
+			events: [],
+			state: {
+				status: "failed",
+				error: {
+					kind: "provider",
+					message: event.message
+				}
+			}
+		};
+		default: return { events: [] };
+	}
+};
+//#endregion
+//#region src/adapters/codex-sdk/adapter.ts
+const CODEX_SDK_CAPABILITIES = {
+	structuredOutput: true,
+	sessionResume: true,
+	imageInput: true,
+	mcp: true,
+	eventStreaming: true
+};
+const toCodexInput = (input) => {
+	return input.length === 1 && input[0]?.type === "text" ? input[0].text : input.map((part) => part.type === "text" ? {
+		type: "text",
+		text: part.text
+	} : {
+		type: "local_image",
+		path: part.path
+	});
+};
+const buildTurnOptions = (run, signal) => ({
+	outputSchema: run.normalizedRequest.schema.kind === "none" ? void 0 : run.normalizedRequest.schema.jsonSchema,
+	signal
+});
+var CodexSdkAgentImpl = class extends SdkAgent {
+	type = "codex-sdk";
+	defaults;
+	runDefaults;
+	command;
+	codex;
+	resolvedEnv;
+	constructor(options = {}) {
+		super({
+			type: "codex-sdk",
+			capabilities: CODEX_SDK_CAPABILITIES,
+			sessionId: options.sessionId,
+			onEvent: options.onEvent
+		});
+		this.command = options.command;
+		this.defaults = {
+			cwd: options.cwd,
+			model: options.model
+		};
+		this.runDefaults = {
+			permissionMode: options.permissionMode,
+			sandboxMode: options.sandboxMode,
+			skipGitRepoCheck: options.skipGitRepoCheck,
+			modelReasoningEffort: options.modelReasoningEffort,
+			networkAccessEnabled: options.networkAccessEnabled,
+			webSearchMode: options.webSearchMode,
+			webSearchEnabled: options.webSearchEnabled,
+			additionalDirectories: options.additionalDirectories ? [...options.additionalDirectories] : void 0
+		};
+		const env = buildBaseProcessEnv({ propagateEnv: options.propagateEnv });
+		if (options.env) Object.assign(env, options.env);
+		this.resolvedEnv = env;
+		this.codex = options.codex ?? new Codex({
+			codexPathOverride: this.command,
+			baseUrl: options.baseUrl,
+			apiKey: options.apiKey,
+			config: options.config,
+			env
+		});
+	}
+	getResolvedEnvForTesting() {
+		return this.resolvedEnv;
+	}
+	get runRequestDefaults() {
+		return this.defaults;
+	}
+	async executeSdkRun(run, request, abortController) {
+		const threadOptions = this.buildThreadOptions(request, run);
+		const thread = run.requestedSessionId ? this.codex.resumeThread(run.requestedSessionId, threadOptions) : this.codex.startThread(threadOptions);
+		if (!run.sessionId && thread.id) {
+			run.sessionId = thread.id;
+			this.setSessionId(thread.id);
+		}
+		if (run.stopReason) return;
+		const streamed = await thread.runStreamed(toCodexInput(run.normalizedRequest.input), buildTurnOptions(run, abortController.signal));
+		for await (const event of streamed.events) {
+			const batch = mapCodexSdkEvent(event, {
+				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);
+		}
+		if (run.normalizedRequest.schema.kind !== "none" && run.output.value === void 0 && run.error === void 0 && run.status !== "failed" && run.output.text) try {
+			applyMappedEventBatch(run, {
+				events: [],
+				state: { output: { value: parseJsonResponseText(run.output.text) } }
+			});
+		} catch {}
+	}
+	buildThreadOptions(request, run) {
+		return {
+			model: run.normalizedRequest.model,
+			workingDirectory: run.normalizedRequest.cwd,
+			approvalPolicy: request.permissionMode ?? this.runDefaults.permissionMode,
+			sandboxMode: request.sandboxMode ?? this.runDefaults.sandboxMode,
+			skipGitRepoCheck: request.skipGitRepoCheck ?? this.runDefaults.skipGitRepoCheck,
+			modelReasoningEffort: request.modelReasoningEffort ?? this.runDefaults.modelReasoningEffort,
+			networkAccessEnabled: request.networkAccessEnabled ?? this.runDefaults.networkAccessEnabled,
+			webSearchMode: request.webSearchMode ?? this.runDefaults.webSearchMode,
+			webSearchEnabled: request.webSearchEnabled ?? this.runDefaults.webSearchEnabled,
+			additionalDirectories: request.additionalDirectories ?? this.runDefaults.additionalDirectories
+		};
+	}
+};
+const createCodexSdkAgent = (options) => new CodexSdkAgentImpl(options);
+//#endregion
+export { createCodexSdkAgent };

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

@@ -0,0 +1,2 @@
+import { a as GeminiCliRunOptions, i as GeminiCliPermissionMode, n as GeminiCliAgent, o as GeminiEvent, r as GeminiCliAgentOptions, t as createGeminiCliAgent } from "../../index-dRVpEAr8.mjs";
+export { GeminiCliAgent, GeminiCliAgentOptions, GeminiCliPermissionMode, GeminiCliRunOptions, GeminiEvent, createGeminiCliAgent };

package/dist/adapters/gemini-cli/index.mjs

@@ -0,0 +1,292 @@
+import { a as toArray, n as isRecord } from "../../util-B4RQZkKr.mjs";
+import { 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 { z } from "zod/v4";
+//#region src/adapters/gemini-cli/events/mappers.ts
+const asString = (value) => typeof value === "string" ? value : void 0;
+const asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const extractText = (value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(extractText).join("");
+	if (isRecord(value)) {
+		const text = asString(value.text);
+		if (text) return text;
+		const parts = value.parts ?? value.content;
+		if (Array.isArray(parts)) return parts.map(extractText).join("");
+	}
+	return "";
+};
+const stringifyValue = (value) => {
+	if (typeof value === "string") return value;
+	if (value === null || value === void 0) return "";
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+};
+const nextId = () => crypto.randomUUID();
+const getGeminiSessionId = (event) => {
+	const raw = event;
+	const sessionId = asString(raw.session_id) ?? asString(raw.sessionId);
+	if (sessionId) return sessionId;
+	if (isRecord(raw.message)) return asString(raw.message.session_id) ?? asString(raw.message.sessionId);
+};
+const mapInitEvent = (_raw, context) => {
+	const text = "[init]";
+	return { events: [createAgentEvent(context.runId, "message", {
+		sessionId: context.sessionId,
+		model: null,
+		role: "system",
+		content: [toTextPart(text)],
+		text
+	})] };
+};
+const mapMessageEvent = (raw, context, options) => {
+	const payload = isRecord(raw.message) ? raw.message : raw;
+	const role = asString(payload.role) ?? asString(raw.role) ?? "assistant";
+	const model = asString(payload.model) ?? asString(raw.model) ?? options.model ?? null;
+	const text = extractText(payload.content ?? payload.parts ?? payload.text ?? raw.content ?? raw.text);
+	if (!text?.trim()) return { events: [] };
+	if (role === "assistant") return { events: [createAgentEvent(context.runId, "message", {
+		sessionId: context.sessionId,
+		model,
+		role: "assistant",
+		content: [toTextPart(text)],
+		text
+	})] };
+	return { events: [createAgentEvent(context.runId, "message", {
+		sessionId: context.sessionId,
+		model: null,
+		role: "user",
+		content: [toTextPart(text)],
+		text
+	})] };
+};
+const mapThoughtEvent = (raw, context, options) => {
+	const text = asString(raw.thought) ?? asString(raw.text) ?? asString(raw.content) ?? "";
+	if (!text.trim()) return { events: [] };
+	return { events: [createAgentEvent(context.runId, "reasoning", {
+		sessionId: context.sessionId,
+		model: options.model ?? null,
+		content: [toTextPart(text)],
+		text
+	})] };
+};
+const mapToolUseEvent = (raw, context, options) => {
+	const toolCallId = asString(raw.tool_id) ?? asString(raw.id) ?? nextId();
+	const toolName = asString(raw.tool_name) ?? asString(raw.name) ?? "tool";
+	const input = (isRecord(raw.parameters) ? raw.parameters : void 0) ?? (isRecord(raw.args) ? raw.args : void 0) ?? (isRecord(raw.input) ? raw.input : void 0) ?? {};
+	return {
+		events: [createAgentEvent(context.runId, "tool-call", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			toolCallId,
+			toolName,
+			input
+		})],
+		toolCalls: [{
+			toolCallId,
+			toolName,
+			input
+		}]
+	};
+};
+const mapToolResultEvent = (raw, context) => {
+	const toolCallId = asString(raw.tool_id) ?? asString(raw.tool_use_id) ?? asString(raw.id) ?? nextId();
+	const status = asString(raw.status);
+	const isError = status ? status !== "success" : Boolean(raw.error);
+	const output = raw.output ?? raw.result ?? raw.content ?? raw.message ?? (typeof raw.error === "string" ? raw.error : void 0);
+	const outputStr = stringifyValue(output);
+	const tool = context.toolCalls.get(toolCallId);
+	return { events: [createAgentEvent(context.runId, "tool-result", {
+		sessionId: context.sessionId,
+		toolCallId,
+		toolName: tool?.toolName,
+		input: tool?.input,
+		output: outputStr,
+		isError: isError || void 0,
+		error: isError ? stringifyValue(raw.error ?? output) : void 0
+	})] };
+};
+const extractUsage = (raw) => {
+	const tokenCount = (isRecord(raw.token_count) ? raw.token_count : void 0) ?? (isRecord(raw.tokenCount) ? raw.tokenCount : void 0) ?? (isRecord(raw.usage) ? raw.usage : void 0) ?? (isRecord(raw.usage_metadata) ? raw.usage_metadata : void 0) ?? (isRecord(raw.usageMetadata) ? raw.usageMetadata : void 0) ?? (isRecord(raw.stats) ? raw.stats : void 0);
+	if (!tokenCount) return void 0;
+	const inputTokens = asNumber(tokenCount.prompt_tokens) ?? asNumber(tokenCount.promptTokens) ?? asNumber(tokenCount.input_tokens) ?? asNumber(tokenCount.inputTokens) ?? asNumber(tokenCount.prompt_token_count);
+	const outputTokens = asNumber(tokenCount.completion_tokens) ?? asNumber(tokenCount.output_tokens) ?? asNumber(tokenCount.outputTokens) ?? asNumber(tokenCount.candidates_token_count) ?? asNumber(tokenCount.completion_token_count);
+	if (inputTokens === void 0 && outputTokens === void 0) return void 0;
+	return {
+		inputTokens: inputTokens ?? 0,
+		outputTokens: outputTokens ?? 0
+	};
+};
+const mapResultEvent = (raw, context) => {
+	const status = asString(raw.status) ?? asString(raw.subtype) ?? "success";
+	const isError = status !== "success" || Boolean(raw.error) || raw.is_error === true;
+	const resultValue = raw.result ?? raw.output ?? raw.text ?? raw.content;
+	const durationMs = asNumber(raw.duration_ms) ?? asNumber(raw.durationMs) ?? (isRecord(raw.stats) ? asNumber(raw.stats.total_time_ms) : void 0) ?? 0;
+	const usage = extractUsage(raw);
+	const totalTokens = usage ? usage.inputTokens + usage.outputTokens : void 0;
+	const state = { stats: {
+		durationMs,
+		apiDurationMs: durationMs,
+		turns: asNumber(raw.num_turns) ?? 1,
+		costUsd: asNumber(raw.total_cost_usd) ?? 0,
+		inputTokens: usage?.inputTokens,
+		outputTokens: usage?.outputTokens,
+		totalTokens
+	} };
+	if (typeof resultValue === "string") state.output = { text: resultValue };
+	if (raw.structured_output !== void 0) state.output = {
+		...state.output,
+		value: raw.structured_output
+	};
+	else if (context.schemaRequested && resultValue !== void 0) state.output = {
+		...state.output,
+		value: resultValue
+	};
+	if (isError) {
+		state.status = "failed";
+		state.error = {
+			kind: "provider",
+			message: asString(raw.error) ?? (typeof resultValue === "string" && resultValue.trim() ? resultValue : stringifyValue(raw.error ?? resultValue ?? status))
+		};
+	} else state.status = "completed";
+	return {
+		events: [],
+		state
+	};
+};
+const mapErrorEvent = (raw, context) => {
+	const message = asString(raw.message) ?? (raw.error === void 0 ? void 0 : stringifyValue(raw.error)) ?? (raw.details === void 0 ? void 0 : stringifyValue(raw.details)) ?? "Gemini emitted an error event.";
+	return { events: [createAgentEvent(context.runId, "stderr", {
+		sessionId: context.sessionId,
+		text: message
+	})] };
+};
+const mapGeminiEvent = (event, context, options = {}) => {
+	const raw = event;
+	switch (event.type) {
+		case "init": return mapInitEvent(raw, context);
+		case "message": return mapMessageEvent(raw, context, options);
+		case "thought": return mapThoughtEvent(raw, context, options);
+		case "tool_use": return mapToolUseEvent(raw, context, options);
+		case "tool_result": return mapToolResultEvent(raw, context);
+		case "result": return mapResultEvent(raw, context);
+		case "error": return mapErrorEvent(raw, context);
+		default: return { events: [] };
+	}
+};
+//#endregion
+//#region src/adapters/gemini-cli/events/parser.ts
+const parseGeminiEvent = createEventParser(z.object({ type: z.string() }).passthrough());
+//#endregion
+//#region src/adapters/gemini-cli/adapter.ts
+const GEMINI_CLI_CAPABILITIES = {
+	structuredOutput: false,
+	sessionResume: true,
+	imageInput: false,
+	mcp: true,
+	eventStreaming: true
+};
+var GeminiCliAgentImpl = class extends Agent {
+	type = "gemini-cli";
+	creationOptions;
+	runDefaults;
+	runModels = /* @__PURE__ */ new Map();
+	runTextBuffers = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		super({
+			type: "gemini-cli",
+			capabilities: GEMINI_CLI_CAPABILITIES,
+			defaults: {
+				cwd: options.cwd,
+				env: options.env,
+				command: toArray(options.command ?? "gemini"),
+				sessionId: options.sessionId,
+				model: options.model,
+				systemPrompt: options.systemPrompt
+			},
+			spawner: options.spawner,
+			container: options.container,
+			logPath: options.logPath,
+			onEvent: options.onEvent
+		});
+		this.creationOptions = options;
+		this.runDefaults = {
+			allowedTools: options.allowedTools ? [...options.allowedTools] : void 0,
+			disallowedTools: options.disallowedTools ? [...options.disallowedTools] : void 0,
+			permissionMode: options.permissionMode,
+			extraArgs: options.extraArgs ? [...options.extraArgs] : void 0
+		};
+	}
+	buildArgs(request, run) {
+		const args = ["--output-format", "stream-json"];
+		const inputText = getInputText(request.input);
+		const allowedTools = request.allowedTools ?? this.runDefaults.allowedTools;
+		const disallowedTools = request.disallowedTools ?? this.runDefaults.disallowedTools;
+		const permissionMode = request.permissionMode ?? this.runDefaults.permissionMode;
+		const extraArgs = request.extraArgs ?? this.runDefaults.extraArgs;
+		this.runModels.set(run.runId, request.model);
+		if (request.model) args.push("--model", request.model);
+		if (request.systemPrompt) args.push("--system-prompt", request.systemPrompt);
+		if (permissionMode === "full") args.push("--approval-mode", "yolo");
+		if (allowedTools && allowedTools.length > 0) {
+			const disallowed = new Set((disallowedTools ?? []).map((t) => t.toLowerCase()));
+			const filtered = allowedTools.filter((t) => !disallowed.has(t.toLowerCase()));
+			for (const tool of filtered) args.push("--allowed-tools", tool);
+		}
+		if (run.requestedSessionId) args.push("--resume", run.requestedSessionId);
+		if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
+		if (inputText.trim().startsWith("-")) args.push("--prompt", inputText);
+		else args.push(inputText);
+		return args;
+	}
+	buildEnv(_request, _run) {
+		return this.buildDefaultEnv(this.creationOptions.propagateEnv);
+	}
+	mapRawEvent(raw, context) {
+		this.appendRawLog(raw);
+		const parsed = parseGeminiEvent(raw);
+		if (!parsed) {
+			this.onParseError(JSON.stringify(raw).slice(0, 200), /* @__PURE__ */ new Error("schema validation failed"));
+			return { events: [] };
+		}
+		const sessionId = getGeminiSessionId(parsed) ?? context.sessionId;
+		const batch = mapGeminiEvent(parsed, {
+			...context,
+			sessionId
+		}, { model: this.runModels.get(context.runId) });
+		if (sessionId && batch.sessionId === void 0) batch.sessionId = sessionId;
+		let assistantText;
+		for (const event of batch.events) {
+			if (event.type !== "message" || event.role !== "assistant" || !event.text) continue;
+			const nextText = `${this.runTextBuffers.get(context.runId) ?? ""}${event.text}`;
+			this.runTextBuffers.set(context.runId, nextText);
+			assistantText = nextText;
+		}
+		if (parsed.type === "result" && batch.state?.output?.text !== void 0) this.runTextBuffers.set(context.runId, batch.state.output.text);
+		else if (assistantText !== void 0) batch.state = {
+			...batch.state,
+			output: {
+				...batch.state?.output,
+				text: assistantText
+			}
+		};
+		return batch;
+	}
+	async onRunFinished(run) {
+		await super.onRunFinished(run);
+		this.runModels.delete(run.runId);
+		this.runTextBuffers.delete(run.runId);
+	}
+};
+const createGeminiCliAgent = (options) => {
+	if (!options?.container) return new GeminiCliAgentImpl(options);
+	return new GeminiCliAgentImpl({
+		...options,
+		spawner: options.container.spawner
+	});
+};
+//#endregion
+export { createGeminiCliAgent };