@copilotkit/runtime 1.56.0 → 1.56.2

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__/middleware-sse-parser.test.ts

@@ -83,6 +83,56 @@ describe("parseSSEResponse", () => {
     });
   });
 
+  it("normalizes array content in TOOL_CALL_RESULT (MCP adapters)", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      {
+        type: "TOOL_CALL_RESULT",
+        toolCallId: "tc-1",
+        messageId: "m-result",
+        role: "tool",
+        content: [
+          { type: "text", text: '{"metric":"cpu","value":42}' },
+          { type: "text", text: " extra info" },
+        ],
+      },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toContainEqual({
+      id: "m-result",
+      role: "tool",
+      content: '{"metric":"cpu","value":42} extra info',
+      toolCallId: "tc-1",
+    });
+  });
+
+  it("filters non-text parts when normalizing array content in TOOL_CALL_RESULT", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      {
+        type: "TOOL_CALL_RESULT",
+        toolCallId: "tc-1",
+        messageId: "m-result",
+        role: "tool",
+        content: [
+          { type: "text", text: "valid" },
+          { type: "image", data: "binary" },
+          null,
+          { type: "text", text: " part" },
+        ],
+      },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toContainEqual({
+      id: "m-result",
+      role: "tool",
+      content: "valid part",
+      toolCallId: "tc-1",
+    });
+  });
+
   it("uses MESSAGES_SNAPSHOT when present", async () => {
     const snapshotMessages = [
       { id: "u-1", role: "user", content: "hi" },

package/src/v2/runtime/core/middleware-sse-parser.ts

@@ -167,14 +167,24 @@ export async function parseSSEResponse(
         break;
       }
 
-      case "TOOL_CALL_RESULT":
+      case "TOOL_CALL_RESULT": {
+        // langchain-mcp-adapters may send content as an array of
+        // {type:"text", text:string} objects instead of a plain string.
+        let resultContent = event.content;
+        if (Array.isArray(resultContent)) {
+          resultContent = resultContent
+            .filter((part: any) => part && typeof part.text === "string")
+            .map((part: any) => part.text)
+            .join("");
+        }
         messagesById.set(event.messageId, {
           id: event.messageId,
           role: "tool",
-          content: event.content,
+          content: resultContent,
           toolCallId: event.toolCallId,
         });
         break;
+      }
     }
   }
 

package/tests/service-adapters/anthropic/anthropic-adapter.test.ts

@@ -374,4 +374,272 @@ describe("AnthropicAdapter", () => {
       });
     });
   });
+
+  describe("Unknown Tool Use Handling", () => {
+    it("should skip unknown tool_use blocks without crashing", async () => {
+      const systemMessage = new TextMessage("system", "System message");
+      const userMessage = new TextMessage("user", "Do something");
+
+      // Mock Anthropic to return a stream with an unknown tool_use block
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          yield { type: "message_start", message: { id: "msg-1" } };
+          // Unknown tool_use block — tool name not in the actions list
+          yield {
+            type: "content_block_start",
+            content_block: {
+              type: "tool_use",
+              id: "tool-unknown",
+              name: "nonexistent_tool",
+            },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: '{"query":' },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: '"test"}' },
+          };
+          yield { type: "content_block_stop" };
+          // Then a normal text block
+          yield {
+            type: "content_block_start",
+            content_block: { type: "text" },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "text_delta", text: "Here is the result." },
+          };
+          yield { type: "content_block_stop" };
+        },
+      });
+
+      const mockStream = {
+        sendTextMessageStart: vi.fn(),
+        sendTextMessageContent: vi.fn(),
+        sendTextMessageEnd: vi.fn(),
+        sendActionExecutionStart: vi.fn(),
+        sendActionExecutionArgs: vi.fn(),
+        sendActionExecutionEnd: vi.fn(),
+        complete: vi.fn(),
+      };
+
+      let streamCallbackDone: Promise<void>;
+      mockEventSource.stream.mockImplementation((callback: any) => {
+        streamCallbackDone = callback(mockStream);
+      });
+
+      await adapter.process({
+        threadId: "test-thread",
+        messages: [systemMessage, userMessage],
+        actions: [
+          {
+            name: "known_tool",
+            description: "A known tool",
+            parameters: [],
+            jsonSchema: '{"type":"object","properties":{}}',
+          },
+        ],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Wait for async stream processing to complete
+      await streamCallbackDone!;
+
+      // Should NOT have sent action execution events for the unknown tool
+      expect(mockStream.sendActionExecutionStart).not.toHaveBeenCalled();
+      expect(mockStream.sendActionExecutionArgs).not.toHaveBeenCalled();
+      expect(mockStream.sendActionExecutionEnd).not.toHaveBeenCalled();
+
+      // Should still process the text block normally
+      expect(mockStream.sendTextMessageStart).toHaveBeenCalled();
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: "msg-1",
+        content: "Here is the result.",
+      });
+      expect(mockStream.sendTextMessageEnd).toHaveBeenCalled();
+      expect(mockStream.complete).toHaveBeenCalled();
+    });
+
+    it("should trigger fallback when only unknown tool_use blocks are returned", async () => {
+      const systemMessage = new TextMessage("system", "System message");
+      const userMessage = new TextMessage("user", "Do something");
+
+      const toolExecution = new ActionExecutionMessage({
+        id: "tool-prev",
+        name: "someAction",
+        arguments: "{}",
+      });
+
+      const toolResult = new ResultMessage({
+        actionExecutionId: "tool-prev",
+        result: "Previous result",
+      });
+
+      // Mock Anthropic to return ONLY an unknown tool_use block
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          yield { type: "message_start", message: { id: "msg-1" } };
+          yield {
+            type: "content_block_start",
+            content_block: {
+              type: "tool_use",
+              id: "tool-unknown",
+              name: "nonexistent_tool",
+            },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: "{}" },
+          };
+          yield { type: "content_block_stop" };
+        },
+      });
+
+      const mockStream = {
+        sendTextMessageStart: vi.fn(),
+        sendTextMessageContent: vi.fn(),
+        sendTextMessageEnd: vi.fn(),
+        sendActionExecutionStart: vi.fn(),
+        sendActionExecutionArgs: vi.fn(),
+        sendActionExecutionEnd: vi.fn(),
+        complete: vi.fn(),
+      };
+
+      let streamCallbackDone: Promise<void>;
+      mockEventSource.stream.mockImplementation((callback: any) => {
+        streamCallbackDone = callback(mockStream);
+      });
+
+      await adapter.process({
+        threadId: "test-thread",
+        messages: [systemMessage, userMessage, toolExecution, toolResult],
+        actions: [
+          {
+            name: "known_tool",
+            description: "A known tool",
+            parameters: [],
+            jsonSchema: '{"type":"object","properties":{}}',
+          },
+        ],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Wait for async stream processing to complete
+      await streamCallbackDone!;
+
+      // Should NOT have sent action execution events
+      expect(mockStream.sendActionExecutionStart).not.toHaveBeenCalled();
+
+      // Should trigger fallback since hasReceivedContent should be false
+      expect(mockStream.sendTextMessageStart).toHaveBeenCalled();
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: expect.any(String),
+        content: "Previous result",
+      });
+      expect(mockStream.sendTextMessageEnd).toHaveBeenCalled();
+    });
+  });
+});
+
+describe("AnthropicAdapter max_tokens default", () => {
+  let mockAnthropicCreate: any;
+  let mockEventSource: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should default max_tokens to 4096 when not specified", async () => {
+    const mockAnthropic = {
+      messages: {
+        create: vi.fn(),
+      },
+    };
+
+    const adapter = new AnthropicAdapter({ anthropic: mockAnthropic as any });
+    mockAnthropicCreate = mockAnthropic.messages.create;
+
+    mockAnthropicCreate.mockResolvedValue({
+      [Symbol.asyncIterator]: async function* () {},
+    });
+
+    mockEventSource = {
+      stream: vi.fn((callback) => {
+        const mockStream = {
+          sendTextMessageStart: vi.fn(),
+          sendTextMessageContent: vi.fn(),
+          sendTextMessageEnd: vi.fn(),
+          sendActionExecutionStart: vi.fn(),
+          sendActionExecutionArgs: vi.fn(),
+          sendActionExecutionEnd: vi.fn(),
+          complete: vi.fn(),
+        };
+        callback(mockStream);
+        return Promise.resolve();
+      }),
+    };
+
+    const systemMessage = new TextMessage("system", "System message");
+    const userMessage = new TextMessage("user", "Hello");
+
+    await adapter.process({
+      threadId: "test-thread",
+      messages: [systemMessage, userMessage],
+      actions: [],
+      eventSource: mockEventSource,
+      forwardedParameters: {},
+    });
+
+    const createCallArgs = mockAnthropicCreate.mock.calls[0][0];
+    expect(createCallArgs.max_tokens).toBe(4096);
+  });
+
+  it("should use provided maxTokens when specified", async () => {
+    const mockAnthropic = {
+      messages: {
+        create: vi.fn(),
+      },
+    };
+
+    const adapter = new AnthropicAdapter({ anthropic: mockAnthropic as any });
+    mockAnthropicCreate = mockAnthropic.messages.create;
+
+    mockAnthropicCreate.mockResolvedValue({
+      [Symbol.asyncIterator]: async function* () {},
+    });
+
+    mockEventSource = {
+      stream: vi.fn((callback) => {
+        const mockStream = {
+          sendTextMessageStart: vi.fn(),
+          sendTextMessageContent: vi.fn(),
+          sendTextMessageEnd: vi.fn(),
+          sendActionExecutionStart: vi.fn(),
+          sendActionExecutionArgs: vi.fn(),
+          sendActionExecutionEnd: vi.fn(),
+          complete: vi.fn(),
+        };
+        callback(mockStream);
+        return Promise.resolve();
+      }),
+    };
+
+    const systemMessage = new TextMessage("system", "System message");
+    const userMessage = new TextMessage("user", "Hello");
+
+    await adapter.process({
+      threadId: "test-thread",
+      messages: [systemMessage, userMessage],
+      actions: [],
+      eventSource: mockEventSource,
+      forwardedParameters: { maxTokens: 8192 },
+    });
+
+    const createCallArgs = mockAnthropicCreate.mock.calls[0][0];
+    expect(createCallArgs.max_tokens).toBe(8192);
+  });
 });