@copilotkit/shared 1.75.2 → 1.76.0

package/dist/intelligence-routing-fields.cjs

@@ -0,0 +1,35 @@
+
+//#region src/intelligence-routing-fields.ts
+/**
+* The only AG-UI 1.0 events whose schema declares `threadId` and `runId`.
+* Plain literals, not `EventType`: a value import of `@ag-ui/client` here put
+* the client and its zod validators into the initial chunk of every app that
+* imports `@copilotkit/shared`.
+*/
+const RUN_IDENTITY_EVENTS = new Set(["RUN_STARTED", "RUN_FINISHED"]);
+/**
+* Removes the routing fields that the Intelligence runner stamps on every
+* event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /
+* `runId` on events that do not declare them).
+*
+* The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown
+* fields before subscribers see them and warns once per field, per event,
+* so a streamed answer would log hundreds of warnings. Call this where a
+* gateway payload enters an AG-UI pipeline. The gateway still receives the
+* fields, because the runner adds them after this point.
+*/
+function stripIntelligenceRoutingFields(event) {
+	const record = event;
+	const keepRunIdentity = RUN_IDENTITY_EVENTS.has(record.type);
+	if (!("thread_id" in record) && !("run_id" in record) && (keepRunIdentity || !("threadId" in record) && !("runId" in record))) return event;
+	const { thread_id: _t, run_id: _r, ...rest } = record;
+	if (!keepRunIdentity) {
+		delete rest.threadId;
+		delete rest.runId;
+	}
+	return rest;
+}
+
+//#endregion
+exports.stripIntelligenceRoutingFields = stripIntelligenceRoutingFields;
+//# sourceMappingURL=intelligence-routing-fields.cjs.map

package/dist/intelligence-routing-fields.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-routing-fields.cjs","names":[],"sources":["../src/intelligence-routing-fields.ts"],"sourcesContent":["import type { BaseEvent } from \"@ag-ui/client\";\n\n/**\n * The only AG-UI 1.0 events whose schema declares `threadId` and `runId`.\n * Plain literals, not `EventType`: a value import of `@ag-ui/client` here put\n * the client and its zod validators into the initial chunk of every app that\n * imports `@copilotkit/shared`.\n */\nconst RUN_IDENTITY_EVENTS = new Set<string>([\"RUN_STARTED\", \"RUN_FINISHED\"]);\n\n/**\n * Removes the routing fields that the Intelligence runner stamps on every\n * event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /\n * `runId` on events that do not declare them).\n *\n * The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown\n * fields before subscribers see them and warns once per field, per event,\n * so a streamed answer would log hundreds of warnings. Call this where a\n * gateway payload enters an AG-UI pipeline. The gateway still receives the\n * fields, because the runner adds them after this point.\n */\nexport function stripIntelligenceRoutingFields<T extends BaseEvent>(\n  event: T,\n): T {\n  const record = event as T & Record<string, unknown>;\n  const keepRunIdentity = RUN_IDENTITY_EVENTS.has(record.type);\n  if (\n    !(\"thread_id\" in record) &&\n    !(\"run_id\" in record) &&\n    (keepRunIdentity || (!(\"threadId\" in record) && !(\"runId\" in record)))\n  ) {\n    return event;\n  }\n  const { thread_id: _t, run_id: _r, ...rest } = record;\n  if (!keepRunIdentity) {\n    delete rest.threadId;\n    delete rest.runId;\n  }\n  return rest as unknown as T;\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,sBAAsB,IAAI,IAAY,CAAC,eAAe,eAAe,CAAC;;;;;;;;;;;;AAa5E,SAAgB,+BACd,OACG;CACH,MAAM,SAAS;CACf,MAAM,kBAAkB,oBAAoB,IAAI,OAAO,KAAK;AAC5D,KACE,EAAE,eAAe,WACjB,EAAE,YAAY,YACb,mBAAoB,EAAE,cAAc,WAAW,EAAE,WAAW,SAE7D,QAAO;CAET,MAAM,EAAE,WAAW,IAAI,QAAQ,IAAI,GAAG,SAAS;AAC/C,KAAI,CAAC,iBAAiB;AACpB,SAAO,KAAK;AACZ,SAAO,KAAK;;AAEd,QAAO"}

package/dist/intelligence-routing-fields.d.cts

@@ -0,0 +1,18 @@
+import { BaseEvent } from "@ag-ui/client";
+
+//#region src/intelligence-routing-fields.d.ts
+/**
+ * Removes the routing fields that the Intelligence runner stamps on every
+ * event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /
+ * `runId` on events that do not declare them).
+ *
+ * The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown
+ * fields before subscribers see them and warns once per field, per event,
+ * so a streamed answer would log hundreds of warnings. Call this where a
+ * gateway payload enters an AG-UI pipeline. The gateway still receives the
+ * fields, because the runner adds them after this point.
+ */
+declare function stripIntelligenceRoutingFields<T extends BaseEvent>(event: T): T;
+//#endregion
+export { stripIntelligenceRoutingFields };
+//# sourceMappingURL=intelligence-routing-fields.d.cts.map

package/dist/intelligence-routing-fields.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-routing-fields.d.cts","names":[],"sources":["../src/intelligence-routing-fields.ts"],"mappings":";;;;;AAqBA;;;;;;;;;iBAAgB,8BAAA,WAAyC,SAAA,CAAA,CACvD,KAAA,EAAO,CAAA,GACN,CAAA"}

package/dist/intelligence-routing-fields.d.mts

@@ -0,0 +1,18 @@
+import { BaseEvent } from "@ag-ui/client";
+
+//#region src/intelligence-routing-fields.d.ts
+/**
+ * Removes the routing fields that the Intelligence runner stamps on every
+ * event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /
+ * `runId` on events that do not declare them).
+ *
+ * The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown
+ * fields before subscribers see them and warns once per field, per event,
+ * so a streamed answer would log hundreds of warnings. Call this where a
+ * gateway payload enters an AG-UI pipeline. The gateway still receives the
+ * fields, because the runner adds them after this point.
+ */
+declare function stripIntelligenceRoutingFields<T extends BaseEvent>(event: T): T;
+//#endregion
+export { stripIntelligenceRoutingFields };
+//# sourceMappingURL=intelligence-routing-fields.d.mts.map

package/dist/intelligence-routing-fields.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-routing-fields.d.mts","names":[],"sources":["../src/intelligence-routing-fields.ts"],"mappings":";;;;;AAqBA;;;;;;;;;iBAAgB,8BAAA,WAAyC,SAAA,CAAA,CACvD,KAAA,EAAO,CAAA,GACN,CAAA"}

package/dist/intelligence-routing-fields.mjs

@@ -0,0 +1,34 @@
+//#region src/intelligence-routing-fields.ts
+/**
+* The only AG-UI 1.0 events whose schema declares `threadId` and `runId`.
+* Plain literals, not `EventType`: a value import of `@ag-ui/client` here put
+* the client and its zod validators into the initial chunk of every app that
+* imports `@copilotkit/shared`.
+*/
+const RUN_IDENTITY_EVENTS = new Set(["RUN_STARTED", "RUN_FINISHED"]);
+/**
+* Removes the routing fields that the Intelligence runner stamps on every
+* event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /
+* `runId` on events that do not declare them).
+*
+* The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown
+* fields before subscribers see them and warns once per field, per event,
+* so a streamed answer would log hundreds of warnings. Call this where a
+* gateway payload enters an AG-UI pipeline. The gateway still receives the
+* fields, because the runner adds them after this point.
+*/
+function stripIntelligenceRoutingFields(event) {
+	const record = event;
+	const keepRunIdentity = RUN_IDENTITY_EVENTS.has(record.type);
+	if (!("thread_id" in record) && !("run_id" in record) && (keepRunIdentity || !("threadId" in record) && !("runId" in record))) return event;
+	const { thread_id: _t, run_id: _r, ...rest } = record;
+	if (!keepRunIdentity) {
+		delete rest.threadId;
+		delete rest.runId;
+	}
+	return rest;
+}
+
+//#endregion
+export { stripIntelligenceRoutingFields };
+//# sourceMappingURL=intelligence-routing-fields.mjs.map

package/dist/intelligence-routing-fields.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-routing-fields.mjs","names":[],"sources":["../src/intelligence-routing-fields.ts"],"sourcesContent":["import type { BaseEvent } from \"@ag-ui/client\";\n\n/**\n * The only AG-UI 1.0 events whose schema declares `threadId` and `runId`.\n * Plain literals, not `EventType`: a value import of `@ag-ui/client` here put\n * the client and its zod validators into the initial chunk of every app that\n * imports `@copilotkit/shared`.\n */\nconst RUN_IDENTITY_EVENTS = new Set<string>([\"RUN_STARTED\", \"RUN_FINISHED\"]);\n\n/**\n * Removes the routing fields that the Intelligence runner stamps on every\n * event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /\n * `runId` on events that do not declare them).\n *\n * The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown\n * fields before subscribers see them and warns once per field, per event,\n * so a streamed answer would log hundreds of warnings. Call this where a\n * gateway payload enters an AG-UI pipeline. The gateway still receives the\n * fields, because the runner adds them after this point.\n */\nexport function stripIntelligenceRoutingFields<T extends BaseEvent>(\n  event: T,\n): T {\n  const record = event as T & Record<string, unknown>;\n  const keepRunIdentity = RUN_IDENTITY_EVENTS.has(record.type);\n  if (\n    !(\"thread_id\" in record) &&\n    !(\"run_id\" in record) &&\n    (keepRunIdentity || (!(\"threadId\" in record) && !(\"runId\" in record)))\n  ) {\n    return event;\n  }\n  const { thread_id: _t, run_id: _r, ...rest } = record;\n  if (!keepRunIdentity) {\n    delete rest.threadId;\n    delete rest.runId;\n  }\n  return rest as unknown as T;\n}\n"],"mappings":";;;;;;;AAQA,MAAM,sBAAsB,IAAI,IAAY,CAAC,eAAe,eAAe,CAAC;;;;;;;;;;;;AAa5E,SAAgB,+BACd,OACG;CACH,MAAM,SAAS;CACf,MAAM,kBAAkB,oBAAoB,IAAI,OAAO,KAAK;AAC5D,KACE,EAAE,eAAe,WACjB,EAAE,YAAY,YACb,mBAAoB,EAAE,cAAc,WAAW,EAAE,WAAW,SAE7D,QAAO;CAET,MAAM,EAAE,WAAW,IAAI,QAAQ,IAAI,GAAG,SAAS;AAC/C,KAAI,CAAC,iBAAiB;AACpB,SAAO,KAAK;AACZ,SAAO,KAAK;;AAEd,QAAO"}

package/dist/package.cjs

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "1.75.2";
+var version = "1.76.0";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "1.75.2";
+var version = "1.76.0";
 
 //#endregion
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/shared",
-  "version": "1.75.2",
+  "version": "1.76.0",
   "private": false,
   "keywords": [
     "ai",
@@ -57,7 +57,7 @@
   },
   "dependencies": {
     "@ag-ui/a2ui-middleware": "0.0.10",
-    "@ag-ui/client": "0.0.59",
+    "@ag-ui/client": "1.0.1",
     "@copilotkit/license-verifier": "~0.5.0",
     "@segment/analytics-node": "^2.1.2",
     "@standard-schema/spec": "^1.0.0",
@@ -71,6 +71,7 @@
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
+    "@ag-ui/core": "1.0.1",
     "@types/clarinet": "^0.12.3",
     "@types/uuid": "^10.0.0",
     "@valibot/to-json-schema": "^1.5.0",

package/src/attachments/__tests__/utils.test.ts

@@ -3,6 +3,7 @@ import {
   formatFileSize,
   exceedsMaxSize,
   matchesAcceptFilter,
+  getSourceUrl,
 } from "../utils";
 
 // ---------------------------------------------------------------------------
@@ -196,3 +197,18 @@ describe("matchesAcceptFilter", () => {
     expect(matchesAcceptFilter(mockFileWithType(""), "image/*")).toBe(false);
   });
 });
+
+describe("getSourceUrl", () => {
+  it("returns a URL source as is and builds a data URL for inline data", () => {
+    expect(getSourceUrl({ type: "url", value: "https://x.test/a.png" })).toBe(
+      "https://x.test/a.png",
+    );
+    expect(
+      getSourceUrl({ type: "data", value: "aGk=", mimeType: "image/png" }),
+    ).toBe("data:image/png;base64,aGk=");
+  });
+
+  it("returns no address for a provider file handle", () => {
+    expect(getSourceUrl({ type: "file", value: "file-abc123" })).toBe("");
+  });
+});

package/src/attachments/utils.ts

@@ -142,11 +142,16 @@ export function matchesAcceptFilter(file: File, accept: string): boolean {
 /**
  * Convert an InputContentSource to a usable URL string.
  * For data sources, returns a base64 data URL; for URL sources, returns the URL directly.
+ * A provider file handle (AG-UI 1.0 `file` source) has no address a browser
+ * can load, so it returns an empty string and the caller shows no preview.
  */
 export function getSourceUrl(source: InputContentSource): string {
   if (source.type === "url") {
     return source.value;
   }
+  if (source.type === "file") {
+    return "";
+  }
   return `data:${source.mimeType};base64,${source.value}`;
 }
 

package/src/finalize-events.test.ts

@@ -57,6 +57,49 @@ describe("createRunEventFinalizer", () => {
     },
   );
 
+  it("closes open reasoning, message before span, because AG-UI 1.0 requires it", () => {
+    const finalizer = createRunEventFinalizer();
+    for (const value of [
+      event({ type: EventType.REASONING_START, messageId: "span-1" }),
+      event({ type: EventType.REASONING_MESSAGE_START, messageId: "r-1" }),
+      event({ type: EventType.REASONING_START, messageId: "span-2" }),
+      event({ type: EventType.REASONING_END, messageId: "span-2" }),
+    ]) {
+      finalizer.observe(value);
+    }
+
+    expect(finalizer.finalize({ stopRequested: true }).slice(0, 2)).toEqual([
+      { type: EventType.REASONING_MESSAGE_END, messageId: "r-1" },
+      { type: EventType.REASONING_END, messageId: "span-1" },
+    ]);
+  });
+
+  it("stamps the run identity on a stop and marks it cancelled for a 1.0 client", () => {
+    const started = event({
+      type: EventType.RUN_STARTED,
+      threadId: "thread-1",
+      runId: "run-1",
+    });
+    const stopFor = (protocolVersion?: string) => {
+      const finalizer = createRunEventFinalizer();
+      finalizer.observe(started);
+      return finalizer.finalize({ stopRequested: true, protocolVersion });
+    };
+
+    expect(stopFor("1.0")).toEqual([
+      {
+        type: EventType.RUN_FINISHED,
+        threadId: "thread-1",
+        runId: "run-1",
+        outcome: { type: "cancelled" },
+      },
+    ]);
+    // A client without a declared version predates 1.0 and cannot parse it.
+    expect(stopFor(undefined)).toEqual([
+      { type: EventType.RUN_FINISHED, threadId: "thread-1", runId: "run-1" },
+    ]);
+  });
+
   it("forgets a lifecycle as soon as it closes", () => {
     const finalizer = createRunEventFinalizer();
     for (let index = 0; index < 1000; index += 1) {
@@ -102,6 +145,101 @@ describe("createRunEventFinalizer", () => {
     ]);
   });
 
+  it("closes open subagents on a stop, children first, after their messages and before the terminal", () => {
+    const finalizer = createRunEventFinalizer();
+    for (const value of [
+      event({
+        type: EventType.SUBAGENT_STARTED,
+        subagentRunId: "parent",
+        name: "researcher",
+      }),
+      event({
+        type: EventType.SUBAGENT_STARTED,
+        subagentRunId: "child",
+        name: "searcher",
+        parentSubagentRunId: "parent",
+      }),
+      event({
+        type: EventType.TEXT_MESSAGE_START,
+        messageId: "message-1",
+        subagentRunId: "child",
+      }),
+    ]) {
+      finalizer.observe(value);
+    }
+
+    expect(
+      finalizer.finalize({
+        stopRequested: true,
+        interruptionMessage: "Stopped from the toolbar",
+      }),
+    ).toEqual([
+      { type: EventType.TEXT_MESSAGE_END, messageId: "message-1" },
+      {
+        type: EventType.SUBAGENT_ERROR,
+        subagentRunId: "child",
+        message: "Stopped from the toolbar",
+        code: "CANCELLED",
+      },
+      {
+        type: EventType.SUBAGENT_ERROR,
+        subagentRunId: "parent",
+        message: "Stopped from the toolbar",
+        code: "CANCELLED",
+      },
+      { type: EventType.RUN_FINISHED },
+    ]);
+  });
+
+  it.each([EventType.SUBAGENT_FINISHED, EventType.SUBAGENT_ERROR])(
+    "does not close a subagent again after %s",
+    (closer) => {
+      const finalizer = createRunEventFinalizer();
+      finalizer.observe(
+        event({
+          type: EventType.SUBAGENT_STARTED,
+          subagentRunId: "done",
+          name: "writer",
+        }),
+      );
+      finalizer.observe(
+        event({ type: closer, subagentRunId: "done", message: "boom" }),
+      );
+      finalizer.observe(
+        event({
+          type: EventType.SUBAGENT_STARTED,
+          subagentRunId: "open",
+          name: "critic",
+        }),
+      );
+
+      expect(finalizer.finalize({ stopRequested: true })).toEqual([
+        {
+          type: EventType.SUBAGENT_ERROR,
+          subagentRunId: "open",
+          message: "Run stopped by user",
+          code: "CANCELLED",
+        },
+        { type: EventType.RUN_FINISHED },
+      ]);
+    },
+  );
+
+  it("leaves open subagents unclosed when the stream ends abruptly, because RUN_ERROR abandons them", () => {
+    const finalizer = createRunEventFinalizer();
+    finalizer.observe(
+      event({
+        type: EventType.SUBAGENT_STARTED,
+        subagentRunId: "open",
+        name: "critic",
+      }),
+    );
+
+    expect(finalizer.finalize().map(({ type }) => type)).toEqual([
+      EventType.RUN_ERROR,
+    ]);
+  });
+
   it("ignores start events without an id so finalize never emits an empty id", () => {
     const finalizer = createRunEventFinalizer();
     finalizer.observe(

package/src/finalize-events.ts

@@ -4,6 +4,13 @@ import { EventType } from "@ag-ui/client";
 export interface FinalizeRunOptions {
   stopRequested?: boolean;
   interruptionMessage?: string;
+  /**
+   * The `protocolVersion` the client declared on its RunAgentInput. When it is
+   * set, a stopped run finishes with the AG-UI 1.0 `cancelled` outcome. A
+   * client that declares no version predates 1.0 and cannot parse that
+   * outcome, so it gets the plain RUN_FINISHED it always got.
+   */
+  protocolVersion?: string;
 }
 
 export interface RunEventFinalizer {
@@ -24,19 +31,64 @@ interface OpenToolCall {
 /**
  * Incremental finalizer for a streamed AG-UI run. Feed every event to
  * `observe`; when the stream ends without a terminal event, `finalize` returns
- * the closers for text messages and tool calls still open plus a terminal
- * event. Closed lifecycles are forgotten at once and payloads are never kept,
+ * the closers for reasoning, text messages and tool calls still open plus a
+ * terminal event. AG-UI 1.0 fails a run that ends with reasoning still open,
+ * so reasoning is closed too. It also fails a RUN_FINISHED while a subagent
+ * is still open, so a stop closes open subagents as well; a RUN_ERROR
+ * abandons them, which the protocol allows. Closed lifecycles are forgotten at once and payloads are never kept,
  * so a caller does not have to retain the event array for this purpose.
  */
 export function createRunEventFinalizer(): RunEventFinalizer {
   const openMessageIds = new Set<string>();
+  const openReasoningMessageIds = new Set<string>();
+  const openReasoningSpanIds = new Set<string>();
   const openToolCalls = new Map<string, OpenToolCall>();
+  // Insertion order is start order, so closing in reverse closes children first.
+  const openSubagentRunIds = new Set<string>();
+  let runIdentity: { threadId?: string; runId?: string } = {};
   let terminalEventObserved = false;
 
+  const clearOpen = () => {
+    openMessageIds.clear();
+    openReasoningMessageIds.clear();
+    openReasoningSpanIds.clear();
+    openToolCalls.clear();
+    openSubagentRunIds.clear();
+  };
+
   const observe = (event: BaseEvent) => {
     if (terminalEventObserved) return;
 
     switch (event.type) {
+      case EventType.RUN_STARTED: {
+        const { threadId, runId } = event as {
+          threadId?: string;
+          runId?: string;
+        };
+        runIdentity = { threadId, runId };
+        break;
+      }
+      case EventType.REASONING_START:
+      case EventType.REASONING_END:
+      case EventType.REASONING_MESSAGE_START:
+      case EventType.REASONING_MESSAGE_END: {
+        const messageId = (event as { messageId?: string }).messageId;
+        if (typeof messageId !== "string") break;
+        const open =
+          event.type === EventType.REASONING_START ||
+          event.type === EventType.REASONING_END
+            ? openReasoningSpanIds
+            : openReasoningMessageIds;
+        if (
+          event.type === EventType.REASONING_START ||
+          event.type === EventType.REASONING_MESSAGE_START
+        ) {
+          open.add(messageId);
+        } else {
+          open.delete(messageId);
+        }
+        break;
+      }
       case EventType.TEXT_MESSAGE_START: {
         const messageId = (event as { messageId?: string }).messageId;
         if (messageId) openMessageIds.add(messageId);
@@ -66,11 +118,23 @@ export function createRunEventFinalizer(): RunEventFinalizer {
         if (info.hasEnd && info.hasResult) openToolCalls.delete(toolCallId);
         break;
       }
+      case EventType.SUBAGENT_STARTED:
+      case EventType.SUBAGENT_FINISHED:
+      case EventType.SUBAGENT_ERROR: {
+        const subagentRunId = (event as { subagentRunId?: string })
+          .subagentRunId;
+        if (!subagentRunId) break;
+        if (event.type === EventType.SUBAGENT_STARTED) {
+          openSubagentRunIds.add(subagentRunId);
+        } else {
+          openSubagentRunIds.delete(subagentRunId);
+        }
+        break;
+      }
       case EventType.RUN_FINISHED:
       case EventType.RUN_ERROR:
         terminalEventObserved = true;
-        openMessageIds.clear();
-        openToolCalls.clear();
+        clearOpen();
         break;
       default:
         break;
@@ -88,6 +152,17 @@ export function createRunEventFinalizer(): RunEventFinalizer {
         : defaultAbruptEndMessage;
     const appended: BaseEvent[] = [];
 
+    // A reasoning message closes before the span that holds it.
+    for (const messageId of openReasoningMessageIds) {
+      appended.push({
+        type: EventType.REASONING_MESSAGE_END,
+        messageId,
+      } as BaseEvent);
+    }
+    for (const messageId of openReasoningSpanIds) {
+      appended.push({ type: EventType.REASONING_END, messageId } as BaseEvent);
+    }
+
     for (const messageId of openMessageIds) {
       appended.push({
         type: EventType.TEXT_MESSAGE_END,
@@ -127,7 +202,29 @@ export function createRunEventFinalizer(): RunEventFinalizer {
     }
 
     if (stopRequested) {
-      appended.push({ type: EventType.RUN_FINISHED } as BaseEvent);
+      // Newest first, so a nested subagent closes before its parent. An index
+      // loop, because `toReversed` is ES2023 and this package targets older.
+      const openIds = [...openSubagentRunIds];
+      for (let index = openIds.length - 1; index >= 0; index -= 1) {
+        appended.push({
+          type: EventType.SUBAGENT_ERROR,
+          subagentRunId: openIds[index],
+          message: resolvedStopMessage,
+          code: "CANCELLED",
+        } as BaseEvent);
+      }
+      appended.push({
+        type: EventType.RUN_FINISHED,
+        ...(runIdentity.threadId !== undefined
+          ? { threadId: runIdentity.threadId }
+          : {}),
+        ...(runIdentity.runId !== undefined
+          ? { runId: runIdentity.runId }
+          : {}),
+        ...(options.protocolVersion !== undefined
+          ? { outcome: { type: "cancelled" } }
+          : {}),
+      } as BaseEvent);
     } else {
       const errorEvent: RunErrorEvent = {
         type: EventType.RUN_ERROR,
@@ -138,8 +235,7 @@ export function createRunEventFinalizer(): RunEventFinalizer {
     }
 
     terminalEventObserved = true;
-    openMessageIds.clear();
-    openToolCalls.clear();
+    clearOpen();
     return appended;
   };
 

package/src/index.ts

@@ -40,6 +40,7 @@ export {
   type FinalizeRunOptions,
   type RunEventFinalizer,
 } from "./finalize-events";
+export { stripIntelligenceRoutingFields } from "./intelligence-routing-fields";
 
 export {
   TranscriptionErrorCode,

package/src/intelligence-routing-fields.test.ts

@@ -0,0 +1,51 @@
+import type { BaseEvent } from "@ag-ui/client";
+import { EventType } from "@ag-ui/client";
+import { describe, expect, it } from "vitest";
+import { stripIntelligenceRoutingFields } from "./intelligence-routing-fields";
+
+const stamped = {
+  threadId: "t1",
+  runId: "r1",
+  thread_id: "t1",
+  run_id: "r1",
+  metadata: { cpki_event_id: "e1" },
+};
+
+describe("stripIntelligenceRoutingFields", () => {
+  it("removes all routing fields from an event that does not declare them", () => {
+    const event = {
+      type: EventType.TEXT_MESSAGE_CONTENT,
+      messageId: "m1",
+      delta: "hi",
+      ...stamped,
+    } as BaseEvent;
+
+    expect(stripIntelligenceRoutingFields(event)).toEqual({
+      type: EventType.TEXT_MESSAGE_CONTENT,
+      messageId: "m1",
+      delta: "hi",
+      metadata: { cpki_event_id: "e1" },
+    });
+  });
+
+  it("keeps threadId and runId on the run events that declare them", () => {
+    const event = { type: EventType.RUN_FINISHED, ...stamped } as BaseEvent;
+
+    expect(stripIntelligenceRoutingFields(event)).toEqual({
+      type: EventType.RUN_FINISHED,
+      threadId: "t1",
+      runId: "r1",
+      metadata: { cpki_event_id: "e1" },
+    });
+  });
+
+  it("returns an event without routing fields unchanged", () => {
+    const event = {
+      type: EventType.RUN_STARTED,
+      threadId: "t1",
+      runId: "r1",
+    } as BaseEvent;
+
+    expect(stripIntelligenceRoutingFields(event)).toBe(event);
+  });
+});

package/src/intelligence-routing-fields.ts

@@ -0,0 +1,40 @@
+import type { BaseEvent } from "@ag-ui/client";
+
+/**
+ * The only AG-UI 1.0 events whose schema declares `threadId` and `runId`.
+ * Plain literals, not `EventType`: a value import of `@ag-ui/client` here put
+ * the client and its zod validators into the initial chunk of every app that
+ * imports `@copilotkit/shared`.
+ */
+const RUN_IDENTITY_EVENTS = new Set<string>(["RUN_STARTED", "RUN_FINISHED"]);
+
+/**
+ * Removes the routing fields that the Intelligence runner stamps on every
+ * event it sends to the gateway (`thread_id`, `run_id`, and `threadId` /
+ * `runId` on events that do not declare them).
+ *
+ * The gateway relays these payloads unchanged. AG-UI 1.0 strips unknown
+ * fields before subscribers see them and warns once per field, per event,
+ * so a streamed answer would log hundreds of warnings. Call this where a
+ * gateway payload enters an AG-UI pipeline. The gateway still receives the
+ * fields, because the runner adds them after this point.
+ */
+export function stripIntelligenceRoutingFields<T extends BaseEvent>(
+  event: T,
+): T {
+  const record = event as T & Record<string, unknown>;
+  const keepRunIdentity = RUN_IDENTITY_EVENTS.has(record.type);
+  if (
+    !("thread_id" in record) &&
+    !("run_id" in record) &&
+    (keepRunIdentity || (!("threadId" in record) && !("runId" in record)))
+  ) {
+    return event;
+  }
+  const { thread_id: _t, run_id: _r, ...rest } = record;
+  if (!keepRunIdentity) {
+    delete rest.threadId;
+    delete rest.runId;
+  }
+  return rest as unknown as T;
+}