@copilotkit/runtime 1.56.4 → 1.56.5-canary.1777671752

package/src/agent/converters/tanstack.ts

@@ -8,6 +8,13 @@ import {
   ToolCallEndEvent,
   ToolCallStartEvent,
   ToolCallResultEvent,
+  StateSnapshotEvent,
+  StateDeltaEvent,
+  ReasoningStartEvent,
+  ReasoningMessageStartEvent,
+  ReasoningMessageContentEvent,
+  ReasoningMessageEndEvent,
+  ReasoningEndEvent,
 } from "@ag-ui/client";
 import { randomUUID } from "@copilotkit/shared";
 
@@ -229,6 +236,44 @@ export async function* convertTanStackStream(
   abortSignal: AbortSignal,
 ): AsyncGenerator<BaseEvent> {
   const messageId = randomUUID();
+  const toolNamesById = new Map<string, string>();
+  // Track the reasoning lifecycle at two granularities so closeReasoningIfOpen
+  // emits exactly the events still owed. A single boolean conflates the run
+  // (REASONING_START → REASONING_END) with the message
+  // (REASONING_MESSAGE_START → REASONING_MESSAGE_END) and produces a duplicate
+  // REASONING_MESSAGE_END when upstream emits MSG_END but not END before
+  // text/tools resume.
+  let reasoningRunOpen = false;
+  let reasoningMessageOpen = false;
+  let reasoningMessageId = randomUUID();
+
+  function* closeReasoningIfOpen(): Generator<BaseEvent> {
+    if (reasoningMessageOpen) {
+      reasoningMessageOpen = false;
+      const msgEnd: ReasoningMessageEndEvent = {
+        type: EventType.REASONING_MESSAGE_END,
+        messageId: reasoningMessageId,
+      };
+      yield msgEnd;
+    }
+    if (reasoningRunOpen) {
+      reasoningRunOpen = false;
+      const end: ReasoningEndEvent = {
+        type: EventType.REASONING_END,
+        messageId: reasoningMessageId,
+      };
+      yield end;
+    }
+  }
+
+  // TanStack's chat() engine runs a multi-turn agent loop: after the model
+  // returns tool calls, the engine tries to execute them and re-prompt. This
+  // produces a second round of TOOL_CALL_START / TOOL_CALL_END events that
+  // duplicate the ones from the first streaming pass. The CopilotKit runtime
+  // handles tool execution externally (via the frontend SDK), so we must stop
+  // converting events once the TanStack adapter signals the first turn is
+  // complete with RUN_FINISHED.
+  let runFinished = false;
 
   for await (const chunk of stream) {
     if (abortSignal.aborted) break;
@@ -236,7 +281,17 @@ export async function* convertTanStackStream(
     const raw = chunk as Record<string, unknown>;
     const type = raw.type as string;
 
-    if (type === "TEXT_MESSAGE_CONTENT" && raw.delta) {
+    // Stop converting after the first RUN_FINISHED — any subsequent events
+    // come from TanStack's internal tool-execution loop and would produce
+    // duplicate TOOL_CALL_END events that violate the ag-ui verify middleware.
+    if (type === "RUN_FINISHED") {
+      runFinished = true;
+      continue;
+    }
+    if (runFinished) continue;
+
+    if (type === "TEXT_MESSAGE_CONTENT" && raw.delta != null) {
+      yield* closeReasoningIfOpen();
       const textEvent: TextMessageChunkEvent = {
         type: EventType.TEXT_MESSAGE_CHUNK,
         role: "assistant",
@@ -245,6 +300,8 @@ export async function* convertTanStackStream(
       };
       yield textEvent;
     } else if (type === "TOOL_CALL_START") {
+      yield* closeReasoningIfOpen();
+      toolNamesById.set(raw.toolCallId as string, raw.toolCallName as string);
       const startEvent: ToolCallStartEvent = {
         type: EventType.TOOL_CALL_START,
         parentMessageId: messageId,
@@ -253,6 +310,7 @@ export async function* convertTanStackStream(
       };
       yield startEvent;
     } else if (type === "TOOL_CALL_ARGS") {
+      yield* closeReasoningIfOpen();
       const argsEvent: ToolCallArgsEvent = {
         type: EventType.TOOL_CALL_ARGS,
         toolCallId: raw.toolCallId as string,
@@ -260,35 +318,134 @@ export async function* convertTanStackStream(
       };
       yield argsEvent;
     } else if (type === "TOOL_CALL_END") {
+      yield* closeReasoningIfOpen();
       const endEvent: ToolCallEndEvent = {
         type: EventType.TOOL_CALL_END,
         toolCallId: raw.toolCallId as string,
       };
       yield endEvent;
     } else if (type === "TOOL_CALL_RESULT") {
+      yield* closeReasoningIfOpen();
+      const toolCallId = raw.toolCallId as string;
+      const toolName = toolNamesById.get(toolCallId);
+      // Accept the payload from either `content` (canonical TanStack shape)
+      // or `result` (alternate shape used by some adapters / tests). Both
+      // state-tool detection and the final TOOL_CALL_RESULT serialization
+      // must read the same field, otherwise STATE_SNAPSHOT/STATE_DELTA can
+      // be silently dropped when upstream uses `result`.
+      const rawPayload = raw.content ?? raw.result;
+
+      const parsedContent =
+        typeof rawPayload === "string" ? safeParse(rawPayload) : rawPayload;
+
+      if (
+        toolName === "AGUISendStateSnapshot" &&
+        parsedContent &&
+        typeof parsedContent === "object" &&
+        "snapshot" in parsedContent
+      ) {
+        const stateSnapshotEvent: StateSnapshotEvent = {
+          type: EventType.STATE_SNAPSHOT,
+          snapshot: (parsedContent as Record<string, unknown>).snapshot,
+        };
+        yield stateSnapshotEvent;
+      }
+
+      if (
+        toolName === "AGUISendStateDelta" &&
+        parsedContent &&
+        typeof parsedContent === "object" &&
+        "delta" in parsedContent
+      ) {
+        const stateDeltaEvent: StateDeltaEvent = {
+          type: EventType.STATE_DELTA,
+          delta: (parsedContent as Record<string, unknown>).delta as never,
+        };
+        yield stateDeltaEvent;
+      }
+
       let serializedContent: string;
-      if (typeof raw.content === "string") {
-        serializedContent = raw.content;
+      if (typeof rawPayload === "string") {
+        serializedContent = rawPayload;
       } else {
         try {
-          serializedContent = JSON.stringify(raw.content ?? raw.result ?? null);
+          serializedContent = JSON.stringify(rawPayload ?? null);
         } catch {
           serializedContent = "[Unserializable tool result]";
         }
       }
+
       const resultEvent: ToolCallResultEvent = {
         type: EventType.TOOL_CALL_RESULT,
         role: "tool",
         messageId: randomUUID(),
-        toolCallId: raw.toolCallId as string,
+        toolCallId,
         content: serializedContent,
       };
       yield resultEvent;
+      toolNamesById.delete(toolCallId);
+    } else if (type === "REASONING_START") {
+      // If a prior reasoning run is still open (no REASONING_END before this
+      // new START), close it cleanly first so MSG_END / END pair correctly.
+      yield* closeReasoningIfOpen();
+      reasoningRunOpen = true;
+      reasoningMessageId = (raw.messageId as string) ?? randomUUID();
+      const startEvt: ReasoningStartEvent = {
+        type: EventType.REASONING_START,
+        messageId: reasoningMessageId,
+      };
+      yield startEvt;
+    } else if (type === "REASONING_MESSAGE_START") {
+      reasoningMessageOpen = true;
+      const evt: ReasoningMessageStartEvent = {
+        type: EventType.REASONING_MESSAGE_START,
+        messageId: reasoningMessageId,
+        role: "reasoning",
+      };
+      yield evt;
+    } else if (type === "REASONING_MESSAGE_CONTENT") {
+      const evt: ReasoningMessageContentEvent = {
+        type: EventType.REASONING_MESSAGE_CONTENT,
+        messageId: reasoningMessageId,
+        delta: raw.delta as string,
+      };
+      yield evt;
+    } else if (type === "REASONING_MESSAGE_END") {
+      reasoningMessageOpen = false;
+      const evt: ReasoningMessageEndEvent = {
+        type: EventType.REASONING_MESSAGE_END,
+        messageId: reasoningMessageId,
+      };
+      yield evt;
+    } else if (type === "REASONING_END") {
+      // If upstream sends REASONING_END while a message is still open, emit
+      // the missing REASONING_MESSAGE_END FIRST so the closing pair stays in
+      // order (MSG_END before END). Otherwise the next non-reasoning chunk
+      // would trigger closeReasoningIfOpen and emit MSG_END after END.
+      if (reasoningMessageOpen) {
+        reasoningMessageOpen = false;
+        const msgEnd: ReasoningMessageEndEvent = {
+          type: EventType.REASONING_MESSAGE_END,
+          messageId: reasoningMessageId,
+        };
+        yield msgEnd;
+      }
+      reasoningRunOpen = false;
+      const evt: ReasoningEndEvent = {
+        type: EventType.REASONING_END,
+        messageId: reasoningMessageId,
+      };
+      yield evt;
     }
-    // Unhandled chunk types are silently ignored.
-    // Known gaps: STATE_SNAPSHOT, STATE_DELTA, and REASONING events are not
-    // converted from TanStack streams. Shared state and reasoning will not
-    // surface when using the TanStack backend. Use the AI SDK backend if these
-    // features are required.
+  }
+
+  yield* closeReasoningIfOpen();
+}
+
+function safeParse(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
   }
 }

package/src/lib/runtime/agent-integrations/langgraph/agent.ts

@@ -154,7 +154,14 @@ export class LangGraphAgent extends AGUILangGraphAgent {
 
   // @ts-ignore
   run(input: RunAgentInput): Observable<BaseEvent> {
-    return super.run(input).pipe(
+    const enrichedInput = {
+      ...input,
+      forwardedProps: {
+        ...input.forwardedProps,
+        streamSubgraphs: input.forwardedProps?.streamSubgraphs ?? true,
+      },
+    };
+    return super.run(enrichedInput).pipe(
       map((processedEvent) => {
         // Turn raw event into emit state snapshot from tool call event
         if (processedEvent.type === EventType.RAW) {

package/src/v2/runtime/__tests__/express-fetch-bridge.test.ts

@@ -23,7 +23,7 @@ function createApp(
     app.use(express.json());
   }
 
-  app.all("*", (req, res) => nodeHandler(req, res));
+  app.all(/.*/, (req, res) => nodeHandler(req, res));
   return app;
 }
 

package/src/v2/runtime/__tests__/fetch-handler-validation.test.ts

@@ -370,3 +370,71 @@ describe("fetch-handler validation — multi-route edge cases", () => {
     expect(body.message).toBeUndefined();
   });
 });
+
+/* ------------------------------------------------------------------------------------------------
+ * Multi-route: HTTP method enforcement on per-thread GET endpoints
+ *
+ * /threads/:threadId/events and /threads/:threadId/state are read-only and
+ * must reject anything other than GET with 405 + Allow: GET. These tests
+ * pin that contract so a future refactor cannot quietly downgrade it.
+ * --------------------------------------------------------------------------------------------- */
+
+describe("fetch-handler validation — GET-only enforcement on threads read endpoints", () => {
+  const runtime = createRuntime();
+  const handler = createCopilotRuntimeHandler({
+    runtime,
+    basePath: "/api",
+  });
+
+  const expectMethodNotAllowed = async (
+    response: Response,
+    expectedAllow: string,
+  ) => {
+    expect(response.status).toBe(405);
+    expect(response.headers.get("Allow")).toBe(expectedAllow);
+  };
+
+  for (const method of ["POST", "PATCH", "DELETE"]) {
+    it(`returns 405 with Allow: GET for ${method} /threads/:id/events`, async () => {
+      const response = await handler(
+        new Request("http://localhost/api/threads/thread-1/events", {
+          method,
+          // PATCH/POST without a body or content-type would otherwise hit
+          // a different validation branch; this exercises pure method check.
+          headers: { "Content-Type": "application/json" },
+        }),
+      );
+      await expectMethodNotAllowed(response, "GET");
+    });
+
+    it(`returns 405 with Allow: GET for ${method} /threads/:id/state`, async () => {
+      const response = await handler(
+        new Request("http://localhost/api/threads/thread-1/state", {
+          method,
+          headers: { "Content-Type": "application/json" },
+        }),
+      );
+      await expectMethodNotAllowed(response, "GET");
+    });
+  }
+
+  it("accepts GET on /threads/:id/events", async () => {
+    const response = await handler(
+      new Request("http://localhost/api/threads/thread-1/events", {
+        method: "GET",
+      }),
+    );
+    // The route may 422 (no Intelligence configured) or 200 — either way it
+    // is NOT a 405, which is the contract we are pinning here.
+    expect(response.status).not.toBe(405);
+  });
+
+  it("accepts GET on /threads/:id/state", async () => {
+    const response = await handler(
+      new Request("http://localhost/api/threads/thread-1/state", {
+        method: "GET",
+      }),
+    );
+    expect(response.status).not.toBe(405);
+  });
+});

package/src/v2/runtime/__tests__/fetch-router.test.ts

@@ -90,6 +90,52 @@ describe("fetch-router", () => {
       });
     });
 
+    it("matches GET /threads/:threadId/events", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread-abc/events",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/events",
+        threadId: "thread-abc",
+      });
+    });
+
+    it("matches GET /threads/:threadId/events with URL-encoded threadId", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread%2F123/events",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/events",
+        threadId: "thread/123",
+      });
+    });
+
+    it("matches GET /threads/:threadId/state", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread-abc/state",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/state",
+        threadId: "thread-abc",
+      });
+    });
+
+    it("matches POST /threads/clear (and does not collide with threads/update)", () => {
+      // Critical: the threads/update route also matches /threads/:threadId,
+      // so we must verify that "/threads/clear" never falls through to that
+      // arm with threadId="clear". The router has explicit guards (the
+      // segment[len-1] !== "clear" check) — this test pins them.
+      const result = matchRoute("/api/copilotkit/threads/clear", basePath);
+      expect(result).toEqual({ method: "threads/clear" });
+      expect(result).not.toEqual({
+        method: "threads/update",
+        threadId: "clear",
+      });
+    });
+
     it("handles URL-encoded threadId in thread routes", () => {
       const result = matchRoute(
         "/api/copilotkit/threads/thread%2F123",

package/src/v2/runtime/__tests__/handle-run.test.ts

@@ -1,10 +1,17 @@
 import { Observable } from "rxjs";
 import { describe, it, expect, vi } from "vitest";
-import { AbstractAgent, BaseEvent, EventType, HttpAgent } from "@ag-ui/client";
+import {
+  AbstractAgent,
+  BaseEvent,
+  EventType,
+  HttpAgent,
+  RunAgentInput,
+} from "@ag-ui/client";
 import { A2UIMiddleware } from "@ag-ui/a2ui-middleware";
 import { handleRunAgent } from "../handlers/handle-run";
 import { CopilotRuntime } from "../core/runtime";
 import { IntelligenceAgentRunner } from "../runner/intelligence";
+import { InMemoryAgentRunner } from "../runner/in-memory";
 
 describe("handleRunAgent", () => {
   const createMockRuntime = (
@@ -1289,4 +1296,93 @@ describe("handleRunAgent", () => {
       }
     });
   });
+
+  describe("agentId tagging on cloned agents", () => {
+    /**
+     * Pins handle-run.ts:40 — `agent.agentId = agentId` is set on the clone
+     * BEFORE the agent reaches the runner. Without it, InMemoryAgentRunner
+     * falls back to "default" when stamping historic runs, and listThreads
+     * returns rows with the wrong agentId. This breaks the agentId filter
+     * in `GET /threads?agentId=...` for the local-dev fallback.
+     *
+     * This test runs the full flow through InMemoryAgentRunner with an
+     * AbstractAgent whose own `agentId` field is undefined (matches the
+     * shape after `clone()` returns a fresh instance), and asserts the
+     * runner records the registry key, NOT "default".
+     */
+    class TaggingTestAgent extends AbstractAgent {
+      async runAgent(
+        _input: RunAgentInput,
+        options: { onEvent: (event: { event: BaseEvent }) => void },
+      ): Promise<void> {
+        // Emit a single TEXT_MESSAGE_END event so the run produces at least
+        // one event and gets persisted to historicRuns. RUN_STARTED /
+        // RUN_FINISHED are appended by the runner itself.
+        options.onEvent({
+          event: {
+            type: EventType.TEXT_MESSAGE_END,
+            messageId: "msg-1",
+          } as BaseEvent,
+        });
+      }
+
+      clone(): AbstractAgent {
+        // The fresh clone has NO agentId — the only way the runner can know
+        // the registry key is if handle-run.ts:40 stamps it before the run.
+        return new TaggingTestAgent();
+      }
+    }
+
+    const createRunRequestForAgent = (agentId: string, threadId: string) =>
+      new Request(`https://example.com/agent/${agentId}/run`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          threadId,
+          runId: `run-${threadId}`,
+          state: {},
+          messages: [],
+          tools: [],
+          context: [],
+          forwardedProps: {},
+        }),
+      });
+
+    it("propagates the registry agentId onto historic runs (NOT 'default')", async () => {
+      const runner = new InMemoryAgentRunner();
+      const agent = new TaggingTestAgent();
+      const runtime = new CopilotRuntime({
+        agents: { tagged: agent },
+        runner,
+      });
+
+      // Use a unique threadId so this test does not collide with other
+      // tests that share the InMemoryAgentRunner GLOBAL_STORE.
+      const threadId = `thread-tagged-${Date.now()}-${Math.random()}`;
+
+      const response = await handleRunAgent({
+        runtime,
+        request: createRunRequestForAgent("tagged", threadId),
+        agentId: "tagged",
+      });
+      expect(response.status).toBe(200);
+
+      // Drain the SSE stream so the underlying observable run completes —
+      // historicRuns is only populated AFTER the run finalizes.
+      const reader = response.body!.getReader();
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+
+      const threads = runner.listThreads();
+      const thisThread = threads.find((t) => t.id === threadId);
+      expect(thisThread).toBeDefined();
+      expect(thisThread!.agentId).toBe("tagged");
+      // Negative assertion locks the regression: a future change that drops
+      // the `agent.agentId = agentId` line in handle-run will surface as
+      // "default" here, not as a missing thread.
+      expect(thisThread!.agentId).not.toBe("default");
+    });
+  });
 });