@copilotkit/runtime 1.55.3 → 1.56.1

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

@@ -110,10 +110,14 @@ describe("MCP Tools Utils", () => {
       });
       expect(result[1]).toEqual({
         name: "objectArray",
-        type: "array",
+        type: "object[]",
         description:
           "Array of objects Array of objects with properties: name, value",
         required: false,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "value", type: "number", description: "", required: false },
+        ],
       });
     });
 
@@ -147,6 +151,7 @@ describe("MCP Tools Utils", () => {
         type: "string",
         description: "Status value Allowed values: active | inactive | pending",
         required: true,
+        enum: ["active", "inactive", "pending"],
       });
       expect(result[1]).toEqual({
         name: "priority",
@@ -192,6 +197,30 @@ describe("MCP Tools Utils", () => {
         description:
           "User object Object with properties: name, email, preferences",
         required: true,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "email", type: "string", description: "", required: false },
+          {
+            name: "preferences",
+            type: "object",
+            description: "Object with properties: theme, notifications",
+            required: false,
+            attributes: [
+              {
+                name: "theme",
+                type: "string",
+                description: "",
+                required: false,
+              },
+              {
+                name: "notifications",
+                type: "boolean",
+                description: "",
+                required: false,
+              },
+            ],
+          },
+        ],
       });
     });
 

package/src/lib/runtime/__tests__/on-after-request.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from "vitest";
+import { CopilotRuntime } from "../copilot-runtime";
+
+describe("onAfterRequest middleware (#2124)", () => {
+  it("should pass hookParams to onAfterRequest, not an empty object", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    // Access the internal afterRequestMiddleware function
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+    expect(afterRequestMw).toBeDefined();
+
+    // Simulate calling the middleware with hookParams (as the v2 runtime would)
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [
+        { id: "msg-1", role: "user", content: "Hi there" },
+        { id: "msg-2", role: "assistant", content: "Hello" },
+        { id: "msg-3", role: "tool", content: "result", toolCallId: "tc-1" },
+      ],
+      threadId: "thread-123",
+      runId: "run-456",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+
+    // Should NOT be called with an empty object
+    expect(callArg).not.toEqual({});
+
+    // Verify all OnAfterRequestOptions fields are present
+    expect(callArg).toHaveProperty("threadId", "thread-123");
+    expect(callArg).toHaveProperty("runId", "run-456");
+    expect(callArg).toHaveProperty("url", "/api/copilotkit");
+    expect(callArg).toHaveProperty("properties");
+    expect(callArg.properties).toEqual({});
+
+    // Verify message splitting: user messages → inputMessages, others → outputMessages
+    expect(callArg.inputMessages).toHaveLength(1);
+    expect(callArg.inputMessages[0]).toMatchObject({
+      id: "msg-1",
+      role: "user",
+    });
+
+    expect(callArg.outputMessages).toHaveLength(2);
+    expect(callArg.outputMessages[0]).toMatchObject({
+      id: "msg-2",
+      role: "assistant",
+    });
+    expect(callArg.outputMessages[1]).toMatchObject({
+      id: "msg-3",
+      role: "tool",
+    });
+  });
+
+  it("should handle undefined messages gracefully", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      // messages intentionally omitted (undefined)
+      threadId: "thread-789",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("thread-789");
+    expect(callArg.inputMessages).toEqual([]);
+    expect(callArg.outputMessages).toEqual([]);
+  });
+
+  it("should default threadId to empty string when undefined", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [],
+      // threadId intentionally omitted
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("");
+    expect(callArg.runId).toBeUndefined();
+  });
+});

package/src/lib/runtime/__tests__/v1-agent-factory.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi } from "vitest";
+import { HttpAgent } from "@ag-ui/client";
+import { CopilotRuntime } from "../copilot-runtime";
+import {
+  resolveAgents,
+  type AgentsConfig,
+} from "../../../v2/runtime/core/runtime";
+
+function createMockAgent(name = "test") {
+  return new HttpAgent({ url: `https://example.com/${name}` });
+}
+
+function createMockRequest(headers?: Record<string, string>) {
+  return new Request("https://example.com/agent/test/run", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify({ threadId: "thread-1", messages: [], state: {} }),
+  });
+}
+
+describe("V1 CopilotRuntime with agent factory function", () => {
+  it("preserves factory function through constructor (does not spread to {})", () => {
+    const factory = vi.fn().mockReturnValue({
+      default: createMockAgent("default"),
+    });
+
+    const runtime = new CopilotRuntime({ agents: factory });
+
+    // The V2 instance should receive a function (factory), not an empty object.
+    // Before the fix, spreading a function produced {}, losing all agents.
+    const v2Agents = runtime.instance.agents;
+    expect(typeof v2Agents).toBe("function");
+  });
+
+  it("factory function resolves agents on each request", async () => {
+    const agentA = createMockAgent("tenant-a");
+    const agentB = createMockAgent("tenant-b");
+
+    const factory: AgentsConfig = ({ request }) => {
+      const tenantId = request.headers.get("x-tenant-id");
+      if (tenantId === "a") return { default: agentA };
+      return { default: agentB };
+    };
+
+    const runtime = new CopilotRuntime({ agents: factory });
+    const v2Agents = runtime.instance.agents;
+
+    const requestA = createMockRequest({ "x-tenant-id": "a" });
+    const resolvedA = await resolveAgents(v2Agents, requestA);
+    expect(resolvedA.default).toBe(agentA);
+
+    const requestB = createMockRequest({ "x-tenant-id": "b" });
+    const resolvedB = await resolveAgents(v2Agents, requestB);
+    expect(resolvedB.default).toBe(agentB);
+  });
+
+  it("merges endpoint agents with factory-resolved agents", async () => {
+    const factoryAgent = createMockAgent("factory-agent");
+    const factory = vi.fn().mockReturnValue({
+      dynamic: factoryAgent,
+    });
+
+    // Use remoteEndpoints to generate endpoint agents that should be merged
+    const runtime = new CopilotRuntime({
+      agents: factory,
+      remoteEndpoints: [
+        {
+          url: "https://example.com/endpoint",
+          onBeforeRequest: undefined,
+        },
+      ],
+    });
+
+    const v2Agents = runtime.instance.agents;
+    expect(typeof v2Agents).toBe("function");
+
+    const request = createMockRequest();
+    const resolved = await resolveAgents(v2Agents, request);
+
+    // Factory agent should be present
+    expect(resolved.dynamic).toBe(factoryAgent);
+    // Factory should have been called with request context
+    expect(factory).toHaveBeenCalledWith({ request });
+  });
+
+  it("static agents record still works after fix", async () => {
+    const agent = createMockAgent("static");
+
+    const runtime = new CopilotRuntime({
+      agents: { myAgent: agent },
+    });
+
+    const v2Agents = runtime.instance.agents;
+    const resolved = await resolveAgents(v2Agents);
+    expect(resolved.myAgent).toBe(agent);
+  });
+
+  it("promised agents record still works after fix", async () => {
+    const agent = createMockAgent("promised");
+
+    const runtime = new CopilotRuntime({
+      agents: Promise.resolve({ myAgent: agent }),
+    });
+
+    const v2Agents = runtime.instance.agents;
+    const resolved = await resolveAgents(v2Agents);
+    expect(resolved.myAgent).toBe(agent);
+  });
+});

package/src/lib/runtime/copilot-runtime.ts

@@ -23,6 +23,7 @@ import {
   getZodParameters,
   type PartialBy,
   isTelemetryDisabled,
+  type DebugConfig,
 } from "@copilotkit/shared";
 import type { RunAgentInput } from "@ag-ui/core";
 import { aguiToGQL } from "../../graphql/message-conversion/agui-to-gql";
@@ -35,8 +36,13 @@ import {
   type CopilotRuntimeOptions,
   type CopilotRuntimeOptions as CopilotRuntimeOptionsVNext,
   type AgentRunner,
+  type AgentsConfig,
+  type AgentsFactory,
+  type AgentFactoryContext,
   InMemoryAgentRunner,
 } from "../../v2/runtime";
+
+export type { AgentsConfig, AgentsFactory, AgentFactoryContext };
 import { TelemetryAgentRunner } from "./telemetry-agent-runner";
 import telemetry from "../telemetry-client";
 
@@ -287,6 +293,19 @@ export interface CopilotRuntimeConstructorParams_BASE<
 
   onStopGeneration?: OnStopGenerationHandler;
 
+  /**
+   * Enable debug logging for the runtime event pipeline.
+   * Pass `true` for full output, or an object for granular control:
+   *
+   * ```ts
+   * const runtime = new CopilotRuntime({
+   *   debug: true,
+   *   // or: debug: { events: true, lifecycle: true, verbose: false }
+   * });
+   * ```
+   */
+  debug?: DebugConfig;
+
   // /** Optional transcription service for audio processing. */
   // transcriptionService?: CopilotRuntimeOptionsVNext["transcriptionService"];
   // /** Optional *before* middleware – callback function or webhook URL. */
@@ -318,7 +337,7 @@ interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []>
    *  – the `MaybePromise<NonEmptyRecord<T>>` constraint in `CopilotRuntimeOptionsVNext`
    *  – the `Record<string, AbstractAgent>` constraint in `both
    */
-  agents?: MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>>;
+  agents?: AgentsConfig;
 }
 
 /**
@@ -342,6 +361,22 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       params?.remoteEndpoints ?? [],
     );
 
+    // Merge endpoint agents with user-provided agents.
+    // When agents is a factory function, wrap it so endpoint agents are merged
+    // at resolution time (spreading a function produces {} — silent data loss).
+    let mergedAgents: AgentsConfig;
+    if (typeof agents === "function") {
+      mergedAgents = async (ctx) => {
+        const resolved = await agents(ctx);
+        return { ...endpointAgents, ...resolved };
+      };
+    } else {
+      mergedAgents = Promise.resolve(agents).then((resolved) => ({
+        ...endpointAgents,
+        ...resolved,
+      }));
+    }
+
     // Determine the base runner (user-provided or default)
     const baseRunner = params?.runner ?? new InMemoryAgentRunner();
 
@@ -353,9 +388,10 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       : new TelemetryAgentRunner({ runner: baseRunner });
 
     this.runtimeArgs = {
-      agents: { ...endpointAgents, ...agents },
+      agents: mergedAgents,
       runner,
       licenseToken: params?.licenseToken,
+      debug: params?.debug,
       // TODO: add support for transcriptionService from CopilotRuntimeOptionsVNext once it is ready
       // transcriptionService: params?.transcriptionService,
 
@@ -590,9 +626,22 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       params?.afterRequestMiddleware?.(hookParams);
 
       if (params?.middleware?.onAfterRequest) {
-        // TODO: provide old expected params here when available
-        // @ts-expect-error -- missing arguments.
-        params.middleware.onAfterRequest({});
+        const messages = hookParams.messages ?? [];
+        params.middleware.onAfterRequest({
+          threadId: hookParams.threadId ?? "",
+          runId: hookParams.runId,
+          inputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role === "user",
+          ) as unknown as Message[],
+          outputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role !== "user",
+          ) as unknown as Message[],
+          // TODO: forward actual properties once the after-request hook has access to the request body
+          properties: {},
+          url: hookParams.path,
+        } satisfies OnAfterRequestOptions);
       }
     };
   }

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/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 });
           }
         }