@copilotkit/core 1.71.2 → 1.72.1-canary.sp-longthread-perf

package/dist/index.mjs

@@ -647,6 +647,13 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	credentials;
 	runtimeAgentId;
 	transport;
+	/**
+	* The runtime URL exactly as the caller supplied it. `runtimeUrl` is the
+	* slash-stripped form used for path joins; the single-route endpoint (run,
+	* connect, stop, info envelopes) is this verbatim value, because a trailing
+	* slash can select a different proxy location.
+	*/
+	runtimeEndpointUrl;
 	singleEndpointUrl;
 	runtimeMode;
 	intelligence;
@@ -657,13 +664,14 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
 		const transport = config.transport ?? "auto";
 		const routedId = config.runtimeAgentId ?? config.agentId ?? "";
-		const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(routedId)}/run`;
+		const runUrl = transport === "single" ? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(routedId)}/run`;
 		if (!runUrl) throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
 		super({
 			...config,
 			url: runUrl
 		});
 		this.runtimeUrl = normalizedRuntimeUrl ?? config.runtimeUrl;
+		this.runtimeEndpointUrl = config.runtimeUrl;
 		this.credentials = config.credentials;
 		this.runtimeAgentId = config.runtimeAgentId;
 		this.transport = transport;
@@ -671,7 +679,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		this.intelligence = config.intelligence;
 		this._capabilities = config.capabilities;
 		if (config.debug) this.debug = config.debug;
-		if (this.transport === "single") this.singleEndpointUrl = this.runtimeUrl;
+		if (this.transport === "single") this.singleEndpointUrl = this.runtimeEndpointUrl;
 	}
 	/**
 	* The agent id used for outbound runtime requests — `runtimeAgentId` when
@@ -826,7 +834,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	}
 	clone() {
 		const cloned = new ProxiedCopilotRuntimeAgent({
-			runtimeUrl: this.runtimeUrl,
+			runtimeUrl: this.runtimeEndpointUrl ?? this.runtimeUrl,
 			agentId: this.agentId,
 			runtimeAgentId: this.runtimeAgentId,
 			description: this.description,
@@ -898,7 +906,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
 			if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
-			url = this.runtimeUrl;
+			url = this.singleEndpointUrl;
 			init = {
 				method: "POST",
 				body: JSON.stringify({ method: "info" })
@@ -928,7 +936,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		} catch {}
 		const singleHeaders = { ...headers };
 		if (!singleHeaders["Content-Type"]) singleHeaders["Content-Type"] = "application/json";
-		const response = await this.fetch(this.runtimeUrl, {
+		const endpointUrl = this.runtimeEndpointUrl ?? this.runtimeUrl;
+		const response = await this.fetch(endpointUrl, {
 			method: "POST",
 			headers: singleHeaders,
 			body: JSON.stringify({ method: "info" }),
@@ -936,7 +945,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		});
 		if (!response.ok) throw await runtimeInfoError(response);
 		this.transport = "single";
-		this.singleEndpointUrl = this.runtimeUrl;
+		this.singleEndpointUrl = endpointUrl;
 		return await response.json();
 	}
 	createSingleRouteRequestInit(input, method, params) {
@@ -1101,6 +1110,8 @@ var AgentRegistry = class {
 	remoteAgents = {};
 	mintedThreadIds = /* @__PURE__ */ new WeakMap();
 	_runtimeUrl;
+	/** The runtime URL as the caller supplied it; the single-route endpoint uses it verbatim. */
+	_runtimeEndpointUrl;
 	_connectionInFlight;
 	_runtimeConnectionGeneration = 0;
 	_activeRuntimeConnectionAttempt;
@@ -1235,7 +1246,8 @@ var AgentRegistry = class {
 	*/
 	setRuntimeUrl(runtimeUrl, options) {
 		const normalizedRuntimeUrl = runtimeUrl ? runtimeUrl.replace(/\/$/, "") : void 0;
-		if (this._runtimeUrl === normalizedRuntimeUrl) return;
+		const runtimeEndpointUrl = runtimeUrl || void 0;
+		if (this._runtimeUrl === normalizedRuntimeUrl && this._runtimeEndpointUrl === runtimeEndpointUrl) return;
 		this.invalidateInspectorMetadataConnection();
 		this.abandonRuntimeHealthProbe();
 		this.resetRuntimeEntitlementRetry();
@@ -1243,6 +1255,7 @@ var AgentRegistry = class {
 		this._runtimeEntitlements = void 0;
 		this._singleRouteResourceOperations = false;
 		this._runtimeUrl = normalizedRuntimeUrl;
+		this._runtimeEndpointUrl = runtimeEndpointUrl;
 		if (options?.deferConnection) return;
 		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
 	}
@@ -1361,7 +1374,7 @@ var AgentRegistry = class {
 		const friends = this.core;
 		const debug = friends.debug;
 		const agent = new ProxiedCopilotRuntimeAgent({
-			runtimeUrl: this._runtimeUrl,
+			runtimeUrl: this._runtimeEndpointUrl ?? this._runtimeUrl,
 			agentId,
 			runtimeAgentId,
 			transport: this._runtimeTransport,
@@ -1442,7 +1455,7 @@ var AgentRegistry = class {
 			const meta = () => runtimeRequestMeta(init);
 			const watchdog = this.armRuntimeRequestWatchdog(meta());
 			try {
-				const singleRouteRequest = this._runtimeTransport === "single" && this._singleRouteResourceOperations && this._runtimeUrl ? await createSingleRouteResourceRequest(input, init, this._runtimeUrl) : null;
+				const singleRouteRequest = this._runtimeTransport === "single" && this._singleRouteResourceOperations && this._runtimeUrl ? await createSingleRouteResourceRequest(input, init, this._runtimeEndpointUrl ?? this._runtimeUrl) : null;
 				const response = singleRouteRequest ? await fetch(singleRouteRequest.input, singleRouteRequest.init) : await fetch(input, init);
 				watchdog.clear();
 				this.handleRuntimeRequestOutcome(response.ok ? "ok" : meta()?.nonCritical ? "ignored" : "failed", watchdog.checked);
@@ -1533,7 +1546,7 @@ var AgentRegistry = class {
 		try {
 			const request = (async () => {
 				const response = resolvedTransport === "single" ? await this.fetchInspectorMetadataSingle({
-					runtimeUrl,
+					runtimeUrl: this.singleEndpointUrlFor(runtimeUrl),
 					headers,
 					credentials,
 					signal: abortController.signal
@@ -1730,13 +1743,13 @@ var AgentRegistry = class {
 	}
 	/** Return the stable key that scopes connection and entitlement retries. */
 	runtimeConnectionKey() {
-		return `${this._runtimeUrl ?? ""}::${this._requestedTransport}`;
+		return `${this._runtimeEndpointUrl ?? this._runtimeUrl ?? ""}::${this._requestedTransport}`;
 	}
 	/** Return whether a proxy still targets this Runtime connection. */
 	canReuseRuntimeAgent(agent, runtimeUrl, transport) {
 		if (!runtimeUrl) return false;
 		const connection = this.remoteAgentConnections.get(agent);
-		return connection?.runtimeUrl === runtimeUrl.replace(/\/$/, "") && connection.transport === transport;
+		return connection?.runtimeUrl === runtimeUrl.replace(/\/$/, "") && connection.endpointUrl === this._runtimeEndpointUrl && connection.transport === transport;
 	}
 	/** Return whether an async attempt still owns the active Runtime state. */
 	isCurrentRuntimeConnection(attempt) {
@@ -1828,7 +1841,7 @@ var AgentRegistry = class {
 					return [id, existing];
 				}
 				const agent = new ProxiedCopilotRuntimeAgent({
-					runtimeUrl,
+					runtimeUrl: this._runtimeEndpointUrl ?? runtimeUrl,
 					agentId: id,
 					description,
 					transport: this._runtimeTransport,
@@ -1848,6 +1861,7 @@ var AgentRegistry = class {
 				}
 				this.remoteAgentConnections.set(agent, {
 					runtimeUrl,
+					endpointUrl: this._runtimeEndpointUrl,
 					transport: this._runtimeTransport
 				});
 				return [id, agent];
@@ -1929,7 +1943,7 @@ var AgentRegistry = class {
 		const credentials = this.core.credentials;
 		const headers = { ...baseHeaders };
 		if (runtimeTransport === "single") return {
-			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, headers, credentials, signal),
+			runtimeInfo: await this.fetchRuntimeInfoSingle(this.singleEndpointUrlFor(runtimeUrl), headers, credentials, signal),
 			resolvedTransport: "single"
 		};
 		if (runtimeTransport === "auto") return this.fetchRuntimeInfoAutoDetect(runtimeUrl, headers, credentials, signal);
@@ -1944,6 +1958,15 @@ var AgentRegistry = class {
 			resolvedTransport: "rest"
 		};
 	}
+	/**
+	* The URL a single-route request targets: the runtime URL as the caller
+	* supplied it. `runtimeUrl` is the slash-stripped form used for path joins;
+	* a trailing slash can select a different proxy location, so the endpoint
+	* itself keeps it.
+	*/
+	singleEndpointUrlFor(runtimeUrl) {
+		return this._runtimeEndpointUrl !== void 0 && this._runtimeUrl === runtimeUrl ? this._runtimeEndpointUrl : runtimeUrl;
+	}
 	async fetchRuntimeInfoSingle(runtimeUrl, headers, credentials, signal) {
 		const response = await fetch(runtimeUrl, {
 			method: "POST",
@@ -1973,7 +1996,7 @@ var AgentRegistry = class {
 			};
 		} catch {}
 		return {
-			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, { ...headers }, credentials, signal),
+			runtimeInfo: await this.fetchRuntimeInfoSingle(this.singleEndpointUrlFor(runtimeUrl), { ...headers }, credentials, signal),
 			resolvedTransport: "single"
 		};
 	}
@@ -2646,6 +2669,15 @@ var RunHandler = class {
 	*/
 	_disabledToolKeys = /* @__PURE__ */ new Set();
 	/**
+	* Registry keys already reported by {@link warnOnMissingToolParameters}.
+	* Development only, and per instance rather than per module so tests and
+	* multiple cores stay independent. Deliberately NOT cleared by
+	* {@link removeTool}: `useFrontendTool` tears down and re-registers on every
+	* dependency change, so clearing it would turn one warning into one per
+	* render. Key = `capabilityKey(name, agentId)`.
+	*/
+	_warnedMissingToolParameters = /* @__PURE__ */ new Set();
+	/**
 	* Tracks whether the current run (including in-flight tool execution)
 	* has been aborted via `stopAgent()` or `agent.abortRun()`. Created
 	* fresh in `runAgent()`, aborted by `abortCurrentRun()`.
@@ -2735,6 +2767,7 @@ var RunHandler = class {
 	initialize(tools) {
 		this._propTools = [...tools];
 		this._cachedMergedTools = null;
+		this.warnOnMissingToolParameters(this._propTools);
 		this.syncWebMCP();
 	}
 	/**
@@ -2749,9 +2782,39 @@ var RunHandler = class {
 		}
 		this._hookTools.set(key, tool);
 		this._cachedMergedTools = null;
+		this.warnOnMissingToolParameters([tool]);
 		this.syncWebMCP();
 	}
 	/**
+	* Report, once per tool and at development time only, a tool registered with
+	* no `parameters` schema.
+	*
+	* `createToolSchema` substitutes `{ type: "object", properties: {} }` for a
+	* missing `parameters` and returns silently, and `parameters` is optional on
+	* `FrontendTool`, so nothing — not the compiler, not the runtime — tells the
+	* developer that the model was handed a tool with nothing to fill in. It then
+	* calls the tool with no arguments. `useComponent`, `useFrontendTool` and
+	* `useHumanInTheLoop` all funnel into {@link addTool}; the provider's `tools`
+	* prop funnels into {@link initialize} and {@link setTools}.
+	*
+	* A parameterless tool is legitimate (a HITL confirm dialog, say), so this
+	* stays a warning rather than an error. An explicit empty schema
+	* (`parameters: z.object({})`) is the way to say "takes none on purpose": it
+	* satisfies the check below and `createToolSchema` reduces it to the same
+	* advertised `{ type: "object", properties: {} }` that omitting `parameters`
+	* produces, so silencing the warning costs nothing on the wire.
+	*/
+	warnOnMissingToolParameters(tools) {
+		if (process.env.NODE_ENV === "production") return;
+		for (const tool of tools) {
+			if (tool.parameters) continue;
+			const key = this.capabilityKey(tool.name, tool.agentId);
+			if (this._warnedMissingToolParameters.has(key)) continue;
+			this._warnedMissingToolParameters.add(key);
+			logger.warn(`Tool has no parameters schema: '${tool.name}' for agent '${tool.agentId || "global"}'. The model is told it takes no arguments and will call it with none. Add \`parameters\` (a Zod or Standard Schema object) if it should receive arguments, or \`parameters: z.object({})\` to declare that it takes none and silence this warning.`);
+		}
+	}
+	/**
 	* Remove a tool by name and optionally by agentId
 	*/
 	removeTool(id, agentId) {
@@ -2784,6 +2847,7 @@ var RunHandler = class {
 	setTools(tools) {
 		this._propTools = [...tools];
 		this._cachedMergedTools = null;
+		this.warnOnMissingToolParameters(this._propTools);
 		this.syncWebMCP();
 	}
 	/**