@copilotkit/runtime 1.8.12-next.2 → 1.8.12-next.4

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.12-next.2",
+  "version": "1.8.12-next.4",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -19,6 +19,7 @@
   "types": "./dist/index.d.ts",
   "license": "MIT",
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
     "@swc/core": "1.5.28",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
@@ -63,7 +64,7 @@
     "rxjs": "^7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.8.12-next.2"
+    "@copilotkit/shared": "1.8.12-next.4"
   },
   "keywords": [
     "copilotkit",

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

@@ -25,7 +25,6 @@ import {
 import {
   convertActionInputToAnthropicTool,
   convertMessageToAnthropicMessage,
-  groupAnthropicMessagesByRole,
   limitMessagesToTokenCount,
 } from "./utils";
 
@@ -80,9 +79,54 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     const instructionsMessage = messages.shift();
     const instructions = instructionsMessage.isTextMessage() ? instructionsMessage.content : "";
 
-    let anthropicMessages = messages.map(convertMessageToAnthropicMessage);
-    anthropicMessages = limitMessagesToTokenCount(anthropicMessages, tools, model);
-    anthropicMessages = groupAnthropicMessagesByRole(anthropicMessages);
+    // ALLOWLIST APPROACH:
+    // 1. First, identify all valid tool_use calls (from assistant)
+    // 2. Then, only keep tool_result blocks that correspond to these valid tool_use IDs
+    // 3. Discard any other tool_result blocks
+
+    // Step 1: Extract valid tool_use IDs
+    const validToolUseIds = new Set<string>();
+
+    for (const message of messages) {
+      if (message.isActionExecutionMessage()) {
+        validToolUseIds.add(message.id);
+      }
+    }
+
+    // Step 2: Map each message to an Anthropic message, eliminating invalid tool_results
+    const anthropicMessages = messages
+      .map((message) => {
+        // For tool results, only include if they match a valid tool_use ID
+        if (message.isResultMessage()) {
+          // Skip if there's no corresponding tool_use
+          if (!validToolUseIds.has(message.actionExecutionId)) {
+            return null; // Will be filtered out later
+          }
+
+          // Remove this ID from valid IDs so we don't process duplicates
+          validToolUseIds.delete(message.actionExecutionId);
+
+          return {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                content: message.result,
+                tool_use_id: message.actionExecutionId,
+              },
+            ],
+          };
+        }
+
+        // For non-tool-result messages, convert normally
+        return convertMessageToAnthropicMessage(message);
+      })
+      .filter(Boolean) as Anthropic.Messages.MessageParam[]; // Explicitly cast after filtering nulls
+
+    // Apply token limits
+    const limitedMessages = limitMessagesToTokenCount(anthropicMessages, tools, model);
+
+    // We skip grouping by role since we've already ensured uniqueness of tool_results
 
     let toolChoice: any = forwardedParameters?.toolChoice;
     if (forwardedParameters?.toolChoice === "function") {
@@ -92,73 +136,87 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
       };
     }
 
-    const stream = this.anthropic.messages.create({
-      system: instructions,
-      model: this.model,
-      messages: anthropicMessages,
-      max_tokens: forwardedParameters?.maxTokens || 1024,
-      ...(forwardedParameters?.temperature ? { temperature: forwardedParameters.temperature } : {}),
-      ...(tools.length > 0 && { tools }),
-      ...(toolChoice && { tool_choice: toolChoice }),
-      stream: true,
-    });
-
-    eventSource.stream(async (eventStream$) => {
-      let mode: "function" | "message" | null = null;
-      let didOutputText = false;
-      let currentMessageId = randomId();
-      let currentToolCallId = randomId();
-      let filterThinkingTextBuffer = new FilterThinkingTextBuffer();
-
-      for await (const chunk of await stream) {
-        if (chunk.type === "message_start") {
-          currentMessageId = chunk.message.id;
-        } else if (chunk.type === "content_block_start") {
-          if (chunk.content_block.type === "text") {
-            didOutputText = false;
-            filterThinkingTextBuffer.reset();
-            mode = "message";
-          } else if (chunk.content_block.type === "tool_use") {
-            currentToolCallId = chunk.content_block.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              actionName: chunk.content_block.name,
-              parentMessageId: currentMessageId,
-            });
-            mode = "function";
-          }
-        } else if (chunk.type === "content_block_delta") {
-          if (chunk.delta.type === "text_delta") {
-            const text = filterThinkingTextBuffer.onTextChunk(chunk.delta.text);
-            if (text.length > 0) {
-              if (!didOutputText) {
-                eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-                didOutputText = true;
+    try {
+      const createParams = {
+        system: instructions,
+        model: this.model,
+        messages: limitedMessages,
+        max_tokens: forwardedParameters?.maxTokens || 1024,
+        ...(forwardedParameters?.temperature
+          ? { temperature: forwardedParameters.temperature }
+          : {}),
+        ...(tools.length > 0 && { tools }),
+        ...(toolChoice && { tool_choice: toolChoice }),
+        stream: true,
+      };
+
+      const stream = await this.anthropic.messages.create(createParams);
+
+      eventSource.stream(async (eventStream$) => {
+        let mode: "function" | "message" | null = null;
+        let didOutputText = false;
+        let currentMessageId = randomId();
+        let currentToolCallId = randomId();
+        let filterThinkingTextBuffer = new FilterThinkingTextBuffer();
+
+        try {
+          for await (const chunk of stream as AsyncIterable<any>) {
+            if (chunk.type === "message_start") {
+              currentMessageId = chunk.message.id;
+            } else if (chunk.type === "content_block_start") {
+              if (chunk.content_block.type === "text") {
+                didOutputText = false;
+                filterThinkingTextBuffer.reset();
+                mode = "message";
+              } else if (chunk.content_block.type === "tool_use") {
+                currentToolCallId = chunk.content_block.id;
+                eventStream$.sendActionExecutionStart({
+                  actionExecutionId: currentToolCallId,
+                  actionName: chunk.content_block.name,
+                  parentMessageId: currentMessageId,
+                });
+                mode = "function";
+              }
+            } else if (chunk.type === "content_block_delta") {
+              if (chunk.delta.type === "text_delta") {
+                const text = filterThinkingTextBuffer.onTextChunk(chunk.delta.text);
+                if (text.length > 0) {
+                  if (!didOutputText) {
+                    eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+                    didOutputText = true;
+                  }
+                  eventStream$.sendTextMessageContent({
+                    messageId: currentMessageId,
+                    content: text,
+                  });
+                }
+              } else if (chunk.delta.type === "input_json_delta") {
+                eventStream$.sendActionExecutionArgs({
+                  actionExecutionId: currentToolCallId,
+                  args: chunk.delta.partial_json,
+                });
+              }
+            } else if (chunk.type === "content_block_stop") {
+              if (mode === "message") {
+                if (didOutputText) {
+                  eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+                }
+              } else if (mode === "function") {
+                eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
               }
-              eventStream$.sendTextMessageContent({
-                messageId: currentMessageId,
-                content: text,
-              });
-            }
-          } else if (chunk.delta.type === "input_json_delta") {
-            eventStream$.sendActionExecutionArgs({
-              actionExecutionId: currentToolCallId,
-              args: chunk.delta.partial_json,
-            });
-          }
-        } else if (chunk.type === "content_block_stop") {
-          if (mode === "message") {
-            if (didOutputText) {
-              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
             }
-          } else if (mode === "function") {
-            eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
           }
+        } catch (error) {
+          console.error("[Anthropic] Error processing stream:", error);
+          throw error;
         }
-      }
 
-      eventStream$.complete();
-    });
+        eventStream$.complete();
+      });
+    } catch (error) {
+      console.error("[Anthropic] Error during API call:", error);
+      throw error;
+    }
 
     return {
       threadId: threadId || randomUUID(),

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

@@ -155,22 +155,3 @@ export function convertMessageToAnthropicMessage(
     };
   }
 }
-
-export function groupAnthropicMessagesByRole(
-  messageParams: Anthropic.Messages.MessageParam[],
-): Anthropic.Messages.MessageParam[] {
-  return messageParams.reduce((acc, message) => {
-    const lastGroup = acc[acc.length - 1];
-
-    if (lastGroup && lastGroup.role === message.role) {
-      lastGroup.content = lastGroup.content.concat(message.content as any);
-    } else {
-      acc.push({
-        role: message.role,
-        content: [...(message.content as any)],
-      });
-    }
-
-    return acc;
-  }, [] as Anthropic.Messages.MessageParam[]);
-}

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

@@ -128,7 +128,34 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     const tools = actions.map(convertActionInputToOpenAITool);
     const threadId = threadIdFromRequest ?? randomUUID();
 
-    let openaiMessages = messages.map((m) =>
+    // ALLOWLIST APPROACH: Only include tool_result messages that correspond to valid tool_calls
+    // Step 1: Extract valid tool_call IDs
+    const validToolUseIds = new Set<string>();
+
+    for (const message of messages) {
+      if (message.isActionExecutionMessage()) {
+        validToolUseIds.add(message.id);
+      }
+    }
+
+    // Step 2: Filter messages, keeping only those with valid tool_call IDs
+    const filteredMessages = messages.filter((message) => {
+      if (message.isResultMessage()) {
+        // Skip if there's no corresponding tool_call
+        if (!validToolUseIds.has(message.actionExecutionId)) {
+          return false;
+        }
+
+        // Remove this ID from valid IDs so we don't process duplicates
+        validToolUseIds.delete(message.actionExecutionId);
+        return true;
+      }
+
+      // Keep all non-tool-result messages
+      return true;
+    });
+
+    let openaiMessages = filteredMessages.map((m) =>
       convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }),
     );
     openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
@@ -141,81 +168,92 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
       };
     }
 
-    const stream = this.openai.beta.chat.completions.stream({
-      model: model,
-      stream: true,
-      messages: openaiMessages,
-      ...(tools.length > 0 && { tools }),
-      ...(forwardedParameters?.maxTokens && { max_tokens: forwardedParameters.maxTokens }),
-      ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
-      ...(toolChoice && { tool_choice: toolChoice }),
-      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-      ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
-    });
+    try {
+      const stream = this.openai.beta.chat.completions.stream({
+        model: model,
+        stream: true,
+        messages: openaiMessages,
+        ...(tools.length > 0 && { tools }),
+        ...(forwardedParameters?.maxTokens && { max_tokens: forwardedParameters.maxTokens }),
+        ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
+        ...(toolChoice && { tool_choice: toolChoice }),
+        ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
+        ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
+      });
 
-    eventSource.stream(async (eventStream$) => {
-      let mode: "function" | "message" | null = null;
-      let currentMessageId: string;
-      let currentToolCallId: string;
-      for await (const chunk of stream) {
-        if (chunk.choices.length === 0) {
-          continue;
-        }
+      eventSource.stream(async (eventStream$) => {
+        let mode: "function" | "message" | null = null;
+        let currentMessageId: string;
+        let currentToolCallId: string;
 
-        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
-        const content = chunk.choices[0].delta.content;
-
-        // When switching from message to function or vice versa,
-        // send the respective end event.
-        // If toolCall?.id is defined, it means a new tool call starts.
-        if (mode === "message" && toolCall?.id) {
-          mode = null;
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-        } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
-          mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-        }
+        try {
+          for await (const chunk of stream) {
+            if (chunk.choices.length === 0) {
+              continue;
+            }
+
+            const toolCall = chunk.choices[0].delta.tool_calls?.[0];
+            const content = chunk.choices[0].delta.content;
+
+            // When switching from message to function or vice versa,
+            // send the respective end event.
+            // If toolCall?.id is defined, it means a new tool call starts.
+            if (mode === "message" && toolCall?.id) {
+              mode = null;
+              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+            } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
+              mode = null;
+              eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+            }
 
-        // If we send a new message type, send the appropriate start event.
-        if (mode === null) {
-          if (toolCall?.id) {
-            mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              parentMessageId: chunk.id,
-              actionName: toolCall!.function!.name,
-            });
-          } else if (content) {
-            mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            // If we send a new message type, send the appropriate start event.
+            if (mode === null) {
+              if (toolCall?.id) {
+                mode = "function";
+                currentToolCallId = toolCall!.id;
+                eventStream$.sendActionExecutionStart({
+                  actionExecutionId: currentToolCallId,
+                  parentMessageId: chunk.id,
+                  actionName: toolCall!.function!.name,
+                });
+              } else if (content) {
+                mode = "message";
+                currentMessageId = chunk.id;
+                eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+              }
+            }
+
+            // send the content events
+            if (mode === "message" && content) {
+              eventStream$.sendTextMessageContent({
+                messageId: currentMessageId,
+                content: content,
+              });
+            } else if (mode === "function" && toolCall?.function?.arguments) {
+              eventStream$.sendActionExecutionArgs({
+                actionExecutionId: currentToolCallId,
+                args: toolCall.function.arguments,
+              });
+            }
           }
-        }
 
-        // send the content events
-        if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: content,
-          });
-        } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
+          // send the end events
+          if (mode === "message") {
+            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+          } else if (mode === "function") {
+            eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+          }
+        } catch (error) {
+          console.error("[OpenAI] Error processing stream:", error);
+          throw error;
         }
-      }
-
-      // send the end events
-      if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-      } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-      }
 
-      eventStream$.complete();
-    });
+        eventStream$.complete();
+      });
+    } catch (error) {
+      console.error("[OpenAI] Error during API call:", error);
+      throw error;
+    }
 
     return {
       threadId,

package/tests/global.d.ts

@@ -0,0 +1,13 @@
+import "@jest/globals";
+
+declare global {
+  const jest: (typeof import("@jest/globals"))["jest"];
+  const expect: (typeof import("@jest/globals"))["expect"];
+  const test: (typeof import("@jest/globals"))["test"];
+  const describe: (typeof import("@jest/globals"))["describe"];
+  const beforeEach: (typeof import("@jest/globals"))["beforeEach"];
+  const afterEach: (typeof import("@jest/globals"))["afterEach"];
+  const beforeAll: (typeof import("@jest/globals"))["beforeAll"];
+  const afterAll: (typeof import("@jest/globals"))["afterAll"];
+  const it: (typeof import("@jest/globals"))["it"];
+}