add thoughtSignature Support and validate contents

Author: ndoschek

packages/ai-google/src/node/google-language-model.ts

@@ -38,6 +38,7 @@ interface ToolCallback {
     readonly id: string;
     readonly index: number;
     args: string;
+    thoughtSignature?: string;
 }
 const convertMessageToPart = (message: LanguageModelMessage): Part[] | undefined => {
     if (LanguageModelMessage.isTextMessage(message) && message.text.length > 0) {
@@ -52,7 +53,7 @@ const convertMessageToPart = (message: LanguageModelMessage): Part[] | undefined
         return [{ functionResponse: { id: message.tool_use_id, name: message.name, response: { output: message.content } } }];
 
     } else if (LanguageModelMessage.isThinkingMessage(message)) {
-        return [{ thought: true }, { text: message.thinking }];
+        return [{ thought: true, text: message.thinking }];
     } else if (LanguageModelMessage.isImageMessage(message) && ImageContent.isBase64(message.image)) {
         return [{ inlineData: { data: message.image.base64data, mimeType: message.image.mimeType } }];
     }
@@ -76,31 +77,61 @@ function transformToGeminiMessages(
             continue; // Skip system messages as they're handled separately
         }
         const resultParts = convertMessageToPart(message);
-        if (resultParts === undefined) {
+        if (resultParts === undefined || resultParts.length === 0) {
             continue;
         }
 
         const role = toGoogleRole(message);
-        const lastContent = contents.pop();
+        const lastContent = contents.length > 0 ? contents[contents.length - 1] : undefined;
 
         if (!lastContent) {
             contents.push({ role, parts: resultParts });
         } else if (lastContent.role !== role) {
-            contents.push(lastContent);
             contents.push({ role, parts: resultParts });
         } else {
-            lastContent?.parts?.push(...resultParts);
-            contents.push(lastContent);
+            if (lastContent.parts) {
+                lastContent.parts.push(...resultParts);
+            } else {
+                lastContent.parts = resultParts;
+            }
         }
 
     }
 
+    // Ensure we have at least one content
+    if (contents.length === 0) {
+        throw new Error('No valid messages to send to Gemini API');
+    }
+
     return {
         contents: contents,
         systemMessage,
     };
 }
 
+/**
+ * Validates that all items in the array are proper Content objects with role and parts
+ * @param contents Array to validate
+ * @throws Error if validation fails
+ */
+function validateContents(contents: Content[]): void {
+    for (let i = 0; i < contents.length; i++) {
+        const content = contents[i];
+        if (!content || typeof content !== 'object') {
+            throw new Error(`Invalid content at index ${i}: not an object`);
+        }
+        if (!content.role || (content.role !== 'user' && content.role !== 'model')) {
+            throw new Error(`Invalid content at index ${i}: missing or invalid role (got ${content.role})`);
+        }
+        if (!content.parts || !Array.isArray(content.parts)) {
+            throw new Error(`Invalid content at index ${i}: missing or invalid parts array`);
+        }
+        if (content.parts.length === 0) {
+            throw new Error(`Invalid content at index ${i}: parts array is empty`);
+        }
+    }
+}
+
 export const GoogleModelIdentifier = Symbol('GoogleModelIdentifier');
 
 /**
@@ -171,6 +202,12 @@ export class GoogleModel implements LanguageModel {
             };
         }
 
+        // Merge contents and tool messages
+        const allContents = [...contents, ...(toolMessages ?? [])];
+
+        // Validate all contents before making API call
+        validateContents(allContents);
+
         // Wrap the API call in the retry mechanism
         const stream = await this.withRetry(async () =>
             genAI.models.generateContentStream({
@@ -187,7 +224,7 @@ export class GoogleModel implements LanguageModel {
                     temperature: 1,
                     ...settings
                 },
-                contents: [...contents, ...(toolMessages ?? [])]
+                contents: allContents
             }));
 
         const that = this;
@@ -228,11 +265,16 @@ export class GoogleModel implements LanguageModel {
                                 const callId = functionCall.id ?? crypto.randomUUID().replace(/-/g, '');
                                 let toolCall = toolCallMap[callId];
                                 if (toolCall === undefined) {
+                                    const candidateParts = chunk.candidates?.[0]?.content?.parts;
+                                    const matchingPart = candidateParts?.find(p =>
+                                        p.functionCall?.id === callId && p.thoughtSignature
+                                    );
                                     toolCall = {
                                         name: functionCall.name ?? '',
                                         args: functionCall.args ? JSON.stringify(functionCall.args) : '{}',
                                         id: callId,
-                                        index: functionIndex++
+                                        index: functionIndex++,
+                                        thoughtSignature: matchingPart?.thoughtSignature
                                     };
                                     toolCallMap[callId] = toolCall;
 
@@ -310,18 +352,33 @@ export class GoogleModel implements LanguageModel {
                         yield { tool_calls: calls };
 
                         // Format tool responses for Gemini
-                        const toolResponses: Part[] = toolResult.map(call => ({
-                            functionResponse: {
-                                id: call.id,
-                                name: call.name,
-                                response: that.formatToolCallResult(call.result)
+                        const toolResponses: Part[] = toolResult.map(call => {
+                            const toolCall = toolCallMap[call.id];
+                            const part: Part = {
+                                functionResponse: {
+                                    id: call.id,
+                                    name: call.name,
+                                    response: that.formatToolCallResult(call.result)
+                                }
+                            };
+                            if (toolCall?.thoughtSignature) {
+                                part.thoughtSignature = toolCall.thoughtSignature;
                             }
-                        }));
+                            return part;
+                        });
                         const responseMessage: Content = { role: 'user', parts: toolResponses };
 
                         const messages = [...(toolMessages ?? [])];
                         if (currentContent) {
-                            messages.push(currentContent);
+                            // Ensure currentContent has proper structure
+                            if (!currentContent.role) {
+                                currentContent.role = 'model';
+                            }
+                            if (!currentContent.parts || currentContent.parts.length === 0) {
+                                console.warn('currentContent has no parts, skipping');
+                            } else {
+                                messages.push(currentContent);
+                            }
                         }
                         messages.push(responseMessage);
                         // Continue the conversation with tool results
@@ -374,6 +431,9 @@ export class GoogleModel implements LanguageModel {
         const { contents, systemMessage } = transformToGeminiMessages(request.messages);
         const functionDeclarations = this.createFunctionDeclarations(request);
 
+        // Validate contents before making API call
+        validateContents(contents);
+
         // Wrap the API call in the retry mechanism
         const model = await this.withRetry(async () => genAI.models.generateContent({
             model: this.model,