@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.1

package/dist/agent/index.mjs

@@ -0,0 +1,1318 @@
+import { describeEndpoint } from "../runtime/handlers/shared/describe-endpoint.mjs";
+import { createSafeUrlDownload, logModelCallError, resolveUrlDownloadSetting } from "./url-download.mjs";
+import { createStateEventNormalizer } from "./state-delta.mjs";
+import { collectStandardRunFinishedDetails, getNonEmptyString, isRecord } from "./converters/usage.mjs";
+import { convertAISDKStream, formatToolError, getAISDKRunFinishedDetails, resolveStreamPartMessageId } from "./converters/aisdk.mjs";
+import { convertInputToTanStackAI, convertTanStackStream } from "./converters/tanstack.mjs";
+import { SkillRegistry } from "../runtime/intelligence-platform/skill-registry/registry.mjs";
+import { assertNoSkillToolConflicts, prepareLearnedSkills } from "./learned-skills.mjs";
+import { mergeMCPTools, toToolNamePrefix } from "./mcp-tool-names.mjs";
+import { classifyModelHost, randomUUID, safeParseToolArgs, schemaToJsonSchema } from "@copilotkit/shared";
+import { z } from "zod";
+import { Observable } from "rxjs";
+import { AbstractAgent, EventType, PROTOCOL_VERSION } from "@ag-ui/client";
+import { RENDER_A2UI_TOOL } from "@ag-ui/a2ui-middleware";
+import { Validator } from "@cfworker/json-schema";
+import { jsonSchema, stepCountIs, streamText, tool } from "ai";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createVertex } from "@ai-sdk/google-vertex";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+//#region src/agent/index.ts
+/**
+* Resolves a model specifier to a LanguageModel instance
+* @param spec - Model string (e.g., "openai/gpt-4o") or LanguageModel instance
+* @param apiKey - Optional API key to use instead of environment variables
+* @returns LanguageModel instance
+*/
+/**
+* An AG-UI tool result as the AI SDK's tool result output.
+*
+* Providers hold one response per tool call, and the Google adapter emits one
+* functionResponse per text entry of a content list, so all of a result's text
+* is collected into a single entry: text parts run together, and a
+* URL-referenced part contributes the URL it carries on a line of its own —
+* the bytes are not here to hand over, and the reference is the content the
+* tool actually returned. A result with no inline media is that text alone.
+* One with inline media is a content list: the text entry first, when there is
+* any, then each media part with its bytes and media type. A media-only result
+* is media alone: a placeholder text would be content the tool never returned.
+* Which adapters can place media inside a tool response is theirs to decide.
+* A provider file handle (`file` source) is neither bytes nor a URL, and this
+* path cannot hand it to the provider, so the part is dropped with a warning.
+* A result whose parts were all dropped is the empty string, as AG-UI 1.0
+* requires: the call must still be answered.
+*/
+function warnDroppedFileSource(what) {
+	console.warn(`[CopilotKit] Dropping a ${what} that references a provider file handle: it is not a URL or inline data, so it cannot be sent to the model here.`);
+}
+function toolResultOutput(content) {
+	if (typeof content === "string") return {
+		type: "text",
+		value: content
+	};
+	const segments = [];
+	const media = [];
+	let open = false;
+	for (const part of content) if (part.type === "text") {
+		if (open) segments[segments.length - 1] += part.text;
+		else segments.push(part.text);
+		open = true;
+	} else if (part.source.type === "file") warnDroppedFileSource(`${part.type} part in a tool result`);
+	else if (part.source.type === "url") {
+		segments.push(part.source.value);
+		open = false;
+	} else {
+		media.push({
+			type: "media",
+			data: part.source.value,
+			mediaType: part.source.mimeType
+		});
+		open = false;
+	}
+	const text = segments.join("\n");
+	if (media.length === 0) return {
+		type: "text",
+		value: text
+	};
+	return {
+		type: "content",
+		value: [...text.length > 0 ? [{
+			type: "text",
+			text
+		}] : [], ...media]
+	};
+}
+/**
+* Split a model string into provider and model id. The provider is the text
+* before the FIRST ":" or "/"; everything after it is the model id, unchanged.
+* So "openai:meta-llama/llama-3.3-70b" keeps the slash in its model id, and
+* "openai/ft:gpt-4o-mini:org::id" keeps its colons. Empty strings mean the
+* part is missing.
+*/
+function parseModelSpec(spec) {
+	const trimmed = spec.trim();
+	const separator = trimmed.search(/[:/]/);
+	if (separator === -1) return {
+		provider: trimmed.toLowerCase(),
+		model: ""
+	};
+	return {
+		provider: trimmed.slice(0, separator).toLowerCase(),
+		model: trimmed.slice(separator + 1).trim()
+	};
+}
+/**
+* Whether an `OPENAI_BASE_URL` should get Chat Completions instead of the
+* Responses API. OpenAI's own hosts (including `*.api.openai.com`, such as the
+* EU data-residency host) and Azure serve `/responses`, so they keep it, as
+* does an unset value. Any other host gets `/chat/completions`, which is what
+* most OpenAI-compatible servers implement. The host rule is
+* `classifyModelHost`, the same one telemetry uses.
+*
+* A value `new URL` throws on keeps the Responses route; the request will
+* fail on that base URL either way. A schemeless value such as
+* `localhost:11434/v1` does not throw (it parses with scheme `localhost:` and
+* an empty host), so it classifies as `other` and gets Chat Completions.
+*/
+function usesChatCompletions(baseURL) {
+	const trimmed = baseURL?.trim();
+	if (!trimmed) return false;
+	try {
+		new URL(trimmed);
+	} catch {
+		return false;
+	}
+	const host = classifyModelHost(trimmed, "openai");
+	return host !== "openai" && host !== "azure";
+}
+/** Whether the Chat Completions notice below was already logged. */
+let loggedChatCompletionsRoute = false;
+/**
+* Which OpenAI API an `openai/...` model string targets.
+*
+* `COPILOTKIT_OPENAI_API` (`responses` or `chat`) wins when set, so a proxy in
+* front of OpenAI can keep the Responses API, and an OpenAI host can use Chat
+* Completions. Unset or blank, `usesChatCompletions` decides from
+* `OPENAI_BASE_URL`.
+*
+* When that rule picks Chat Completions, this logs once per process. Through a
+* proxy, Chat Completions drops Responses-only features (such as reasoning
+* summaries) without an error, and the notice names the way back.
+*/
+function openAIApiFor(baseURL) {
+	const raw = process.env.COPILOTKIT_OPENAI_API;
+	const override = raw?.trim().toLowerCase();
+	if (override === "responses" || override === "chat") return override;
+	if (override) throw new Error(`Invalid COPILOTKIT_OPENAI_API "${raw}". Use "responses" or "chat", or leave it unset.`);
+	if (!usesChatCompletions(baseURL)) return "responses";
+	if (!loggedChatCompletionsRoute) {
+		loggedChatCompletionsRoute = true;
+		console.info("[CopilotKit] OPENAI_BASE_URL is not an OpenAI or Azure host, so \"openai/...\" models use the Chat Completions API. To use the Responses API instead, set COPILOTKIT_OPENAI_API=responses.");
+	}
+	return "chat";
+}
+function resolveModel(spec, apiKey) {
+	if (typeof spec !== "string") return spec;
+	const { provider, model } = parseModelSpec(spec);
+	if (!provider) throw new Error(`Invalid model string "${spec}". Use "openai/gpt-5", "anthropic/claude-sonnet-4.5", or "google/gemini-3.8-flash".`);
+	if (!model) throw new Error(`Invalid model string "${spec}". Use "openai/gpt-5", "anthropic/claude-sonnet-4.5", or "google/gemini-3.8-flash".`);
+	switch (provider) {
+		case "openai": {
+			const openai = createOpenAI({
+				apiKey: apiKey || process.env.OPENAI_API_KEY,
+				baseURL: process.env.OPENAI_BASE_URL
+			});
+			return openAIApiFor(process.env.OPENAI_BASE_URL) === "chat" ? openai.chat(model) : openai(model);
+		}
+		case "anthropic": return createAnthropic({
+			apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
+			baseURL: process.env.ANTHROPIC_BASE_URL
+		})(model);
+		case "google":
+		case "gemini":
+		case "google-gemini": return createGoogleGenerativeAI({
+			apiKey: apiKey || process.env.GOOGLE_API_KEY,
+			baseURL: process.env.GOOGLE_GENERATIVE_AI_BASE_URL
+		})(model);
+		case "minimax": return createOpenAI({
+			name: "minimax",
+			apiKey: apiKey || process.env.MINIMAX_API_KEY,
+			baseURL: process.env.MINIMAX_BASE_URL || "https://api.minimax.io/v1"
+		})(model);
+		case "vertex": return createVertex()(model);
+		default: throw new Error(`Unknown provider "${provider}" in "${spec}". Supported: openai, anthropic, google (gemini).`);
+	}
+}
+/**
+* Which vendor a model specifier will actually reach, as a closed vocabulary.
+*
+* `resolveModel` above is the only place this runtime builds a provider, so it
+* is the only place that knows the endpoint. Once built, the endpoint is gone:
+* an AI SDK model's `provider` names only the wire API (`"openai.responses"`
+* on OpenAI and Azure, `"openai.chat"` on any other host), so it cannot tell
+* OpenRouter from a laptop, and its base URL survives
+* only inside a closure that the public `LanguageModelV3` type does not
+* expose. Azure's own migration guide tells customers to use that same OpenAI
+* client, so the case we are blindest to is the common one.
+*
+* A caller who hands us an already-built LanguageModel gets `unknown`. Nobody
+* can recover the host from it, and saying so is more useful than guessing
+* `openai` from a provider label that means only "speaks the OpenAI wire".
+*
+* The branches below mirror `resolveModel`'s switch and must change with it.
+* `model-host-class.test.ts` walks every provider that switch accepts and
+* fails if one lands here as `unknown`.
+*/
+function classifyModelSpec(spec) {
+	if (typeof spec !== "string") return "unknown";
+	const { provider } = parseModelSpec(spec);
+	switch (provider) {
+		case "openai": return classifyModelHost(process.env.OPENAI_BASE_URL, "openai");
+		case "anthropic": return classifyModelHost(process.env.ANTHROPIC_BASE_URL, "anthropic");
+		case "google":
+		case "gemini":
+		case "google-gemini": return classifyModelHost(process.env.GOOGLE_GENERATIVE_AI_BASE_URL, "google");
+		case "minimax": return classifyModelHost(process.env.MINIMAX_BASE_URL || "https://api.minimax.io/v1", "minimax");
+		case "vertex": return "vertex";
+		default: return "unknown";
+	}
+}
+/**
+* Thrown by `AgentFactoryContext.interrupt()` on a fresh (non-resume) run to
+* pause the factory. Caught in `runFactory` and translated into a RUN_FINISHED
+* event carrying `outcome:{type:"interrupt",interrupts}`. Not a real error.
+*/
+var InterruptSignal = class extends Error {
+	constructor(interrupts) {
+		super("CopilotKit interrupt: run paused awaiting human input");
+		this.interrupts = interrupts;
+		this.name = "InterruptSignal";
+	}
+};
+/**
+* Define a tool for use with BuiltInAgent
+* @param name - The name of the tool
+* @param description - Description of what the tool does
+* @param parameters - Schema for the tool's input parameters (any Standard Schema V1 compatible library: Zod, Valibot, ArkType, etc.)
+* @param execute - Function to execute the tool server-side
+* @returns Tool definition
+*/
+function defineTool(config) {
+	return {
+		name: config.name,
+		description: config.description,
+		parameters: config.parameters,
+		execute: config.execute,
+		interrupt: config.interrupt,
+		interruptReason: config.interruptReason,
+		interruptMessage: config.interruptMessage
+	};
+}
+/**
+* Converts AG-UI user message content to Vercel AI SDK UserContent format.
+* Handles plain strings, new modality-specific parts (image/audio/video/document),
+* and legacy BinaryInputContent for backward compatibility.
+*/
+function convertUserMessageContent(content) {
+	if (!content) return "";
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object" || !("type" in part)) continue;
+		switch (part.type) {
+			case "text": {
+				const text = part.text;
+				if (text) parts.push({
+					type: "text",
+					text
+				});
+				break;
+			}
+			case "image": {
+				const source = part.source;
+				if (!source) break;
+				if (source.type === "data") parts.push({
+					type: "image",
+					image: source.value,
+					mediaType: source.mimeType
+				});
+				else if (source.type === "file") warnDroppedFileSource("image part");
+				else if (source.type === "url") try {
+					parts.push({
+						type: "image",
+						image: new URL(source.value),
+						mediaType: source.mimeType
+					});
+				} catch {
+					console.error(`[CopilotKit] convertUserMessageContent: invalid URL "${source.value}" in image part — skipping`);
+				}
+				break;
+			}
+			case "audio":
+			case "video":
+			case "document": {
+				const source = part.source;
+				if (!source) break;
+				if (source.type === "data") parts.push({
+					type: "file",
+					data: source.value,
+					mediaType: source.mimeType
+				});
+				else if (source.type === "file") warnDroppedFileSource(`${part.type} part`);
+				else if (source.type === "url") try {
+					parts.push({
+						type: "file",
+						data: new URL(source.value),
+						mediaType: source.mimeType ?? "application/octet-stream"
+					});
+				} catch {
+					console.error(`[CopilotKit] convertUserMessageContent: invalid URL "${source.value}" in ${part.type} part — skipping`);
+				}
+				break;
+			}
+			case "binary": {
+				const legacy = part;
+				const mimeType = legacy.mimeType ?? "application/octet-stream";
+				const isImage = mimeType.startsWith("image/");
+				if (legacy.data) if (isImage) parts.push({
+					type: "image",
+					image: legacy.data,
+					mediaType: mimeType
+				});
+				else parts.push({
+					type: "file",
+					data: legacy.data,
+					mediaType: mimeType
+				});
+				else if (legacy.url) try {
+					const url = new URL(legacy.url);
+					if (isImage) parts.push({
+						type: "image",
+						image: url,
+						mediaType: mimeType
+					});
+					else parts.push({
+						type: "file",
+						data: url,
+						mediaType: mimeType
+					});
+				} catch {
+					console.error(`[CopilotKit] convertUserMessageContent: invalid URL "${legacy.url}" in binary part — skipping`);
+				}
+				break;
+			}
+			default:
+				console.error(`[CopilotKit] convertUserMessageContent: unrecognized content part type "${part.type}" — skipping`);
+				break;
+		}
+	}
+	return parts.length > 0 ? parts : "";
+}
+/**
+* Converts AG-UI messages to Vercel AI SDK ModelMessage format
+*/
+function convertMessagesToVercelAISDKMessages(messages, options = {}) {
+	const result = [];
+	for (const message of messages) if (message.role === "system" && options.forwardSystemMessages) {
+		const systemMsg = {
+			role: "system",
+			content: message.content ?? ""
+		};
+		result.push(systemMsg);
+	} else if (message.role === "developer" && options.forwardDeveloperMessages) {
+		const systemMsg = {
+			role: "system",
+			content: message.content ?? ""
+		};
+		result.push(systemMsg);
+	} else if (message.role === "assistant") {
+		const parts = message.content ? [{
+			type: "text",
+			text: message.content
+		}] : [];
+		for (const toolCall of message.toolCalls ?? []) {
+			const toolCallPart = {
+				type: "tool-call",
+				toolCallId: toolCall.id,
+				toolName: toolCall.function.name,
+				input: safeParseToolArgs(toolCall.function.arguments)
+			};
+			parts.push(toolCallPart);
+		}
+		const assistantMsg = {
+			role: "assistant",
+			content: parts
+		};
+		result.push(assistantMsg);
+	} else if (message.role === "user") {
+		const userMsg = {
+			role: "user",
+			content: convertUserMessageContent(message.content)
+		};
+		result.push(userMsg);
+	} else if (message.role === "tool") {
+		let toolName = "unknown";
+		for (const msg of messages) if (msg.role === "assistant") {
+			for (const toolCall of msg.toolCalls ?? []) if (toolCall.id === message.toolCallId) {
+				toolName = toolCall.function.name;
+				break;
+			}
+		}
+		const toolMsg = {
+			role: "tool",
+			content: [{
+				type: "tool-result",
+				toolCallId: message.toolCallId,
+				toolName,
+				output: toolResultOutput(message.content)
+			}]
+		};
+		result.push(toolMsg);
+	}
+	return result;
+}
+/**
+* Converts JSON Schema to Zod schema
+*/
+function convertJsonSchemaToZodSchema(jsonSchema, required) {
+	if (jsonSchema.type === "null") {
+		const schema = z.null().describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	}
+	const unionVariants = jsonSchema.anyOf ?? jsonSchema.oneOf;
+	if (Array.isArray(unionVariants) && unionVariants.length > 0) {
+		if (unionVariants.length === 1) return convertJsonSchemaToZodSchema(unionVariants[0], required);
+		const variantSchemas = unionVariants.map((variant) => convertJsonSchemaToZodSchema(variant, true));
+		const schema = z.union(variantSchemas).describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	}
+	if (!jsonSchema.type) return required ? z.object({}) : z.object({}).optional();
+	if (jsonSchema.type === "object") {
+		const spec = {};
+		if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) return !required ? z.object(spec).optional() : z.object(spec);
+		for (const [key, value] of Object.entries(jsonSchema.properties)) spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
+		const schema = z.object(spec).describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	} else if (jsonSchema.type === "string") {
+		if (jsonSchema.enum && jsonSchema.enum.length > 0) {
+			const schema = z.enum(jsonSchema.enum).describe(jsonSchema.description ?? "");
+			return required ? schema : schema.optional();
+		}
+		const schema = z.string().describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	} else if (jsonSchema.type === "number" || jsonSchema.type === "integer") {
+		const schema = z.number().describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	} else if (jsonSchema.type === "boolean") {
+		const schema = z.boolean().describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	} else if (jsonSchema.type === "array") {
+		if (!jsonSchema.items) throw new Error("Array type must have items property");
+		const itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
+		const schema = z.array(itemSchema).describe(jsonSchema.description ?? "");
+		return required ? schema : schema.optional();
+	}
+	console.error("Invalid JSON schema:", JSON.stringify(jsonSchema, null, 2));
+	throw new Error("Invalid JSON schema");
+}
+/**
+* Converts AG-UI tools to Vercel AI SDK ToolSet
+*/
+function isJsonSchema(obj) {
+	if (typeof obj !== "object" || obj === null) return false;
+	const schema = obj;
+	if (Object.keys(schema).length === 0) return true;
+	return typeof schema.type === "string" && [
+		"object",
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"array"
+	].includes(schema.type);
+}
+/**
+* Type-only pass-through for handing a Zod schema to the AI SDK's `tool()`.
+* The raw Zod schema is returned unchanged at runtime — the SDK's `asSchema()`
+* converts and validates it internally exactly as before.
+*
+* The Zod type is erased through `unknown` deliberately: letting tsc relate
+* Zod schema types to the AI SDK's `FlexibleSchema` union (conditional types
+* spanning zod v3/v4) makes type instantiation explode (TS2589 / compiler
+* OOM) under this package's `moduleResolution: node`.
+*/
+function toLanguageModelSchema(schema) {
+	return schema;
+}
+/** Preserve AG-UI tool schemas when passing them to the model provider. */
+function convertToolsToVercelAITools(tools) {
+	const result = {};
+	for (const tool$1 of tools) {
+		if (!isJsonSchema(tool$1.parameters)) throw new Error(`Invalid JSON schema for tool ${tool$1.name}`);
+		const validator = new Validator(tool$1.parameters, "7");
+		result[tool$1.name] = tool({
+			description: tool$1.description,
+			inputSchema: jsonSchema(tool$1.parameters, { validate: (value) => {
+				return validator.validate(value).valid ? {
+					success: true,
+					value
+				} : {
+					success: false,
+					error: /* @__PURE__ */ new Error(`Invalid arguments for tool ${tool$1.name}`)
+				};
+			} }),
+			...tool$1.name === RENDER_A2UI_TOOL.name ? { strict: false } : {}
+		});
+	}
+	return result;
+}
+/**
+* Check whether a schema is a Zod schema by inspecting its Standard Schema vendor.
+*/
+function isZodSchema(schema) {
+	return schema["~standard"]?.vendor === "zod";
+}
+/**
+* Converts ToolDefinition array to Vercel AI SDK ToolSet.
+*
+* For Zod schemas, passes them directly to the AI SDK (Zod satisfies FlexibleSchema).
+* For non-Zod schemas, converts to JSON Schema via schemaToJsonSchema() and wraps
+* with the AI SDK's jsonSchema() helper.
+*/
+function convertToolDefinitionsToVercelAITools(tools) {
+	const result = {};
+	for (const tool$2 of tools) if (isZodSchema(tool$2.parameters)) result[tool$2.name] = tool({
+		description: tool$2.description,
+		inputSchema: tool$2.parameters,
+		execute: tool$2.execute
+	});
+	else {
+		const jsonSchemaObj = schemaToJsonSchema(tool$2.parameters);
+		result[tool$2.name] = tool({
+			description: tool$2.description,
+			inputSchema: jsonSchema(jsonSchemaObj),
+			execute: tool$2.execute
+		});
+	}
+	return result;
+}
+/**
+* Type guard: returns true if this is a factory-mode config.
+*/
+function isFactoryConfig(config) {
+	return "factory" in config;
+}
+var BuiltInAgent = class BuiltInAgent extends AbstractAgent {
+	constructor(config) {
+		super();
+		this.config = config;
+		if (!isFactoryConfig(config)) this.urlDownload = resolveUrlDownloadSetting(config.urlDownload);
+		else if ("urlDownload" in config) throw new Error("BuiltInAgent: urlDownload has no effect in factory mode. Pass experimental_download: createSafeUrlDownload({ signal: ctx.abortSignal }) (from @copilotkit/runtime) to your own streamText() call instead.");
+		this.skillRegistry = config.learnedSkills === void 0 ? void 0 : new SkillRegistry(config.learnedSkills);
+		this.modelHostClass = isFactoryConfig(config) ? "unknown" : classifyModelSpec(config.model);
+	}
+	/**
+	* Check if a property can be overridden by forwardedProps
+	*/
+	canOverride(property) {
+		if (isFactoryConfig(this.config)) return false;
+		return this.config?.overridableProperties?.includes(property) ?? false;
+	}
+	async getCapabilities() {
+		const inferred = {
+			tools: {
+				supported: true,
+				clientProvided: true
+			},
+			transport: { streaming: true },
+			humanInTheLoop: { interrupts: true }
+		};
+		const capabilities = isFactoryConfig(this.config) ? void 0 : this.config.capabilities;
+		if (!capabilities) return inferred;
+		return {
+			...inferred,
+			...capabilities
+		};
+	}
+	run(input) {
+		if (isFactoryConfig(this.config)) return this.runFactory(input, this.config);
+		const config = this.config;
+		if (this.abortController) throw new Error("Agent is already running. Call abortRun() first or create a new instance.");
+		this.abortController = new AbortController();
+		const abortController = this.abortController;
+		return new Observable((subscriber) => {
+			const startEvent = {
+				type: EventType.RUN_STARTED,
+				threadId: input.threadId,
+				runId: input.runId,
+				protocolVersion: PROTOCOL_VERSION
+			};
+			subscriber.next(startEvent);
+			const model = resolveModel(config.model, config.apiKey);
+			let systemPrompt = void 0;
+			const hasPrompt = !!config.prompt;
+			const hasContext = input.context && input.context.length > 0;
+			const hasState = input.state !== void 0 && input.state !== null && !(typeof input.state === "object" && Object.keys(input.state).length === 0);
+			if (hasPrompt || hasContext || hasState) {
+				const parts = [];
+				if (hasPrompt) parts.push(config.prompt);
+				if (hasContext) {
+					parts.push("\n## Context from the application\n");
+					for (const ctx of input.context) parts.push(`${ctx.description}:\n${ctx.value}\n`);
+				}
+				if (hasState) parts.push(`
+## Application State
+This is state from the application that you can edit by calling AGUISendStateSnapshot or AGUISendStateDelta.
+\`\`\`json\n${JSON.stringify(input.state, null, 2)}\n\`\`\`\n`);
+				systemPrompt = parts.join("");
+			}
+			const systemMessages = [];
+			if (systemPrompt) systemMessages.push({
+				role: "system",
+				content: systemPrompt
+			});
+			const messages = convertMessagesToVercelAISDKMessages(input.messages, {
+				forwardSystemMessages: config.forwardSystemMessages,
+				forwardDeveloperMessages: config.forwardDeveloperMessages
+			});
+			const resumeEntries = input.resume ?? [];
+			if (resumeEntries.length > 0) {
+				const toolNameById = /* @__PURE__ */ new Map();
+				for (const m of input.messages) {
+					if (m.role !== "assistant") continue;
+					for (const tc of m.toolCalls ?? []) if (tc.id && tc.function?.name) toolNameById.set(tc.id, tc.function.name);
+				}
+				const alreadyAnswered = /* @__PURE__ */ new Set();
+				for (const m of messages) {
+					if (m.role !== "tool" || !Array.isArray(m.content)) continue;
+					for (const part of m.content) if (part && typeof part === "object" && "toolCallId" in part) alreadyAnswered.add(part.toolCallId);
+				}
+				for (const entry of resumeEntries) {
+					if (alreadyAnswered.has(entry.interruptId)) continue;
+					const value = entry.status === "cancelled" ? { status: "cancelled" } : entry.payload ?? { status: "resolved" };
+					const toolResultMessage = {
+						role: "tool",
+						content: [{
+							type: "tool-result",
+							toolCallId: entry.interruptId,
+							toolName: toolNameById.get(entry.interruptId) ?? "",
+							output: {
+								type: "json",
+								value
+							}
+						}]
+					};
+					messages.push(toolResultMessage);
+				}
+			}
+			let allTools = convertToolsToVercelAITools(input.tools);
+			if (config.tools && config.tools.length > 0) {
+				const configTools = convertToolDefinitionsToVercelAITools(config.tools);
+				allTools = {
+					...allTools,
+					...configTools
+				};
+			}
+			const streamTextParams = {
+				model,
+				messages,
+				tools: allTools,
+				toolChoice: config.toolChoice,
+				stopWhen: config.maxSteps ? stepCountIs(config.maxSteps) : void 0,
+				maxOutputTokens: config.maxOutputTokens,
+				temperature: config.temperature,
+				topP: config.topP,
+				topK: config.topK,
+				presencePenalty: config.presencePenalty,
+				frequencyPenalty: config.frequencyPenalty,
+				stopSequences: config.stopSequences,
+				seed: config.seed,
+				providerOptions: config.providerOptions,
+				maxRetries: config.maxRetries,
+				experimental_download: this.urlDownload?.(abortController.signal)
+			};
+			if (input.forwardedProps && typeof input.forwardedProps === "object") {
+				const props = input.forwardedProps;
+				if (props.model !== void 0 && this.canOverride("model")) {
+					if (typeof props.model === "string" || typeof props.model === "object") streamTextParams.model = resolveModel(props.model, config.apiKey);
+				}
+				if (props.toolChoice !== void 0 && this.canOverride("toolChoice")) {
+					const toolChoice = props.toolChoice;
+					if (toolChoice === "auto" || toolChoice === "required" || toolChoice === "none" || typeof toolChoice === "object" && toolChoice !== null && "type" in toolChoice && toolChoice.type === "tool") streamTextParams.toolChoice = toolChoice;
+				}
+				if (typeof props.maxOutputTokens === "number" && this.canOverride("maxOutputTokens")) streamTextParams.maxOutputTokens = props.maxOutputTokens;
+				if (typeof props.temperature === "number" && this.canOverride("temperature")) streamTextParams.temperature = props.temperature;
+				if (typeof props.topP === "number" && this.canOverride("topP")) streamTextParams.topP = props.topP;
+				if (typeof props.topK === "number" && this.canOverride("topK")) streamTextParams.topK = props.topK;
+				if (typeof props.presencePenalty === "number" && this.canOverride("presencePenalty")) streamTextParams.presencePenalty = props.presencePenalty;
+				if (typeof props.frequencyPenalty === "number" && this.canOverride("frequencyPenalty")) streamTextParams.frequencyPenalty = props.frequencyPenalty;
+				if (Array.isArray(props.stopSequences) && this.canOverride("stopSequences")) {
+					if (props.stopSequences.every((item) => typeof item === "string")) streamTextParams.stopSequences = props.stopSequences;
+				}
+				if (typeof props.seed === "number" && this.canOverride("seed")) streamTextParams.seed = props.seed;
+				if (typeof props.maxRetries === "number" && this.canOverride("maxRetries")) streamTextParams.maxRetries = props.maxRetries;
+				if (props.providerOptions !== void 0 && this.canOverride("providerOptions")) {
+					if (typeof props.providerOptions === "object" && props.providerOptions !== null) streamTextParams.providerOptions = props.providerOptions;
+				}
+			}
+			const mcpClients = [];
+			(async () => {
+				let terminalEventEmitted = false;
+				let messageId = randomUUID();
+				let reasoningMessageId = randomUUID();
+				let isInReasoning = false;
+				const closeReasoningIfOpen = () => {
+					if (!isInReasoning) return;
+					isInReasoning = false;
+					const reasoningMsgEnd = {
+						type: EventType.REASONING_MESSAGE_END,
+						messageId: reasoningMessageId
+					};
+					subscriber.next(reasoningMsgEnd);
+					const reasoningEnd = {
+						type: EventType.REASONING_END,
+						messageId: reasoningMessageId
+					};
+					subscriber.next(reasoningEnd);
+				};
+				try {
+					const learnedSkills = await prepareLearnedSkills(this.skillRegistry, abortController.signal);
+					abortController.signal.throwIfAborted();
+					if (learnedSkills.catalog) {
+						systemMessages.unshift({
+							role: "system",
+							content: learnedSkills.catalog
+						});
+						if (config.maxSteps === void 0) streamTextParams.stopWhen = stepCountIs(10);
+					}
+					streamTextParams.tools = {
+						...streamTextParams.tools,
+						AGUISendStateSnapshot: tool({
+							description: "Replace the entire application state with a new snapshot",
+							inputSchema: toLanguageModelSchema(z.object({ snapshot: z.any().describe("The complete new state object") })),
+							execute: async ({ snapshot }) => {
+								return {
+									success: true,
+									snapshot
+								};
+							}
+						}),
+						AGUISendStateDelta: tool({
+							description: "Apply incremental updates to application state using JSON Patch operations",
+							inputSchema: toLanguageModelSchema(z.object({ delta: z.array(z.object({
+								op: z.enum([
+									"add",
+									"replace",
+									"remove"
+								]).describe("The operation to perform"),
+								path: z.string().describe("JSON Pointer path (e.g., '/foo/bar')"),
+								value: z.any().optional().describe("The value to set. Required for 'add' and 'replace' operations, ignored for 'remove'.")
+							})).describe("Array of JSON Patch operations") })),
+							execute: async ({ delta }) => {
+								return {
+									success: true,
+									delta
+								};
+							}
+						})
+					};
+					const mcpToolSources = [];
+					const userMcpClients = config.mcpClients ?? [];
+					for (const [index, client] of userMcpClients.entries()) {
+						const mcpTools = await client.tools();
+						abortController.signal.throwIfAborted();
+						mcpToolSources.push({
+							label: `mcp${index + 1}`,
+							tools: mcpTools
+						});
+					}
+					const allMcpServers = [...config.mcpServers ?? []];
+					if (allMcpServers.length > 0) for (const [index, serverConfig] of allMcpServers.entries()) {
+						const label = serverConfig.name ? toToolNamePrefix(serverConfig.name) : `mcp${userMcpClients.length + index + 1}`;
+						let transport;
+						if (serverConfig.type === "http") transport = new StreamableHTTPClientTransport(new URL(serverConfig.url), serverConfig.options);
+						else if (serverConfig.type === "sse") {
+							const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+							abortController.signal.throwIfAborted();
+							transport = new SSEClientTransport(new URL(serverConfig.url), serverConfig.headers ? { requestInit: { headers: serverConfig.headers } } : void 0);
+						}
+						if (transport) {
+							let mcpClient;
+							try {
+								mcpClient = await createMCPClient({ transport });
+							} catch (err) {
+								abortController.signal.throwIfAborted();
+								console.error(`[CopilotKit] MCP server ${describeEndpoint(serverConfig.url)} failed to connect — skipping it for this run:`, err);
+								continue;
+							}
+							if (abortController.signal.aborted) {
+								await mcpClient.close();
+								abortController.signal.throwIfAborted();
+							}
+							mcpClients.push(mcpClient);
+							try {
+								const mcpTools = await mcpClient.tools();
+								abortController.signal.throwIfAborted();
+								mcpToolSources.push({
+									label,
+									tools: mcpTools
+								});
+							} catch (err) {
+								abortController.signal.throwIfAborted();
+								console.error(`[CopilotKit] MCP server ${describeEndpoint(serverConfig.url)} tools() failed — skipping its tools for this run:`, err);
+							}
+						}
+					}
+					if (mcpToolSources.length > 0) streamTextParams.tools = mergeMCPTools(streamTextParams.tools ?? {}, mcpToolSources);
+					if (this.skillRegistry) {
+						assertNoSkillToolConflicts(streamTextParams.tools ?? {});
+						streamTextParams.tools = {
+							...streamTextParams.tools,
+							...learnedSkills.tools
+						};
+					}
+					abortController.signal.throwIfAborted();
+					const response = streamText({
+						...streamTextParams,
+						...messages.length > 0 ? { system: systemMessages.length > 0 ? systemMessages : void 0 } : { messages: systemMessages },
+						abortSignal: abortController.signal,
+						onError: ({ error }) => logModelCallError(error)
+					});
+					const interruptToolNames = new Set((isFactoryConfig(this.config) ? [] : this.config.tools ?? []).filter((t) => t.interrupt).map((t) => t.name));
+					const interruptToolMeta = new Map((isFactoryConfig(this.config) ? [] : this.config.tools ?? []).filter((t) => t.interrupt).map((t) => [t.name, {
+						reason: t.interruptReason ?? "tool_call",
+						message: t.interruptMessage
+					}]));
+					const pendingInterrupts = [];
+					const normalizeStateEvent = createStateEventNormalizer(input.state);
+					const toolCallStates = /* @__PURE__ */ new Map();
+					const ensureToolCallState = (toolCallId) => {
+						let state = toolCallStates.get(toolCallId);
+						if (!state) {
+							state = {
+								started: false,
+								hasArgsDelta: false,
+								ended: false
+							};
+							toolCallStates.set(toolCallId, state);
+						}
+						return state;
+					};
+					const warnedUnknownPartTypes = /* @__PURE__ */ new Set();
+					for await (const part of response.fullStream) {
+						if (part.type !== "reasoning-delta") closeReasoningIfOpen();
+						switch (part.type) {
+							case "abort": {
+								const abortEndEvent = {
+									type: EventType.RUN_FINISHED,
+									threadId: input.threadId,
+									runId: input.runId,
+									...input.protocolVersion !== void 0 ? { outcome: { type: "cancelled" } } : {}
+								};
+								subscriber.next(abortEndEvent);
+								terminalEventEmitted = true;
+								subscriber.complete();
+								break;
+							}
+							case "reasoning-start": {
+								reasoningMessageId = resolveStreamPartMessageId("id" in part ? part.id : void 0);
+								const reasoningStartEvent = {
+									type: EventType.REASONING_START,
+									messageId: reasoningMessageId
+								};
+								subscriber.next(reasoningStartEvent);
+								const reasoningMessageStart = {
+									type: EventType.REASONING_MESSAGE_START,
+									messageId: reasoningMessageId,
+									role: "reasoning"
+								};
+								subscriber.next(reasoningMessageStart);
+								isInReasoning = true;
+								break;
+							}
+							case "reasoning-delta": {
+								const delta = part.text ?? "";
+								if (!delta) break;
+								const reasoningDeltaEvent = {
+									type: EventType.REASONING_MESSAGE_CONTENT,
+									messageId: reasoningMessageId,
+									delta
+								};
+								subscriber.next(reasoningDeltaEvent);
+								break;
+							}
+							case "reasoning-end": break;
+							case "tool-input-start": {
+								const toolCallId = part.id;
+								const state = ensureToolCallState(toolCallId);
+								state.toolName = part.toolName;
+								if (!state.started) {
+									state.started = true;
+									const startEvent = {
+										type: EventType.TOOL_CALL_START,
+										parentMessageId: messageId,
+										toolCallId,
+										toolCallName: part.toolName
+									};
+									subscriber.next(startEvent);
+								}
+								break;
+							}
+							case "tool-input-delta": {
+								const toolCallId = part.id;
+								const state = ensureToolCallState(toolCallId);
+								state.hasArgsDelta = true;
+								const argsEvent = {
+									type: EventType.TOOL_CALL_ARGS,
+									toolCallId,
+									delta: part.delta
+								};
+								subscriber.next(argsEvent);
+								break;
+							}
+							case "tool-input-end": break;
+							case "text-start":
+								messageId = resolveStreamPartMessageId("id" in part ? part.id : void 0);
+								break;
+							case "text-delta": {
+								const textDelta = "text" in part ? part.text : "";
+								const textEvent = {
+									type: EventType.TEXT_MESSAGE_CHUNK,
+									role: "assistant",
+									messageId,
+									delta: textDelta
+								};
+								subscriber.next(textEvent);
+								break;
+							}
+							case "tool-call": {
+								const toolCallId = part.toolCallId;
+								const state = ensureToolCallState(toolCallId);
+								state.toolName = part.toolName ?? state.toolName;
+								if (!state.started) {
+									state.started = true;
+									const startEvent = {
+										type: EventType.TOOL_CALL_START,
+										parentMessageId: messageId,
+										toolCallId,
+										toolCallName: part.toolName
+									};
+									subscriber.next(startEvent);
+								}
+								if (!state.hasArgsDelta && "input" in part && part.input !== void 0) {
+									let serializedInput = "";
+									if (typeof part.input === "string") serializedInput = part.input;
+									else try {
+										serializedInput = JSON.stringify(part.input);
+									} catch {
+										serializedInput = String(part.input);
+									}
+									if (serializedInput.length > 0) {
+										const argsEvent = {
+											type: EventType.TOOL_CALL_ARGS,
+											toolCallId,
+											delta: serializedInput
+										};
+										subscriber.next(argsEvent);
+										state.hasArgsDelta = true;
+									}
+								}
+								if (!state.ended) {
+									state.ended = true;
+									const endEvent = {
+										type: EventType.TOOL_CALL_END,
+										toolCallId
+									};
+									subscriber.next(endEvent);
+								}
+								if (state.toolName && interruptToolNames.has(state.toolName)) {
+									const meta = interruptToolMeta.get(state.toolName);
+									pendingInterrupts.push({
+										id: toolCallId,
+										toolCallId,
+										reason: meta?.reason ?? "tool_call",
+										...meta?.message ? { message: meta.message } : {}
+									});
+								}
+								break;
+							}
+							case "tool-result": {
+								const toolName = "toolName" in part && part.toolName || toolCallStates.get(part.toolCallId)?.toolName || "";
+								if (toolName && interruptToolNames.has(toolName)) {
+									toolCallStates.delete(part.toolCallId);
+									break;
+								}
+								const legacyPart = part;
+								const toolResult = "output" in part ? part.output : "result" in legacyPart ? legacyPart.result : null;
+								toolCallStates.delete(part.toolCallId);
+								if (toolName === "AGUISendStateSnapshot" && toolResult && typeof toolResult === "object") {
+									const snapshot = toolResult.snapshot;
+									if (snapshot !== void 0) {
+										const stateSnapshotEvent = {
+											type: EventType.STATE_SNAPSHOT,
+											snapshot
+										};
+										for (const event of normalizeStateEvent(stateSnapshotEvent)) subscriber.next(event);
+									}
+								} else if (toolName === "AGUISendStateDelta" && toolResult && typeof toolResult === "object") {
+									const delta = toolResult.delta;
+									if (delta !== void 0) {
+										const stateDeltaEvent = {
+											type: EventType.STATE_DELTA,
+											delta
+										};
+										for (const event of normalizeStateEvent(stateDeltaEvent)) subscriber.next(event);
+									}
+								}
+								let serializedResult;
+								try {
+									serializedResult = JSON.stringify(toolResult);
+								} catch {
+									serializedResult = `[Unserializable tool result from ${toolName || part.toolCallId}]`;
+								}
+								const resultEvent = {
+									type: EventType.TOOL_CALL_RESULT,
+									role: "tool",
+									messageId: randomUUID(),
+									toolCallId: part.toolCallId,
+									content: serializedResult
+								};
+								subscriber.next(resultEvent);
+								break;
+							}
+							case "tool-error": {
+								const toolCallId = part.toolCallId;
+								const toolName = "toolName" in part && part.toolName || toolCallStates.get(toolCallId)?.toolName || "";
+								if (toolName && interruptToolNames.has(toolName)) {
+									toolCallStates.delete(toolCallId);
+									break;
+								}
+								toolCallStates.delete(toolCallId);
+								const resultEvent = {
+									type: EventType.TOOL_CALL_RESULT,
+									role: "tool",
+									messageId: randomUUID(),
+									toolCallId,
+									content: `Error: ${formatToolError(part.error)}`
+								};
+								subscriber.next(resultEvent);
+								break;
+							}
+							case "finish": {
+								const model = streamTextParams.model;
+								const finishedEvent = {
+									type: EventType.RUN_FINISHED,
+									threadId: input.threadId,
+									runId: input.runId,
+									...getAISDKRunFinishedDetails(part, {
+										provider: isRecord(model) ? getNonEmptyString(model.provider) : void 0,
+										model: isRecord(model) ? getNonEmptyString(model.modelId) : void 0
+									}),
+									...pendingInterrupts.length > 0 ? { outcome: {
+										type: "interrupt",
+										interrupts: pendingInterrupts
+									} } : {}
+								};
+								subscriber.next(finishedEvent);
+								terminalEventEmitted = true;
+								subscriber.complete();
+								break;
+							}
+							case "error": {
+								if (abortController.signal.aborted) break;
+								const err = part.error ?? ("message" in part ? part.message : void 0) ?? ("cause" in part ? part.cause : void 0);
+								const runErrorEvent = {
+									type: EventType.RUN_ERROR,
+									message: err instanceof Error ? err.message : typeof err === "string" ? err : `AI SDK stream error: ${JSON.stringify(part)}`,
+									threadId: input.threadId,
+									runId: input.runId
+								};
+								subscriber.next(runErrorEvent);
+								terminalEventEmitted = true;
+								if (err instanceof Error) subscriber.error(err);
+								else subscriber.error(new Error(typeof err === "string" ? err : `AI SDK stream error`));
+								break;
+							}
+							case "start":
+							case "start-step":
+							case "finish-step":
+							case "text-end":
+							case "source":
+							case "file":
+							case "tool-output-denied":
+							case "tool-approval-request":
+							case "raw": break;
+							default: {
+								const _exhaustive = part;
+								const unknownType = String(_exhaustive.type);
+								if (!warnedUnknownPartTypes.has(unknownType)) {
+									warnedUnknownPartTypes.add(unknownType);
+									console.warn(`[BuiltInAgent] Ignoring unhandled AI SDK stream part: ${unknownType}`);
+								}
+								break;
+							}
+						}
+					}
+					if (!terminalEventEmitted) {
+						closeReasoningIfOpen();
+						if (abortController.signal.aborted) {} else {
+							const finishedEvent = {
+								type: EventType.RUN_FINISHED,
+								threadId: input.threadId,
+								runId: input.runId,
+								...pendingInterrupts.length > 0 ? { outcome: {
+									type: "interrupt",
+									interrupts: pendingInterrupts
+								} } : {}
+							};
+							subscriber.next(finishedEvent);
+						}
+						terminalEventEmitted = true;
+						subscriber.complete();
+					}
+				} catch (error) {
+					closeReasoningIfOpen();
+					if (abortController.signal.aborted) subscriber.complete();
+					else {
+						const runErrorEvent = {
+							type: EventType.RUN_ERROR,
+							message: error instanceof Error ? error.message : String(error),
+							threadId: input.threadId,
+							runId: input.runId
+						};
+						subscriber.next(runErrorEvent);
+						terminalEventEmitted = true;
+						subscriber.error(error);
+					}
+				} finally {
+					if (this.abortController === abortController) this.abortController = void 0;
+					await Promise.all(mcpClients.map((client) => client.close()));
+				}
+			})();
+			return () => {
+				abortController.abort();
+				if (this.abortController === abortController) this.abortController = void 0;
+				Promise.all(mcpClients.map((client) => client.close())).catch(() => {});
+			};
+		});
+	}
+	runFactory(input, config) {
+		if (this.abortController) throw new Error("Agent is already running. Call abortRun() first or create a new instance.");
+		this.abortController = new AbortController();
+		const controller = this.abortController;
+		return new Observable((subscriber) => {
+			const startEvent = {
+				type: EventType.RUN_STARTED,
+				threadId: input.threadId,
+				runId: input.runId,
+				protocolVersion: PROTOCOL_VERSION
+			};
+			subscriber.next(startEvent);
+			const ctx = {
+				input,
+				abortController: controller,
+				abortSignal: controller.signal,
+				interrupt: async (interrupts) => {
+					const resume = input.resume ?? [];
+					const ids = new Set(interrupts.map((i) => i.id));
+					const matching = resume.filter((r) => ids.has(r.interruptId));
+					if (interrupts.length > 0 && matching.length === interrupts.length) return matching;
+					throw new InterruptSignal(interrupts);
+				}
+			};
+			(async () => {
+				const runFinishedDetails = {};
+				try {
+					const toolCallIds = new Set(input.messages.flatMap((message) => message.role === "assistant" ? (message.toolCalls ?? []).map((call) => call.id) : []));
+					const answeredToolMessages = input.messages.filter((message) => message.role === "tool");
+					const answeredToolCallIds = new Set(answeredToolMessages.map((message) => message.toolCallId));
+					const nativeResume = config.type === "custom" ? [] : input.resume ?? [];
+					const resumeToolMessages = [];
+					const decisionsByCall = /* @__PURE__ */ new Map();
+					for (const entry of nativeResume) {
+						if (!toolCallIds.has(entry.interruptId)) continue;
+						const content = JSON.stringify(entry.status === "cancelled" ? { status: "cancelled" } : entry.payload ?? { status: "resolved" });
+						if (decisionsByCall.has(entry.interruptId)) {
+							if (decisionsByCall.get(entry.interruptId) !== content) throw new Error(`Conflicting decisions for resumed tool call ${entry.interruptId}`);
+							continue;
+						}
+						decisionsByCall.set(entry.interruptId, content);
+						if (answeredToolCallIds.has(entry.interruptId)) continue;
+						resumeToolMessages.push({
+							id: randomUUID(),
+							role: "tool",
+							toolCallId: entry.interruptId,
+							content
+						});
+					}
+					const resumedIds = new Set(nativeResume.map((entry) => entry.interruptId));
+					const resumedResults = new Map([...answeredToolMessages, ...resumeToolMessages].filter((message) => resumedIds.has(message.toolCallId)).map((message) => [message.toolCallId, message.content]));
+					for (const message of resumeToolMessages) {
+						const event = {
+							type: EventType.TOOL_CALL_RESULT,
+							messageId: message.id,
+							toolCallId: message.toolCallId,
+							role: "tool",
+							content: message.content
+						};
+						subscriber.next(event);
+					}
+					const factoryInput = resumeToolMessages.length > 0 && config.type !== "custom" ? {
+						...input,
+						messages: [...input.messages, ...resumeToolMessages]
+					} : input;
+					const learnedSkills = await prepareLearnedSkills(this.skillRegistry, controller.signal);
+					controller.signal.throwIfAborted();
+					const factoryCtx = {
+						...ctx,
+						input: factoryInput,
+						learnedSkills
+					};
+					let events;
+					let customRunFinishedEvent;
+					const pendingInterrupts = [];
+					switch (config.type) {
+						case "aisdk":
+							events = convertAISDKStream((await config.factory(factoryCtx)).fullStream, controller.signal, pendingInterrupts, input.state, runFinishedDetails);
+							break;
+						case "tanstack":
+							events = convertTanStackStream(await config.factory(factoryCtx), controller.signal, pendingInterrupts, input.state, runFinishedDetails);
+							break;
+						case "custom":
+							events = await config.factory(factoryCtx);
+							break;
+						default: {
+							const _exhaustive = config;
+							throw new Error(`Unknown agent config type: ${_exhaustive.type}`);
+						}
+					}
+					for await (const event of events) {
+						if (event.type === EventType.TOOL_CALL_RESULT && "toolCallId" in event && typeof event.toolCallId === "string" && "content" in event && resumedResults.has(event.toolCallId)) {
+							if (resumedResults.get(event.toolCallId) !== event.content) throw new Error(`Conflicting result for resumed tool call ${event.toolCallId}`);
+							continue;
+						}
+						if (config.type === "custom" && event.type === EventType.RUN_FINISHED) {
+							customRunFinishedEvent = event;
+							collectStandardRunFinishedDetails(event, runFinishedDetails);
+							continue;
+						}
+						subscriber.next(event);
+					}
+					if (pendingInterrupts.length > 0 && !controller.signal.aborted) throw new InterruptSignal(pendingInterrupts);
+					if (!controller.signal.aborted) {
+						const finishedEvent = {
+							...customRunFinishedEvent,
+							type: EventType.RUN_FINISHED,
+							threadId: input.threadId,
+							runId: input.runId,
+							...runFinishedDetails
+						};
+						subscriber.next(finishedEvent);
+					}
+					subscriber.complete();
+				} catch (error) {
+					if (error instanceof InterruptSignal) {
+						const finishedEvent = {
+							type: EventType.RUN_FINISHED,
+							threadId: input.threadId,
+							runId: input.runId,
+							...runFinishedDetails,
+							outcome: {
+								type: "interrupt",
+								interrupts: error.interrupts
+							}
+						};
+						subscriber.next(finishedEvent);
+						subscriber.complete();
+					} else if (controller.signal.aborted) subscriber.complete();
+					else {
+						const runErrorEvent = {
+							type: EventType.RUN_ERROR,
+							message: error instanceof Error ? error.message : String(error),
+							threadId: input.threadId,
+							runId: input.runId
+						};
+						subscriber.next(runErrorEvent);
+						subscriber.error(error);
+					}
+				} finally {
+					if (this.abortController === controller) this.abortController = void 0;
+				}
+			})();
+			return () => {
+				controller.abort();
+				if (this.abortController === controller) this.abortController = void 0;
+			};
+		});
+	}
+	clone() {
+		const cloned = new BuiltInAgent({
+			...this.config,
+			learnedSkills: void 0
+		});
+		cloned.config = this.config;
+		cloned.skillRegistry = this.skillRegistry;
+		cloned.middlewares = [...this.middlewares];
+		return cloned;
+	}
+	abortRun() {
+		this.abortController?.abort();
+	}
+};
+/**
+* @deprecated Use BuiltInAgent instead
+*/
+var BasicAgent = class extends BuiltInAgent {
+	constructor(config) {
+		super(config);
+		console.warn("BasicAgent is deprecated, use BuiltInAgent instead");
+	}
+};
+
+//#endregion
+export { BasicAgent, BuiltInAgent, InterruptSignal, classifyModelSpec, convertJsonSchemaToZodSchema, convertMessagesToVercelAISDKMessages, convertToolDefinitionsToVercelAITools, convertToolsToVercelAITools, defineTool, resolveModel };
+//# sourceMappingURL=index.mjs.map