@copilotkit/runtime 1.77.2 → 1.79.0

package/README.md

@@ -192,3 +192,19 @@ See [Skill delivery](https://docs.copilotkit.ai/intelligence/learned-skills) for
 Explicit `containers` accepts 1–50 unique container IDs and sends one batch request for all sources that need a refresh. This also applies to a list with one entry.
 The server must support `POST /api/v1/learning/skills/batch` before you use this configuration. The SDK does not fall back to separate requests.
 Legacy `containerId` configuration keeps its existing single-container request. Both interfaces use the same authentication configuration.
+
+## Intelligence runner reconnects
+
+`IntelligenceAgentRunner` retains unacknowledged events and retries them with the
+same IDs after reconnect. An unexpected normal WebSocket close (`1000`) also
+reconnects while the run remains active. Intentional cleanup does not reconnect.
+
+Recovery also depends on the Intelligence gateway's reconnect grace period.
+The current gateway defaults to 15 seconds and stores pending disconnects in
+Redis so another gateway replica can finish cleanup. The gateway controls this
+period; the runner does not negotiate it. A gateway with no reconnect grace can
+record `RUNNER_CONNECTION_DROPPED` before the runner reconnects.
+
+This recovers a lost WebSocket while the agent runtime remains alive. It does
+not restart an agent after its runtime process exits. The existing 60-second
+event acknowledgment deadline still applies.

package/dist/agent/index.cjs

@@ -86,20 +86,88 @@ function toolResultOutput(content) {
 		}] : [], ...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 = (0, _copilotkit_shared.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 parts = spec.replace("/", ":").trim().split(":");
-	const rawProvider = parts[0];
-	const rest = parts.slice(1);
-	if (!rawProvider) throw new Error(`Invalid model string "${spec}". Use "openai/gpt-5", "anthropic/claude-sonnet-4.5", or "google/gemini-2.5-pro".`);
-	const provider = rawProvider.toLowerCase();
-	const model = rest.join(":").trim();
-	if (!model) throw new Error(`Invalid model string "${spec}". Use "openai/gpt-5", "anthropic/claude-sonnet-4.5", or "google/gemini-2.5-pro".`);
+	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": return (0, _ai_sdk_openai.createOpenAI)({
-			apiKey: apiKey || process.env.OPENAI_API_KEY,
-			baseURL: process.env.OPENAI_BASE_URL
-		})(model);
+		case "openai": {
+			const openai = (0, _ai_sdk_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 (0, _ai_sdk_anthropic.createAnthropic)({
 			apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
 			baseURL: process.env.ANTHROPIC_BASE_URL
@@ -124,8 +192,9 @@ function resolveModel(spec, apiKey) {
 *
 * `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 reports `provider: "openai.responses"` whether it points at
-* api.openai.com, Azure, OpenRouter or a laptop, and its base URL survives
+* 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.
@@ -140,7 +209,8 @@ function resolveModel(spec, apiKey) {
 */
 function classifyModelSpec(spec) {
 	if (typeof spec !== "string") return "unknown";
-	switch (spec.replace("/", ":").trim().split(":")[0]?.toLowerCase()) {
+	const { provider } = parseModelSpec(spec);
+	switch (provider) {
 		case "openai": return (0, _copilotkit_shared.classifyModelHost)(process.env.OPENAI_BASE_URL, "openai");
 		case "anthropic": return (0, _copilotkit_shared.classifyModelHost)(process.env.ANTHROPIC_BASE_URL, "anthropic");
 		case "google":