@copilotkit/runtime 1.9.2-next.9 → 1.9.3-next.0

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

@@ -61,6 +61,36 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     }
   }
 
+  private shouldGenerateFallbackResponse(messages: Anthropic.Messages.MessageParam[]): boolean {
+    if (messages.length === 0) return false;
+
+    const lastMessage = messages[messages.length - 1];
+
+    // Check if the last message is a tool result
+    const endsWithToolResult =
+      lastMessage.role === "user" &&
+      Array.isArray(lastMessage.content) &&
+      lastMessage.content.some((content: any) => content.type === "tool_result");
+
+    // Also check if we have a recent pattern of user message -> assistant tool use -> user tool result
+    // This indicates a completed action that might not need a response
+    if (messages.length >= 3 && endsWithToolResult) {
+      const lastThree = messages.slice(-3);
+      const hasRecentToolPattern =
+        lastThree[0]?.role === "user" && // Initial user message
+        lastThree[1]?.role === "assistant" && // Assistant tool use
+        Array.isArray(lastThree[1].content) &&
+        lastThree[1].content.some((content: any) => content.type === "tool_use") &&
+        lastThree[2]?.role === "user" && // Tool result
+        Array.isArray(lastThree[2].content) &&
+        lastThree[2].content.some((content: any) => content.type === "tool_result");
+
+      return hasRecentToolPattern;
+    }
+
+    return endsWithToolResult;
+  }
+
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
@@ -95,24 +125,30 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     }
 
     // Step 2: Map each message to an Anthropic message, eliminating invalid tool_results
+    const processedToolResultIds = new Set<string>();
     const anthropicMessages = messages
       .map((message) => {
-        // For tool results, only include if they match a valid tool_use ID
+        // For tool results, only include if they match a valid tool_use ID AND haven't been processed
         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);
+          // Skip if we've already processed a result for this tool_use ID
+          if (processedToolResultIds.has(message.actionExecutionId)) {
+            return null; // Will be filtered out later
+          }
+
+          // Mark this tool result as processed
+          processedToolResultIds.add(message.actionExecutionId);
 
           return {
             role: "user",
             content: [
               {
                 type: "tool_result",
-                content: message.result,
+                content: message.result || "Action completed successfully",
                 tool_use_id: message.actionExecutionId,
               },
             ],
@@ -140,6 +176,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     // Apply token limits
     const limitedMessages = limitMessagesToTokenCount(anthropicMessages, tools, model);
 
+    // We'll check if we need a fallback response after seeing what Anthropic returns
     // We skip grouping by role since we've already ensured uniqueness of tool_results
 
     let toolChoice: any = forwardedParameters?.toolChoice;
@@ -172,12 +209,14 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
         let currentMessageId = randomId();
         let currentToolCallId = randomId();
         let filterThinkingTextBuffer = new FilterThinkingTextBuffer();
+        let hasReceivedContent = false;
 
         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") {
+              hasReceivedContent = true;
               if (chunk.content_block.type === "text") {
                 didOutputText = false;
                 filterThinkingTextBuffer.reset();
@@ -224,6 +263,27 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
           throw convertServiceAdapterError(error, "Anthropic");
         }
 
+        // Generate fallback response only if Anthropic produced no content
+        if (!hasReceivedContent && this.shouldGenerateFallbackResponse(limitedMessages)) {
+          // Extract the tool result content for a more contextual response
+          let fallbackContent = "Task completed successfully.";
+          const lastMessage = limitedMessages[limitedMessages.length - 1];
+          if (lastMessage?.role === "user" && Array.isArray(lastMessage.content)) {
+            const toolResult = lastMessage.content.find((c: any) => c.type === "tool_result");
+            if (toolResult?.content && toolResult.content !== "Action completed successfully") {
+              fallbackContent = toolResult.content;
+            }
+          }
+
+          currentMessageId = randomId();
+          eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: fallbackContent,
+          });
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        }
+
         eventStream$.complete();
       });
     } catch (error) {

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

@@ -1,11 +1,6 @@
-import {
-  ActionExecutionMessage,
-  Message,
-  ResultMessage,
-  TextMessage,
-} from "../../graphql/types/converted";
-import { ActionInput } from "../../graphql/inputs/action.input";
 import { Anthropic } from "@anthropic-ai/sdk";
+import { ActionInput } from "../../graphql/inputs/action.input";
+import { Message } from "../../graphql/types/converted";
 
 export function limitMessagesToTokenCount(
   messages: any[],
@@ -148,7 +143,7 @@ export function convertMessageToAnthropicMessage(
       content: [
         {
           type: "tool_result",
-          content: message.result,
+          content: message.result || "Action completed successfully",
           tool_use_id: message.actionExecutionId,
         },
       ],

package/src/service-adapters/events.ts

@@ -240,6 +240,16 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
 export class RuntimeEventSource {
   private eventStream$ = new RuntimeEventSubject();
   private callback!: EventSourceCallback;
+  private errorHandler?: (error: any, context: any) => Promise<void>;
+  private errorContext?: any;
+
+  constructor(params?: {
+    errorHandler?: (error: any, context: any) => Promise<void>;
+    errorContext?: any;
+  }) {
+    this.errorHandler = params?.errorHandler;
+    this.errorContext = params?.errorContext;
+  }
 
   async stream(callback: EventSourceCallback): Promise<void> {
     this.callback = callback;
@@ -267,9 +277,19 @@ export class RuntimeEventSource {
     actionInputsWithoutAgents: ActionInput[];
     threadId: string;
   }) {
-    this.callback(this.eventStream$).catch((error) => {
+    this.callback(this.eventStream$).catch(async (error) => {
       // Convert streaming errors to structured errors, but preserve already structured ones
       const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
+
+      // Call the runtime error handler if provided
+      if (this.errorHandler && this.errorContext) {
+        try {
+          await this.errorHandler(structuredError, this.errorContext);
+        } catch (errorHandlerError) {
+          console.error("Error in streaming error handler:", errorHandlerError);
+        }
+      }
+
       this.eventStream$.error(structuredError);
       this.eventStream$.complete();
     });
@@ -333,6 +353,25 @@ export class RuntimeEventSource {
                 error,
                 convertStreamingErrorToStructured,
               );
+
+              // Call the runtime error handler if provided
+              if (this.errorHandler && this.errorContext) {
+                // Use from() to handle async error handler
+                from(
+                  this.errorHandler(structuredError, {
+                    ...this.errorContext,
+                    action: {
+                      name: eventWithState.action!.name,
+                      executionId: eventWithState.actionExecutionId,
+                    },
+                  }),
+                ).subscribe({
+                  error: (errorHandlerError) => {
+                    console.error("Error in action execution error handler:", errorHandlerError);
+                  },
+                });
+              }
+
               toolCallEventStream$.sendActionExecutionResult({
                 actionExecutionId: eventWithState.actionExecutionId!,
                 actionName: eventWithState.action!.name,

package/src/service-adapters/google/google-genai-adapter.ts

@@ -23,6 +23,10 @@ interface GoogleGenerativeAIAdapterOptions {
    * A custom Google Generative AI model to use.
    */
   model?: string;
+  /**
+   * The API key to use.
+   */
+  apiKey?: string;
 }
 
 export class GoogleGenerativeAIAdapter extends LangChainAdapter {
@@ -46,6 +50,7 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
         });
 
         const model = new ChatGoogle({
+          apiKey: options?.apiKey ?? process.env.GOOGLE_API_KEY,
           modelName: options?.model ?? "gemini-1.5-pro",
           apiVersion: "v1beta",
         }).bindTools(tools);

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

@@ -129,8 +129,6 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     const tools = actions.map(convertActionInputToOpenAITool);
     const threadId = threadIdFromRequest ?? randomUUID();
 
-    console.log("messages", messages);
-
     // 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>();
@@ -171,18 +169,6 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
       };
     }
 
-    console.log("INPUT", {
-      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,