@omarestrella/ai-sdk-agent-sdk 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.d.mts

@@ -0,0 +1,41 @@
+import { LanguageModelV2 } from "@ai-sdk/provider";
+
+//#region src/provider.d.ts
+interface ClaudeAgentProviderSettings {
+  name?: string;
+  /**
+   * Working directory for the Agent SDK.
+   * @default process.cwd()
+   */
+  cwd?: string;
+}
+interface ClaudeAgentProvider {
+  (modelId: string): LanguageModelV2;
+  languageModel(modelId: string): LanguageModelV2;
+}
+declare function createClaudeAgent(options?: ClaudeAgentProviderSettings): ClaudeAgentProvider;
+//#endregion
+//#region src/language-model.d.ts
+interface ClaudeAgentLanguageModelConfig {
+  provider: string;
+  cwd?: string;
+}
+type DoGenerateOptions = Parameters<LanguageModelV2["doGenerate"]>[0];
+type DoGenerateResult = Awaited<ReturnType<LanguageModelV2["doGenerate"]>>;
+type DoStreamOptions = Parameters<LanguageModelV2["doStream"]>[0];
+type DoStreamResult = Awaited<ReturnType<LanguageModelV2["doStream"]>>;
+declare class ClaudeAgentLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion: "v2";
+  readonly modelId: string;
+  readonly defaultObjectGenerationMode: undefined;
+  private readonly config;
+  constructor(modelId: string, config: ClaudeAgentLanguageModelConfig);
+  get provider(): string;
+  get supportedUrls(): Record<string, RegExp[]>;
+  private buildQueryOptions;
+  doGenerate(options: DoGenerateOptions): Promise<DoGenerateResult>;
+  doStream(options: DoStreamOptions): Promise<DoStreamResult>;
+}
+//#endregion
+export { ClaudeAgentLanguageModel, type ClaudeAgentProvider, type ClaudeAgentProviderSettings, createClaudeAgent as create, createClaudeAgent };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/provider.ts","../src/language-model.ts"],"mappings":";;;UAQiB,2BAAA;EACf,IAAA;EADe;;;;EAOf,GAAA;AAAA;AAAA,UAGe,mBAAA;EAAA,CACd,OAAA,WAAkB,eAAA;EACnB,aAAA,CAAc,OAAA,WAAkB,eAAA;AAAA;AAAA,iBAGlB,iBAAA,CACd,OAAA,GAAS,2BAAA,GACR,mBAAA;;;UCuBc,8BAAA;EACf,QAAA;EACA,GAAA;AAAA;AAAA,KAGG,iBAAA,GAAoB,UAAA,CAAW,eAAA;AAAA,KAC/B,gBAAA,GAAmB,OAAA,CAAQ,UAAA,CAAW,eAAA;AAAA,KACtC,eAAA,GAAkB,UAAA,CAAW,eAAA;AAAA,KAC7B,cAAA,GAAiB,OAAA,CAAQ,UAAA,CAAW,eAAA;AAAA,cAO5B,wBAAA,YAAoC,eAAA;EAAA,SACtC,oBAAA;EAAA,SACA,OAAA;EAAA,SACA,2BAAA;EAAA,iBAEQ,MAAA;cAEL,OAAA,UAAiB,MAAA,EAAQ,8BAAA;EAAA,IAKjC,QAAA,CAAA;EAAA,IAIA,aAAA,CAAA,GAAiB,MAAA,SAAe,MAAA;EAAA,QAI5B,iBAAA;EAmCF,UAAA,CAAW,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,gBAAA;EA0GhD,QAAA,CAAS,OAAA,EAAS,eAAA,GAAkB,OAAA,CAAQ,cAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,641 @@
+import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
+import { createWriteStream, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import * as z from "zod";
+
+//#region src/logger.ts
+/**
+* This is a weird file. We want to log to a file, but only if the consola package
+* we are using is available.
+*/
+const LOG_LEVEL = process.env.LOG_LEVEL || "debug";
+const LOG_DIR = process.env.LOG_DIR || join(homedir(), ".cache", "ai-sdk-claude-agent");
+const LOG_FILE = process.env.LOG_FILE || "ai-sdk-claude-agent.log";
+if (!existsSync(LOG_DIR)) try {
+	mkdirSync(LOG_DIR, { recursive: true });
+} catch {}
+const LOG_FILE_PATH = join(LOG_DIR, LOG_FILE);
+let logStream = null;
+function getLogStream() {
+	if (!logStream) logStream = createWriteStream(LOG_FILE_PATH, { flags: "a" });
+	return logStream;
+}
+let consolaInstance = null;
+let consolaLoadAttempted = false;
+/**
+* Dynamically loads consola if available.
+* This is an optional peer dependency - if not installed, logging is a no-op.
+*/
+async function loadConsola() {
+	if (consolaLoadAttempted) return consolaInstance;
+	consolaLoadAttempted = true;
+	try {
+		const { createConsola } = await import("consola");
+		const reporters = [];
+		if (LOG_FILE) reporters.push({ log: (logObj) => {
+			const levelName = {
+				0: "ERROR",
+				1: "WARN",
+				2: "LOG",
+				3: "INFO",
+				4: "DEBUG",
+				5: "TRACE"
+			}[logObj.level] || "LOG";
+			const message = logObj.args.map((arg) => typeof arg === "object" ? safeJsonStringify(arg) : String(arg)).join(" ");
+			const line = safeJsonStringify({
+				timestamp: logObj.date.toISOString(),
+				level: levelName,
+				message
+			}) + "\n";
+			getLogStream().write(line);
+		} });
+		consolaInstance = createConsola({
+			level: LOG_LEVEL === "trace" ? 5 : LOG_LEVEL === "debug" ? 4 : LOG_LEVEL === "info" ? 3 : LOG_LEVEL === "warn" ? 1 : 0,
+			reporters
+		});
+		consolaInstance.info("Logger initialized with consola", {
+			level: LOG_LEVEL,
+			file: LOG_FILE_PATH
+		});
+		return consolaInstance;
+	} catch {
+		return null;
+	}
+}
+const consolaPromise = loadConsola();
+/**
+* Logger interface that wraps consola if available, otherwise no-op.
+*/
+const logger = {
+	debug(message, ...args) {
+		if (consolaInstance) consolaInstance.debug(message, ...args);
+		else consolaPromise.then((c) => c?.debug(message, ...args));
+	},
+	info(message, ...args) {
+		if (consolaInstance) consolaInstance.info(message, ...args);
+		else consolaPromise.then((c) => c?.info(message, ...args));
+	},
+	warn(message, ...args) {
+		if (consolaInstance) consolaInstance.warn(message, ...args);
+		else consolaPromise.then((c) => c?.warn(message, ...args));
+	},
+	error(message, ...args) {
+		if (consolaInstance) consolaInstance.error(message, ...args);
+		else consolaPromise.then((c) => c?.error(message, ...args));
+	},
+	log(message, ...args) {
+		this.info(message, ...args);
+	}
+};
+
+//#endregion
+//#region src/json.ts
+/**
+* Safely serializes a value to JSON, handling circular references
+* by replacing them with `[Circular]`.
+*/
+function safeJsonStringify(value, space) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (key, val) => {
+			if (val === null || typeof val !== "object") return val;
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+			return val;
+		}, space);
+	} catch (e) {
+		const err = e;
+		logger.error("Cannot stringify JSON", {
+			error: err.message,
+			stack: err.stack
+		});
+		return "{}";
+	}
+}
+
+//#endregion
+//#region src/messages.ts
+/**
+* Converts an AI SDK LanguageModelV2 prompt (array of system/user/assistant/tool messages)
+* into a system prompt string and a user prompt string for the Claude Agent SDK's query().
+*
+* Since we use maxTurns: 1, the Agent SDK makes a single LLM call. We serialize the full
+* conversation history into the prompt so the LLM has context from prior turns.
+*/
+function convertMessages(messages) {
+	logger.debug("Converting messages:", { count: messages.length });
+	const systemParts = [];
+	const conversationParts = [];
+	for (const message of messages) {
+		logger.debug("Processing message:", { role: message.role });
+		switch (message.role) {
+			case "system":
+				systemParts.push(message.content);
+				break;
+			case "user": {
+				const parts = [];
+				logger.debug("Processing user message parts:", { count: message.content.length });
+				for (const part of message.content) switch (part.type) {
+					case "text":
+						parts.push(part.text);
+						break;
+					case "file":
+						parts.push(`[File: ${part.filename ?? part.mediaType}]`);
+						break;
+				}
+				if (parts.length > 0) conversationParts.push(`[user]\n${parts.join("\n")}`);
+				break;
+			}
+			case "assistant": {
+				const parts = [];
+				logger.debug("Processing assistant message parts:", { count: message.content.length });
+				for (const part of message.content) switch (part.type) {
+					case "text":
+						parts.push(part.text);
+						break;
+					case "tool-call":
+						parts.push(`[tool_call: ${part.toolName}(${safeJsonStringify(part.input)})]`);
+						break;
+					case "reasoning":
+						parts.push(`[thinking]\n${part.text}\n[/thinking]`);
+						break;
+				}
+				if (parts.length > 0) conversationParts.push(`[assistant]\n${parts.join("\n")}`);
+				break;
+			}
+			case "tool": {
+				const parts = [];
+				for (const part of message.content) {
+					const output = part.output;
+					let outputText;
+					if (Array.isArray(output)) outputText = output.map((o) => {
+						if (o.type === "text") return o.text;
+						return `[${o.type}]`;
+					}).join("\n");
+					else outputText = typeof output === "string" ? output : safeJsonStringify(output);
+					parts.push(`[tool_result: ${part.toolName} (id: ${part.toolCallId})]\n${outputText}`);
+				}
+				if (parts.length > 0) conversationParts.push(parts.join("\n"));
+				break;
+			}
+		}
+	}
+	return {
+		systemPrompt: systemParts.join("\n\n"),
+		prompt: conversationParts.join("\n\n")
+	};
+}
+
+//#endregion
+//#region src/tools.ts
+/**
+* The name of the MCP server that hosts AI SDK tools.
+* This is used to identify tools when the Agent SDK returns them
+* in the format: mcp__{SERVER_NAME}__{tool_name}
+*/
+const AI_SDK_MCP_SERVER_NAME = "ai-sdk-tools";
+/**
+* Extracts Zod schema from AI SDK tool inputSchema using Zod 4's native
+* JSON Schema conversion.
+*/
+function extractZodSchema(tool) {
+	const inputSchema = tool.inputSchema;
+	if (!inputSchema || typeof inputSchema !== "object") return {};
+	try {
+		const zodSchema = z.fromJSONSchema(inputSchema);
+		if (zodSchema instanceof z.ZodObject) return zodSchema.shape;
+		return { value: zodSchema };
+	} catch (error) {
+		logger.error("Failed to convert JSON Schema to Zod:", {
+			tool: tool.name,
+			error
+		});
+		return {};
+	}
+}
+/**
+* Converts AI SDK function tool definitions into an in-process Agent SDK MCP server.
+*
+* Each AI SDK tool becomes an MCP tool with proper parameter validation.
+* Since we use maxTurns: 1, the Agent SDK will report tool_use blocks in the
+* assistant message but won't execute them. The AI SDK caller handles actual
+* tool execution.
+*/
+function convertTools(tools) {
+	if (!tools || tools.length === 0) return void 0;
+	logger.debug("Converting tools:", {
+		count: tools.length,
+		tools: tools.map((t) => t.name)
+	});
+	const mcpTools = tools.map((aiTool) => {
+		const zodSchema = extractZodSchema(aiTool);
+		logger.debug("Creating tool:", {
+			name: aiTool.name,
+			schemaKeys: Object.keys(zodSchema)
+		});
+		return tool(aiTool.name, aiTool.description ?? "", zodSchema, async () => {
+			return { content: [{
+				type: "text",
+				text: safeJsonStringify({
+					_deferred: true,
+					message: "Tool execution deferred to AI SDK caller"
+				})
+			}] };
+		});
+	});
+	logger.info("Created MCP server with", mcpTools.length, "tools");
+	const mcpServer = createSdkMcpServer({
+		name: AI_SDK_MCP_SERVER_NAME,
+		tools: mcpTools
+	});
+	const allowedTools = tools.map((t) => `mcp__${AI_SDK_MCP_SERVER_NAME}__${t.name}`);
+	logger.debug("Allowed tools:", allowedTools);
+	return {
+		mcpServer,
+		allowedTools
+	};
+}
+
+//#endregion
+//#region src/language-model.ts
+/**
+* Strips the MCP prefix from tool names returned by the Agent SDK.
+* The Agent SDK returns tools in format: mcp__{serverName}__{toolName}
+* The AI SDK expects just the original tool name.
+*/
+function stripMcpPrefix(toolName) {
+	const prefix = `mcp__${AI_SDK_MCP_SERVER_NAME}__`;
+	if (toolName.startsWith(prefix)) return toolName.slice(prefix.length);
+	return toolName;
+}
+function mapFinishReason(stopReason, hasToolCalls) {
+	if (hasToolCalls) return "tool-calls";
+	switch (stopReason) {
+		case "end_turn": return "stop";
+		case "max_tokens": return "length";
+		case "stop_sequence": return "stop";
+		case "tool_use": return "tool-calls";
+		default: return "unknown";
+	}
+}
+let idCounter = 0;
+function generateId() {
+	return `agent-${Date.now()}-${++idCounter}`;
+}
+var ClaudeAgentLanguageModel = class {
+	specificationVersion = "v2";
+	modelId;
+	defaultObjectGenerationMode = void 0;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get supportedUrls() {
+		return {};
+	}
+	buildQueryOptions(options) {
+		const { systemPrompt, prompt } = convertMessages(options.prompt);
+		const convertedTools = convertTools(options.tools);
+		const abortController = new AbortController();
+		if (options.abortSignal) options.abortSignal.addEventListener("abort", () => {
+			abortController.abort();
+		});
+		const queryOptions = {
+			model: this.modelId,
+			maxTurns: 1,
+			permissionMode: "bypassPermissions",
+			allowDangerouslySkipPermissions: true,
+			abortController,
+			tools: [],
+			allowedTools: [`mcp__${AI_SDK_MCP_SERVER_NAME}__*`],
+			...this.config.cwd ? { cwd: this.config.cwd } : {}
+		};
+		if (systemPrompt) queryOptions.systemPrompt = systemPrompt;
+		if (convertedTools?.mcpServer) queryOptions.mcpServers = { [AI_SDK_MCP_SERVER_NAME]: convertedTools.mcpServer };
+		return {
+			prompt,
+			queryOptions
+		};
+	}
+	async doGenerate(options) {
+		const warnings = [];
+		const { prompt, queryOptions } = this.buildQueryOptions(options);
+		const generator = query({
+			prompt,
+			options: queryOptions
+		});
+		const content = [];
+		let usage = {
+			inputTokens: void 0,
+			outputTokens: void 0,
+			totalTokens: void 0
+		};
+		let finishReason = "unknown";
+		let hasToolCalls = false;
+		const seenMessageIds = /* @__PURE__ */ new Set();
+		for await (const message of generator) {
+			if (message.type === "assistant") {
+				const apiMessage = message.message;
+				const messageId = message.uuid;
+				if (Array.isArray(apiMessage.content)) {
+					for (const block of apiMessage.content) if (block.type === "text") content.push({
+						type: "text",
+						text: block.text
+					});
+					else if (block.type === "tool_use") {
+						hasToolCalls = true;
+						const originalToolName = stripMcpPrefix(block.name);
+						content.push({
+							type: "tool-call",
+							toolCallId: block.id,
+							toolName: originalToolName,
+							input: typeof block.input === "string" ? block.input : safeJsonStringify(block.input)
+						});
+					} else if (block.type === "thinking") content.push({
+						type: "reasoning",
+						text: block.thinking ?? ""
+					});
+					if (apiMessage.usage && messageId && !seenMessageIds.has(messageId)) {
+						seenMessageIds.add(messageId);
+						usage = {
+							inputTokens: apiMessage.usage.input_tokens,
+							outputTokens: apiMessage.usage.output_tokens,
+							totalTokens: (apiMessage.usage.input_tokens ?? 0) + (apiMessage.usage.output_tokens ?? 0)
+						};
+						logger.debug("Usage reported in doGenerate", {
+							messageId,
+							inputTokens: usage.inputTokens,
+							outputTokens: usage.outputTokens,
+							totalTokens: usage.totalTokens
+						});
+					}
+					finishReason = mapFinishReason(apiMessage.stop_reason, hasToolCalls);
+				}
+			}
+			if (message.type === "result") {
+				if (message.usage) {
+					usage = {
+						inputTokens: message.usage.input_tokens ?? usage.inputTokens,
+						outputTokens: message.usage.output_tokens ?? usage.outputTokens,
+						totalTokens: usage.totalTokens
+					};
+					logger.debug("Final usage from result message", {
+						inputTokens: usage.inputTokens,
+						outputTokens: usage.outputTokens
+					});
+				}
+			}
+		}
+		if (usage.inputTokens !== void 0 && usage.outputTokens !== void 0) usage.totalTokens = usage.inputTokens + usage.outputTokens;
+		return {
+			content,
+			finishReason,
+			usage,
+			warnings,
+			request: { body: queryOptions },
+			response: { headers: void 0 }
+		};
+	}
+	async doStream(options) {
+		const warnings = [];
+		const { prompt, queryOptions } = this.buildQueryOptions(options);
+		queryOptions.includePartialMessages = true;
+		const generator = query({
+			prompt,
+			options: queryOptions
+		});
+		let hasToolCalls = false;
+		return {
+			stream: new ReadableStream({ async start(controller) {
+				controller.enqueue({
+					type: "stream-start",
+					warnings
+				});
+				let finishReason = "unknown";
+				let usage = {
+					inputTokens: void 0,
+					outputTokens: void 0,
+					totalTokens: void 0
+				};
+				let activeTextId = null;
+				let activeReasoningId = null;
+				const toolCalls = /* @__PURE__ */ new Map();
+				const seenMessageIds = /* @__PURE__ */ new Set();
+				try {
+					for await (const message of generator) if (message.type === "stream_event") {
+						const event = message.event;
+						if (!event || !event.type) continue;
+						switch (event.type) {
+							case "message_start": {
+								const msg = event.message;
+								if (msg) {
+									controller.enqueue({
+										type: "response-metadata",
+										id: msg.id,
+										timestamp: /* @__PURE__ */ new Date(),
+										modelId: msg.model
+									});
+									if (msg.usage) {
+										usage.inputTokens = msg.usage.input_tokens;
+										logger.debug("Initial usage reported in doStream (message_start)", { inputTokens: usage.inputTokens });
+									}
+								}
+								break;
+							}
+							case "content_block_start": {
+								const block = event.content_block;
+								const index = event.index;
+								if (block?.type === "text") {
+									activeTextId = generateId();
+									controller.enqueue({
+										type: "text-start",
+										id: activeTextId
+									});
+								} else if (block?.type === "tool_use") {
+									hasToolCalls = true;
+									const id = block.id ?? generateId();
+									toolCalls.set(index, {
+										toolCallId: id,
+										toolName: block.name,
+										argsText: ""
+									});
+									controller.enqueue({
+										type: "tool-input-start",
+										id,
+										toolName: block.name
+									});
+								} else if (block?.type === "thinking") {
+									activeReasoningId = generateId();
+									controller.enqueue({
+										type: "reasoning-start",
+										id: activeReasoningId
+									});
+								}
+								break;
+							}
+							case "content_block_delta": {
+								const delta = event.delta;
+								const index = event.index;
+								if (delta?.type === "text_delta") {
+									if (!activeTextId) {
+										activeTextId = generateId();
+										controller.enqueue({
+											type: "text-start",
+											id: activeTextId
+										});
+									}
+									controller.enqueue({
+										type: "text-delta",
+										id: activeTextId,
+										delta: delta.text
+									});
+								} else if (delta?.type === "input_json_delta") {
+									const tc = toolCalls.get(index);
+									if (tc) {
+										tc.argsText += delta.partial_json;
+										controller.enqueue({
+											type: "tool-input-delta",
+											id: tc.toolCallId,
+											delta: delta.partial_json
+										});
+									}
+								} else if (delta?.type === "thinking_delta") {
+									if (!activeReasoningId) {
+										activeReasoningId = generateId();
+										controller.enqueue({
+											type: "reasoning-start",
+											id: activeReasoningId
+										});
+									}
+									controller.enqueue({
+										type: "reasoning-delta",
+										id: activeReasoningId,
+										delta: delta.thinking
+									});
+								}
+								break;
+							}
+							case "content_block_stop": {
+								const index = event.index;
+								const tc = toolCalls.get(index);
+								if (tc) {
+									const originalToolName = stripMcpPrefix(tc.toolName);
+									controller.enqueue({
+										type: "tool-input-end",
+										id: tc.toolCallId
+									});
+									controller.enqueue({
+										type: "tool-call",
+										toolCallId: tc.toolCallId,
+										toolName: originalToolName,
+										input: tc.argsText
+									});
+									toolCalls.delete(index);
+								} else if (activeTextId) {
+									controller.enqueue({
+										type: "text-end",
+										id: activeTextId
+									});
+									activeTextId = null;
+								} else if (activeReasoningId) {
+									controller.enqueue({
+										type: "reasoning-end",
+										id: activeReasoningId
+									});
+									activeReasoningId = null;
+								}
+								break;
+							}
+							case "message_delta":
+								if (event.usage) {
+									usage.outputTokens = event.usage.output_tokens;
+									if (usage.inputTokens !== void 0) usage.totalTokens = usage.inputTokens + (event.usage.output_tokens ?? 0);
+									logger.debug("Usage delta reported in doStream (message_delta)", {
+										outputTokens: usage.outputTokens,
+										totalTokens: usage.totalTokens
+									});
+								}
+								finishReason = mapFinishReason(event.delta?.stop_reason, hasToolCalls);
+								break;
+							case "message_stop": break;
+						}
+					} else if (message.type === "assistant") {
+						const apiMessage = message.message;
+						const messageId = message.uuid;
+						if (Array.isArray(apiMessage?.content)) {
+							for (const block of apiMessage.content) if (block.type === "tool_use") hasToolCalls = true;
+						}
+						if (apiMessage?.usage && messageId && !seenMessageIds.has(messageId)) {
+							seenMessageIds.add(messageId);
+							logger.debug("Assistant message usage (already tracked from streaming)", {
+								messageId,
+								inputTokens: apiMessage.usage.input_tokens,
+								outputTokens: apiMessage.usage.output_tokens
+							});
+						}
+						if (apiMessage?.stop_reason) finishReason = mapFinishReason(apiMessage.stop_reason, hasToolCalls);
+					} else if (message.type === "result") {
+						const result = message;
+						if (result.usage) {
+							usage.inputTokens = result.usage.input_tokens ?? usage.inputTokens;
+							usage.outputTokens = result.usage.output_tokens ?? usage.outputTokens;
+							logger.debug("Final usage from result message", {
+								inputTokens: usage.inputTokens,
+								outputTokens: usage.outputTokens
+							});
+						}
+					}
+				} catch (error) {
+					controller.enqueue({
+						type: "error",
+						error
+					});
+				}
+				if (activeTextId) controller.enqueue({
+					type: "text-end",
+					id: activeTextId
+				});
+				if (activeReasoningId) controller.enqueue({
+					type: "reasoning-end",
+					id: activeReasoningId
+				});
+				if (usage.inputTokens !== void 0 && usage.outputTokens !== void 0) usage.totalTokens = usage.inputTokens + usage.outputTokens;
+				controller.enqueue({
+					type: "finish",
+					finishReason,
+					usage
+				});
+				controller.close();
+			} }),
+			request: { body: queryOptions },
+			response: { headers: void 0 }
+		};
+	}
+};
+
+//#endregion
+//#region src/provider.ts
+function createClaudeAgent(options = {}) {
+	const config = {
+		provider: options.name ?? "claude-agent",
+		cwd: options.cwd
+	};
+	logger.debug("Creating agent with:", safeJsonStringify(options));
+	const createLanguageModel = (modelId) => {
+		return new ClaudeAgentLanguageModel(modelId, config);
+	};
+	const provider = function(modelId) {
+		return createLanguageModel(modelId);
+	};
+	provider.languageModel = createLanguageModel;
+	return provider;
+}
+
+//#endregion
+export { ClaudeAgentLanguageModel, createClaudeAgent as create, createClaudeAgent };
+//# sourceMappingURL=index.mjs.map