@copilotkit/runtime 1.56.0 → 1.56.2-canary.pin-to-send

package/src/lib/runtime/mcp-tools-utils.ts

@@ -85,30 +85,65 @@ export function extractParametersFromSchema(
         }
       }
 
-      // Handle enums
+      // Handle enums — preserve as structured data for Zod conversion
+      let enumValues: string[] | undefined;
       if (paramDef.enum && Array.isArray(paramDef.enum)) {
-        const enumValues = paramDef.enum.join(" | ");
+        enumValues = paramDef.enum.map(String);
+        const enumDisplay = enumValues.join(" | ");
         description =
           description +
           (description ? " " : "") +
-          `Allowed values: ${enumValues}`;
+          `Allowed values: ${enumDisplay}`;
       }
 
-      // Handle objects with properties
+      // Handle objects with properties — recurse to preserve nested structure
+      let attributes: Parameter[] | undefined;
       if (type === "object" && paramDef.properties) {
         const objectProperties = Object.keys(paramDef.properties).join(", ");
         description =
           description +
           (description ? " " : "") +
           `Object with properties: ${objectProperties}`;
+        // Recursively extract nested parameters
+        attributes = extractParametersFromSchema({
+          parameters: {
+            properties: paramDef.properties,
+            required: paramDef.required || [],
+          },
+        });
       }
 
-      parameters.push({
+      // Handle object arrays — recurse into item schema
+      if (type === "array" && paramDef.items?.type === "object" && paramDef.items?.properties) {
+        attributes = extractParametersFromSchema({
+          parameters: {
+            properties: paramDef.items.properties,
+            required: paramDef.items.required || [],
+          },
+        });
+      }
+
+      const param: any = {
         name: paramName,
         type: type,
         description: description,
         required: requiredParams.has(paramName),
-      });
+      };
+
+      // Preserve enum values for string parameters
+      if (type === "string" && enumValues) {
+        param.enum = enumValues;
+      }
+
+      // Preserve nested attributes for object and object[] types
+      if (attributes && attributes.length > 0) {
+        param.attributes = attributes;
+        if (type === "array") {
+          param.type = "object[]";
+        }
+      }
+
+      parameters.push(param);
     }
   }
 

package/src/lib/runtime/retry-utils.ts

@@ -7,6 +7,8 @@ export const RETRY_CONFIG = {
   maxDelayMs: 5000,
   // HTTP status codes that should be retried
   retryableStatusCodes: [502, 503, 504, 408, 429],
+  // Maximum Retry-After value (in seconds) we're willing to honor
+  maxRetryAfterSeconds: 60,
   // Network error patterns that should be retried
   retryableErrorMessages: [
     "fetch failed",
@@ -44,6 +46,28 @@ export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// Parse the Retry-After header value into milliseconds.
+// Returns undefined if the header is missing or unparseable.
+export function parseRetryAfter(response: Response): number | undefined {
+  const retryAfter = response.headers.get("Retry-After");
+  if (!retryAfter) return undefined;
+
+  // Try as seconds (integer)
+  const seconds = Number(retryAfter);
+  if (!Number.isNaN(seconds) && seconds >= 0) {
+    return seconds * 1000;
+  }
+
+  // Try as HTTP-date
+  const date = Date.parse(retryAfter);
+  if (!Number.isNaN(date)) {
+    const delayMs = date - Date.now();
+    return delayMs > 0 ? delayMs : 0;
+  }
+
+  return undefined;
+}
+
 // Calculate exponential backoff delay
 export function calculateDelay(attempt: number): number {
   const delay = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt);
@@ -67,7 +91,23 @@ export async function fetchWithRetry(
         isRetryableError(null, response) &&
         attempt < RETRY_CONFIG.maxRetries
       ) {
-        const delay = calculateDelay(attempt);
+        let delay = calculateDelay(attempt);
+
+        // Honor Retry-After header on 429 responses
+        if (response.status === 429) {
+          const retryAfterMs = parseRetryAfter(response);
+          if (retryAfterMs !== undefined) {
+            const maxMs = RETRY_CONFIG.maxRetryAfterSeconds * 1000;
+            if (retryAfterMs > maxMs) {
+              throw new Error(
+                `Server requested Retry-After of ${Math.ceil(retryAfterMs / 1000)}s ` +
+                  `which exceeds the maximum of ${RETRY_CONFIG.maxRetryAfterSeconds}s`,
+              );
+            }
+            delay = retryAfterMs;
+          }
+        }
+
         logger?.warn(
           `Request to ${url} failed with status ${response.status}. ` +
             `Retrying attempt ${attempt + 1}/${RETRY_CONFIG.maxRetries + 1} in ${delay}ms.`,

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -70,12 +70,19 @@ export interface AnthropicAdapterParams {
    * See: https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
    */
   promptCaching?: AnthropicPromptCachingConfig;
+
+  /**
+   * Optional maximum input token limit. Overrides the default limit
+   * used when trimming messages to fit the context window.
+   */
+  maxInputTokens?: number;
 }
 
 export class AnthropicAdapter implements CopilotServiceAdapter {
   public model: string = DEFAULT_MODEL;
   public provider = "anthropic";
   private promptCaching: AnthropicPromptCachingConfig;
+  private maxInputTokens?: number;
 
   private _anthropic: Anthropic;
   public get anthropic(): Anthropic {
@@ -94,6 +101,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
       this.model = params.model;
     }
     this.promptCaching = params?.promptCaching || { enabled: false };
+    this.maxInputTokens = params?.maxInputTokens;
   }
 
   getLanguageModel(): LanguageModel {
@@ -244,6 +252,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
       forwardedParameters,
     } = request;
     const tools = actions.map(convertActionInputToAnthropicTool);
+    const knownActionNames = new Set(actions.map((a) => a.name));
 
     const messages = [...rawMessages];
 
@@ -322,6 +331,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
       anthropicMessages,
       tools,
       model,
+      this.maxInputTokens,
     );
 
     // Apply prompt caching if enabled
@@ -350,7 +360,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
         system: cachedSystemPrompt,
         model: this.model,
         messages: cachedMessages,
-        max_tokens: forwardedParameters?.maxTokens || 1024,
+        max_tokens: forwardedParameters?.maxTokens || 4096,
         ...(forwardedParameters?.temperature
           ? { temperature: forwardedParameters.temperature }
           : {}),
@@ -375,12 +385,18 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             if (chunk.type === "message_start") {
               currentMessageId = chunk.message.id;
             } else if (chunk.type === "content_block_start") {
-              hasReceivedContent = true;
               if (chunk.content_block.type === "text") {
+                hasReceivedContent = true;
                 didOutputText = false;
                 filterThinkingTextBuffer.reset();
                 mode = "message";
               } else if (chunk.content_block.type === "tool_use") {
+                if (!knownActionNames.has(chunk.content_block.name)) {
+                  // Unknown tool - skip execution to prevent crashes
+                  mode = null;
+                  continue;
+                }
+                hasReceivedContent = true;
                 currentToolCallId = chunk.content_block.id;
                 eventStream$.sendActionExecutionStart({
                   actionExecutionId: currentToolCallId,
@@ -390,6 +406,10 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
                 mode = "function";
               }
             } else if (chunk.type === "content_block_delta") {
+              if (mode === null) {
+                // Skip deltas for unknown/skipped content blocks
+                continue;
+              }
               if (chunk.delta.type === "text_delta") {
                 const text = filterThinkingTextBuffer.onTextChunk(
                   chunk.delta.text,

package/src/service-adapters/anthropic/utils.ts

@@ -49,7 +49,66 @@ export function limitMessagesToTokenCount(
     maxTokens -= numTokens;
   }
 
-  return result;
+  // Post-process: remove orphaned tool_result and tool_use blocks.
+  // Token trimming may have removed the assistant message containing tool_use
+  // while keeping the user message with tool_result (or vice versa),
+  // which Anthropic rejects.
+
+  // Collect all tool_use IDs from assistant messages
+  const toolUseIds = new Set<string>();
+  for (const msg of result) {
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          toolUseIds.add(block.id);
+        }
+      }
+    }
+  }
+
+  // Collect all tool_result IDs from user messages
+  const toolResultIds = new Set<string>();
+  for (const msg of result) {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          toolResultIds.add(block.tool_use_id);
+        }
+      }
+    }
+  }
+
+  // Filter orphaned blocks without mutating the original messages
+  const filtered: any[] = [];
+  for (const msg of result) {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      const remaining = msg.content.filter(
+        (block: any) =>
+          block.type !== "tool_result" || toolUseIds.has(block.tool_use_id),
+      );
+      if (remaining.length === 0) continue;
+      if (remaining.length !== msg.content.length) {
+        filtered.push({ ...msg, content: remaining });
+      } else {
+        filtered.push(msg);
+      }
+    } else if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      const remaining = msg.content.filter(
+        (block: any) =>
+          block.type !== "tool_use" || toolResultIds.has(block.id),
+      );
+      if (remaining.length === 0) continue;
+      if (remaining.length !== msg.content.length) {
+        filtered.push({ ...msg, content: remaining });
+      } else {
+        filtered.push(msg);
+      }
+    } else {
+      filtered.push(msg);
+    }
+  }
+
+  return filtered;
 }
 
 const MAX_TOKENS = 128000;

package/src/service-adapters/langchain/utils.ts

@@ -269,7 +269,7 @@ export async function streamLangChainResponse({
             });
           } else if (content) {
             mode = "message";
-            currentMessageId = value.lc_kwargs?.id || randomId();
+            currentMessageId = randomId();
             eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }

package/src/service-adapters/openai/openai-adapter.ts

@@ -97,6 +97,12 @@ export interface OpenAIAdapterParams {
    * @default false
    */
   keepSystemRole?: boolean;
+
+  /**
+   * Optional maximum input token limit. Overrides the default model-based limit
+   * used when trimming messages to fit the context window.
+   */
+  maxInputTokens?: number;
 }
 
 export class OpenAIAdapter implements CopilotServiceAdapter {
@@ -106,6 +112,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
   private disableParallelToolCalls: boolean = false;
   private _openai: OpenAI;
   private keepSystemRole: boolean = false;
+  private maxInputTokens?: number;
 
   public get openai(): OpenAI {
     return this._openai;
@@ -125,6 +132,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     }
     this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
     this.keepSystemRole = params?.keepSystemRole ?? false;
+    this.maxInputTokens = params?.maxInputTokens;
   }
 
   getLanguageModel(): LanguageModel {
@@ -192,7 +200,12 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     let openaiMessages = filteredMessages.map((m) =>
       convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }),
     );
-    openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
+    openaiMessages = limitMessagesToTokenCount(
+      openaiMessages,
+      tools,
+      model,
+      this.maxInputTokens,
+    );
 
     let toolChoice: any = forwardedParameters?.toolChoice;
     if (forwardedParameters?.toolChoice === "function") {

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

@@ -135,6 +135,11 @@ describe("fetch-router", () => {
       const result = matchRoute("/info", "/");
       expect(result).toEqual({ method: "info" });
     });
+
+    it("matches GET /cpk-debug-events", () => {
+      const result = matchRoute("/api/copilotkit/cpk-debug-events", basePath);
+      expect(result).toEqual({ method: "cpk-debug-events" });
+    });
   });
 
   describe("without basePath (suffix matching)", () => {
@@ -204,5 +209,22 @@ describe("fetch-router", () => {
       const result = matchRoute("/api/v2/copilotkit/agent/a1/run");
       expect(result).toEqual({ method: "agent/run", agentId: "a1" });
     });
+
+    it("matches /cpk-debug-events suffix", () => {
+      const result = matchRoute("/api/copilotkit/cpk-debug-events");
+      expect(result).toEqual({ method: "cpk-debug-events" });
+    });
+
+    it("matches bare /cpk-debug-events", () => {
+      const result = matchRoute("/cpk-debug-events");
+      expect(result).toEqual({ method: "cpk-debug-events" });
+    });
+  });
+
+  describe("cpk-debug-events route with basePath", () => {
+    it("matches /cpk-debug-events with /api basePath", () => {
+      const result = matchRoute("/api/cpk-debug-events", "/api");
+      expect(result).toEqual({ method: "cpk-debug-events" });
+    });
   });
 });

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

@@ -228,7 +228,9 @@ describe("handleConnectAgent", () => {
         afterRequestMiddleware: undefined,
         runner,
         mode: "intelligence",
-        identifyUser: vi.fn().mockResolvedValue({ id: "user-1" }),
+        identifyUser: vi
+          .fn()
+          .mockResolvedValue({ id: "user-1", name: "User One" }),
         intelligence: platform,
       } as unknown as CopilotRuntime;
     };
@@ -262,6 +264,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
+        runId: "run-1",
         lastSeenEventId: null,
       });
     });
@@ -271,7 +274,15 @@ describe("handleConnectAgent", () => {
         ɵconnectThread: vi.fn().mockResolvedValue({
           mode: "bootstrap",
           latestEventId: "event-2",
-          events: [{ type: "MESSAGES_SNAPSHOT", messages: [] }],
+          events: [
+            {
+              type: "RUN_STARTED",
+              threadId: "thread-1",
+              run_id: "backend-run-1",
+              input: { messages: [] },
+            },
+            { type: "RUN_FINISHED" },
+          ],
         }),
       };
       const runtime = createIntelligenceRuntime(platform);
@@ -287,7 +298,23 @@ describe("handleConnectAgent", () => {
       expect(body).toEqual({
         mode: "bootstrap",
         latestEventId: "event-2",
-        events: [{ type: "MESSAGES_SNAPSHOT", messages: [] }],
+        events: [
+          {
+            type: "RUN_STARTED",
+            threadId: "thread-1",
+            runId: "run-1",
+            input: {
+              messages: [],
+              threadId: "thread-1",
+              runId: "run-1",
+            },
+          },
+          {
+            type: "RUN_FINISHED",
+            threadId: "thread-1",
+            runId: "run-1",
+          },
+        ],
       });
     });
 
@@ -310,6 +337,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
+        runId: "run-1",
         lastSeenEventId: null,
       });
     });
@@ -349,6 +377,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
+        runId: "run-1",
         lastSeenEventId: "event-9",
       });
     });
@@ -357,7 +386,9 @@ describe("handleConnectAgent", () => {
       const platform = {
         ɵconnectThread: vi.fn().mockResolvedValue(null),
       };
-      const identifyUser = vi.fn().mockResolvedValue({ id: "resolved-user" });
+      const identifyUser = vi
+        .fn()
+        .mockResolvedValue({ id: "resolved-user", name: "Resolved User" });
       const runtime = createIntelligenceRuntime(platform);
       runtime.identifyUser = identifyUser;
       const request = createConnectRequest(
@@ -377,6 +408,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "resolved-user",
+        runId: "run-1",
         lastSeenEventId: "event-9",
       });
     });
@@ -386,7 +418,28 @@ describe("handleConnectAgent", () => {
         ɵconnectThread: vi.fn(),
       };
       const runtime = createIntelligenceRuntime(platform);
-      runtime.identifyUser = vi.fn().mockResolvedValue({ id: "" });
+      runtime.identifyUser = vi
+        .fn()
+        .mockResolvedValue({ id: "", name: "User" });
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(400);
+      expect(platform.ɵconnectThread).not.toHaveBeenCalled();
+    });
+
+    it("returns 400 when identifyUser returns an invalid name", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn(),
+      };
+      const runtime = createIntelligenceRuntime(platform);
+      runtime.identifyUser = vi
+        .fn()
+        .mockResolvedValue({ id: "user-1", name: "" });
 
       const response = await handleConnectAgent({
         runtime,

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

@@ -298,7 +298,9 @@ describe("handleRunAgent", () => {
         generateThreadNames?: boolean;
         identifyUser?: (
           request: Request,
-        ) => { id: string } | Promise<{ id: string }>;
+        ) =>
+          | { id: string; name: string }
+          | Promise<{ id: string; name: string }>;
       },
     ) => {
       const runner = Object.create(IntelligenceAgentRunner.prototype);
@@ -318,7 +320,8 @@ describe("handleRunAgent", () => {
         generateThreadNames: options?.generateThreadNames ?? false,
         intelligence: platform,
         identifyUser:
-          options?.identifyUser ?? vi.fn().mockResolvedValue({ id: "user-1" }),
+          options?.identifyUser ??
+          vi.fn().mockResolvedValue({ id: "user-1", name: "User One" }),
       } as unknown as CopilotRuntime;
     };
 
@@ -395,7 +398,9 @@ describe("handleRunAgent", () => {
           .fn()
           .mockResolvedValue({ joinToken: "jt-123", joinCode: "jc-123" }),
       };
-      const identifyUser = vi.fn().mockResolvedValue({ id: "resolved-user" });
+      const identifyUser = vi
+        .fn()
+        .mockResolvedValue({ id: "resolved-user", name: "Resolved User" });
       const runtime = createIntelligenceRuntime(agent, platform, {
         identifyUser,
       });
@@ -870,7 +875,29 @@ describe("handleRunAgent", () => {
         ɵacquireThreadLock: vi.fn(),
       };
       const runtime = createIntelligenceRuntime(agent, platform, {
-        identifyUser: vi.fn().mockResolvedValue({ id: "" }),
+        identifyUser: vi.fn().mockResolvedValue({ id: "", name: "User" }),
+      });
+
+      const response = await handleRunAgent({
+        runtime,
+        request: createRunRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(400);
+      expect(platform.getOrCreateThread).not.toHaveBeenCalled();
+      expect(platform.ɵacquireThreadLock).not.toHaveBeenCalled();
+    });
+
+    it("returns 400 when identifyUser returns an invalid name", async () => {
+      const agent = createAgentForIntelligence();
+      const platform = {
+        getOrCreateThread: vi.fn(),
+        getThreadMessages: vi.fn(),
+        ɵacquireThreadLock: vi.fn(),
+      };
+      const runtime = createIntelligenceRuntime(agent, platform, {
+        identifyUser: vi.fn().mockResolvedValue({ id: "user-1", name: "" }),
       });
 
       const response = await handleRunAgent({

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

@@ -10,12 +10,13 @@ import {
 import { CopilotRuntime } from "../core/runtime";
 
 describe("thread handlers", () => {
-  const createIdentifyUser = () => vi.fn().mockResolvedValue({ id: "user-1" });
+  const createIdentifyUser = () =>
+    vi.fn().mockResolvedValue({ id: "user-1", name: "User One" });
 
   const createIntelligenceRuntime = (options?: {
     identifyUser?: (
       request: Request,
-    ) => { id: string } | Promise<{ id: string }>;
+    ) => { id: string; name: string } | Promise<{ id: string; name: string }>;
     intelligence?: Record<string, unknown>;
   }) =>
     ({
@@ -92,7 +93,25 @@ describe("thread handlers", () => {
     };
     const runtime = createIntelligenceRuntime({
       intelligence,
-      identifyUser: vi.fn().mockResolvedValue({ id: "" }),
+      identifyUser: vi.fn().mockResolvedValue({ id: "", name: "User" }),
+    });
+
+    const response = await handleListThreads({
+      runtime,
+      request: new Request("https://example.com/threads?agentId=agent-1"),
+    });
+
+    expect(response.status).toBe(400);
+    expect(intelligence.listThreads).not.toHaveBeenCalled();
+  });
+
+  it("returns 400 when identifyUser returns an invalid name for thread list", async () => {
+    const intelligence = {
+      listThreads: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({
+      intelligence,
+      identifyUser: vi.fn().mockResolvedValue({ id: "user-1", name: "" }),
     });
 
     const response = await handleListThreads({
@@ -258,7 +277,50 @@ describe("thread handlers", () => {
     };
     const runtime = createIntelligenceRuntime({
       intelligence,
-      identifyUser: vi.fn().mockResolvedValue({ id: "" }),
+      identifyUser: vi.fn().mockResolvedValue({ id: "", name: "User" }),
+    });
+
+    const updateResponse = await handleUpdateThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1", "PATCH", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(updateResponse.status).toBe(400);
+
+    const archiveResponse = await handleArchiveThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1/archive", "POST", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(archiveResponse.status).toBe(400);
+
+    const deleteResponse = await handleDeleteThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1", "DELETE", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(deleteResponse.status).toBe(400);
+
+    expect(intelligence.updateThread).not.toHaveBeenCalled();
+    expect(intelligence.archiveThread).not.toHaveBeenCalled();
+    expect(intelligence.deleteThread).not.toHaveBeenCalled();
+  });
+
+  it("returns 400 when identifyUser returns an invalid name for thread mutations", async () => {
+    const intelligence = {
+      updateThread: vi.fn(),
+      archiveThread: vi.fn(),
+      deleteThread: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({
+      intelligence,
+      identifyUser: vi.fn().mockResolvedValue({ id: "user-1", name: "" }),
     });
 
     const updateResponse = await handleUpdateThread({

package/src/v2/runtime/__tests__/integration/node-servers.integration.test.ts

@@ -10,6 +10,10 @@
 
 import { multiEndpointSuite } from "./suites/multi-endpoint.suite";
 import { singleEndpointSuite } from "./suites/single-endpoint.suite";
+import {
+  debugEventsSuite,
+  debugEventsProductionGuardSuite,
+} from "./suites/debug-events.suite";
 
 // Server factories
 import { createExpressMultiServer } from "./servers/express-multi";
@@ -37,3 +41,18 @@ singleEndpointSuite("Node", createNodeSingleServer);
 singleEndpointSuite("Fetch", (opts) =>
   Promise.resolve(createFetchDirectHandler("single-route", opts)),
 );
+
+// ─── Debug Events ───────────────────────────────────────────────────
+
+debugEventsSuite("Express", createExpressMultiServer);
+debugEventsSuite("Hono", createHonoMultiServer);
+debugEventsSuite("Node", createNodeMultiServer);
+debugEventsSuite("Fetch", (opts) =>
+  Promise.resolve(createFetchDirectHandler("multi-route", opts)),
+);
+
+debugEventsProductionGuardSuite(
+  () => createFetchDirectHandler("multi-route"),
+  "http://localhost",
+  "/api/copilotkit",
+);