@copilotkit/runtime 1.8.14-next.3 → 1.8.14-next.5

package/src/lib/runtime/agui-action.ts

@@ -67,10 +67,13 @@ export function constructAGUIRemoteAction({
         };
       });
 
+      const forwardedProps = metaEvents.length
+        ? { command: { resume: metaEvents[0]?.response } }
+        : undefined;
+
       return agent.legacy_to_be_removed_runAgentBridged({
         tools,
-        // @ts-ignore
-        resume: metaEvents[0]?.response,
+        forwardedProps,
       }) as Observable<RuntimeEvent>;
     },
   };

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

@@ -121,7 +121,20 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
         // For non-tool-result messages, convert normally
         return convertMessageToAnthropicMessage(message);
       })
-      .filter(Boolean) as Anthropic.Messages.MessageParam[]; // Explicitly cast after filtering nulls
+      .filter(Boolean) // Remove nulls
+      .filter((msg) => {
+        // Filter out assistant messages with empty text content
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+          const hasEmptyTextOnly =
+            msg.content.length === 1 &&
+            msg.content[0].type === "text" &&
+            (!(msg.content[0] as any).text || (msg.content[0] as any).text.trim() === "");
+
+          // Keep messages that have tool_use or non-empty text
+          return !hasEmptyTextOnly;
+        }
+        return true;
+      }) as Anthropic.Messages.MessageParam[];
 
     // Apply token limits
     const limitedMessages = limitMessagesToTokenCount(anthropicMessages, tools, model);

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

@@ -0,0 +1,104 @@
+import { GoogleGenerativeAIAdapter } from "./google-genai-adapter";
+import { AIMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
+
+// Mock ChatGoogle to capture what messages are passed to it
+jest.mock("@langchain/google-gauth", () => ({
+  ChatGoogle: jest.fn().mockImplementation(() => ({
+    bindTools: jest.fn().mockReturnThis(),
+    stream: jest.fn().mockImplementation((messages) => {
+      // Return the messages so we can verify filtering
+      return Promise.resolve({ filteredMessages: messages });
+    }),
+  })),
+}));
+
+describe("GoogleGenerativeAIAdapter", () => {
+  it("should filter out empty AIMessages to prevent Gemini validation errors", async () => {
+    const adapter = new GoogleGenerativeAIAdapter();
+
+    // Create a mix of messages including an empty AIMessage (the problematic case)
+    const messages = [
+      new HumanMessage("Hello"),
+      new AIMessage(""), // This should be filtered out
+      new HumanMessage("How are you?"),
+      new AIMessage("I'm doing well!"), // This should be kept
+      new SystemMessage("You are a helpful assistant"), // This should be kept
+      new AIMessage(""), // Another empty one to filter out
+    ];
+
+    // Access the internal chainFn to test the filtering logic
+    const chainFnResult = await (adapter as any).options.chainFn({
+      messages,
+      tools: [],
+      threadId: "test-thread",
+    });
+
+    // The result should be filtered messages passed to ChatGoogle.stream()
+    const { filteredMessages } = chainFnResult;
+
+    // Should only contain non-empty messages
+    expect(filteredMessages).toHaveLength(4);
+    expect(filteredMessages[0]).toBeInstanceOf(HumanMessage);
+    expect(filteredMessages[0].content).toBe("Hello");
+    expect(filteredMessages[1]).toBeInstanceOf(HumanMessage);
+    expect(filteredMessages[1].content).toBe("How are you?");
+    expect(filteredMessages[2]).toBeInstanceOf(AIMessage);
+    expect(filteredMessages[2].content).toBe("I'm doing well!");
+    expect(filteredMessages[3]).toBeInstanceOf(SystemMessage);
+    expect(filteredMessages[3].content).toBe("You are a helpful assistant");
+  });
+
+  it("should keep AIMessages with tool_calls even if content is empty", async () => {
+    const adapter = new GoogleGenerativeAIAdapter();
+
+    const messagesWithToolCalls = [
+      new HumanMessage("Execute a function"),
+      new AIMessage({
+        content: "", // Empty content but has tool calls
+        tool_calls: [
+          {
+            id: "call_123",
+            name: "test_function",
+            args: { param: "value" },
+          },
+        ],
+      }),
+    ];
+
+    const chainFnResult = await (adapter as any).options.chainFn({
+      messages: messagesWithToolCalls,
+      tools: [],
+      threadId: "test-thread",
+    });
+
+    const { filteredMessages } = chainFnResult;
+
+    // Should keep both messages - the AIMessage has tool_calls so it's valid
+    expect(filteredMessages).toHaveLength(2);
+    expect(filteredMessages[1]).toBeInstanceOf(AIMessage);
+    expect(filteredMessages[1].tool_calls).toHaveLength(1);
+  });
+
+  it("should keep all non-AIMessage types regardless of content", async () => {
+    const adapter = new GoogleGenerativeAIAdapter();
+
+    const messages = [
+      new HumanMessage(""), // Empty human message should be kept
+      new SystemMessage(""), // Empty system message should be kept
+      new AIMessage(""), // Empty AI message should be filtered
+    ];
+
+    const chainFnResult = await (adapter as any).options.chainFn({
+      messages,
+      tools: [],
+      threadId: "test-thread",
+    });
+
+    const { filteredMessages } = chainFnResult;
+
+    // Should keep HumanMessage and SystemMessage, filter out empty AIMessage
+    expect(filteredMessages).toHaveLength(2);
+    expect(filteredMessages[0]).toBeInstanceOf(HumanMessage);
+    expect(filteredMessages[1]).toBeInstanceOf(SystemMessage);
+  });
+});

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

@@ -16,6 +16,7 @@
  */
 import { ChatGoogle } from "@langchain/google-gauth";
 import { LangChainAdapter } from "../langchain/langchain-adapter";
+import { AIMessage } from "@langchain/core/messages";
 
 interface GoogleGenerativeAIAdapterOptions {
   /**
@@ -28,11 +29,28 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
   constructor(options?: GoogleGenerativeAIAdapterOptions) {
     super({
       chainFn: async ({ messages, tools, threadId }) => {
+        // Filter out empty assistant messages to prevent Gemini validation errors
+        // Gemini specifically rejects conversations containing AIMessages with empty content
+        const filteredMessages = messages.filter((message) => {
+          // Keep all non-AI messages (HumanMessage, SystemMessage, ToolMessage, etc.)
+          if (!(message instanceof AIMessage)) {
+            return true;
+          }
+
+          // For AIMessages, only keep those with non-empty content
+          // Also keep AIMessages with tool_calls even if content is empty
+          return (
+            (message.content && String(message.content).trim().length > 0) ||
+            (message.tool_calls && message.tool_calls.length > 0)
+          );
+        });
+
         const model = new ChatGoogle({
           modelName: options?.model ?? "gemini-1.5-pro",
           apiVersion: "v1beta",
         }).bindTools(tools);
-        return model.stream(messages, { metadata: { conversation_id: threadId } });
+
+        return model.stream(filteredMessages, { metadata: { conversation_id: threadId } });
       },
     });
   }