smoltalk 0.7.1 → 0.8.1

package/dist/classes/ToolCall.d.ts

@@ -5,23 +5,29 @@ export declare const ToolCallJSONSchema: z.ZodObject<{
     id: z.ZodDefault<z.ZodString>;
     name: z.ZodString;
     arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    thoughtSignature: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ToolCallJSON = z.infer<typeof ToolCallJSONSchema>;
-export type ToolCallOptions = {};
+export type ToolCallOptions = {
+    thoughtSignature?: string;
+};
 export declare class ToolCall {
     private _id;
     private _name;
     private _arguments;
+    private _thoughtSignature?;
     private logger;
     constructor(id: string, name: string, args: Record<string, any> | string, options?: ToolCallOptions);
     get id(): string;
     get name(): string;
     get arguments(): Record<string, any>;
+    get thoughtSignature(): string | undefined;
     toJSON(): ToolCallJSON;
     static fromJSON(json: unknown): ToolCall;
     toOpenAI(): any;
     toGoogle(): {
         functionCall: FunctionCall;
+        thoughtSignature?: string;
     };
     toOpenAIResponseInputItem(): ResponseInputItem;
 }

package/dist/classes/ToolCall.js

@@ -4,15 +4,20 @@ export const ToolCallJSONSchema = z.object({
     id: z.string().default(""),
     name: z.string(),
     arguments: z.record(z.string(), z.any()).default({}),
+    // Google Gemini 3 attaches an encrypted thought signature to the same part as
+    // the function call; it must be echoed back verbatim during tool use.
+    thoughtSignature: z.string().optional(),
 });
 export class ToolCall {
     _id;
     _name;
     _arguments;
+    _thoughtSignature;
     logger;
     constructor(id, name, args, options = {}) {
         this._id = id;
         this._name = name;
+        this._thoughtSignature = options.thoughtSignature;
         this.logger = getLogger();
         if (typeof args === "string") {
             try {
@@ -37,11 +42,17 @@ export class ToolCall {
     get arguments() {
         return this._arguments;
     }
+    get thoughtSignature() {
+        return this._thoughtSignature;
+    }
     toJSON() {
         return {
             id: this._id,
             name: this._name,
             arguments: this._arguments,
+            ...(this._thoughtSignature !== undefined && {
+                thoughtSignature: this._thoughtSignature,
+            }),
         };
     }
     static fromJSON(json) {
@@ -53,7 +64,9 @@ export class ToolCall {
             logger.debug("ToolCall payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse ToolCall");
         }
-        return new ToolCall(result.data.id, result.data.name, result.data.arguments);
+        return new ToolCall(result.data.id, result.data.name, result.data.arguments, {
+            thoughtSignature: result.data.thoughtSignature,
+        });
     }
     toOpenAI() {
         return {
@@ -71,6 +84,11 @@ export class ToolCall {
                 name: this.name,
                 args: this.arguments,
             },
+            // Gemini 3 requires the original thought signature echoed back on the
+            // function-call part; omitting it fails validation during tool use.
+            ...(this._thoughtSignature !== undefined && {
+                thoughtSignature: this._thoughtSignature,
+            }),
         };
     }
     toOpenAIResponseInputItem() {

package/dist/classes/message/AssistantMessage.d.ts

@@ -19,6 +19,7 @@ export declare const AssistantMessageJSONSchema: z.ZodObject<{
         id: z.ZodDefault<z.ZodString>;
         name: z.ZodString;
         arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        thoughtSignature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     thinkingBlocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         text: z.ZodString;

package/dist/clients/anthropic.d.ts

@@ -2,6 +2,7 @@ import type { MessageParam, Tool } from "@anthropic-ai/sdk/resources/messages.js
 import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk, HostedToolResult } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
+export declare function mergeConsecutiveMessages(messages: MessageParam[]): MessageParam[];
 export declare function anthropicWebSearchEntries(hostedTools?: string[]): any[];
 export declare function parseAnthropicHostedTools(response: any, provider: string): HostedToolResult[];
 type EphemeralCacheControl = {

package/dist/clients/anthropic.js

@@ -12,6 +12,40 @@ import { BaseClient } from "./baseClient.js";
 import { getModel, isTextModel } from "../models.js";
 import { Model } from "../model.js";
 const DEFAULT_MAX_TOKENS = 4096;
+// Normalize an Anthropic message's content to a block array for merging.
+// Array content is passed through; a non-empty string becomes a single text
+// block; an empty string (or any other unexpected value) becomes no blocks
+// (Anthropic rejects empty text blocks). Guarding non-array values keeps the
+// exported merge helper from throwing on a spread if a caller passes content
+// that isn't the string | block[] the type promises.
+function anthropicContentToBlocks(content) {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    if (typeof content === "string" && content.length > 0) {
+        return [{ type: "text", text: content }];
+    }
+    return [];
+}
+// Anthropic requires strict user/assistant turn alternation. Collapse any run of
+// consecutive messages that share a role into a single message by concatenating
+// their content blocks. Does not mutate the input.
+export function mergeConsecutiveMessages(messages) {
+    const merged = [];
+    for (const msg of messages) {
+        const last = merged[merged.length - 1];
+        if (last && last.role === msg.role) {
+            const content = [
+                ...anthropicContentToBlocks(last.content),
+                ...anthropicContentToBlocks(msg.content),
+            ];
+            merged[merged.length - 1] = { ...last, content };
+            continue;
+        }
+        merged.push(msg);
+    }
+    return merged;
+}
 export function anthropicWebSearchEntries(hostedTools) {
     if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
         return [{ type: "web_search_20250305", name: "web_search" }];
@@ -187,30 +221,21 @@ export class SmolAnthropic extends BaseClient {
             .filter((m) => m instanceof SystemMessage || m instanceof DeveloperMessage)
             .map((m) => m.content);
         const system = systemParts.length > 0 ? systemParts.join("\n") : undefined;
-        // Convert remaining messages, merging consecutive tool_result user messages
-        const anthropicMessages = [];
+        // Convert remaining messages into Anthropic message params.
+        const converted = [];
         for (const msg of config.messages) {
             if (msg instanceof SystemMessage || msg instanceof DeveloperMessage) {
                 continue;
             }
-            const converted = msg.toAnthropicMessage();
-            if (converted === null)
+            const c = msg.toAnthropicMessage();
+            if (c === null)
                 continue;
-            // Merge consecutive tool_result user messages into one (required by Anthropic)
-            if (converted.role === "user" &&
-                Array.isArray(converted.content) &&
-                converted.content.every((c) => c.type === "tool_result")) {
-                const last = anthropicMessages[anthropicMessages.length - 1];
-                if (last &&
-                    last.role === "user" &&
-                    Array.isArray(last.content) &&
-                    last.content.every((c) => c.type === "tool_result")) {
-                    last.content.push(...converted.content);
-                    continue;
-                }
-            }
-            anthropicMessages.push(converted);
+            converted.push(c);
         }
+        // Anthropic requires strict user/assistant alternation — merge any run of
+        // consecutive same-role messages into one (e.g. two user turns, or a user
+        // turn followed by tool results, which also map to role "user").
+        const anthropicMessages = mergeConsecutiveMessages(converted);
         const functionTools = config.tools && config.tools.length > 0
             ? config.tools.map((tool) => zodToAnthropicTool(tool.name, tool.schema, {
                 description: tool.description,

package/dist/clients/google.js

@@ -134,6 +134,14 @@ export class SmolGoogle extends BaseClient {
                 toolGroups.push(entry);
             }
             genConfig.tools = toolGroups;
+            // Gemini rejects mixing built-in (server-side) tools with function calling
+            // unless the caller opts in. Only required when both kinds coexist.
+            if (tools.length > 0 && hostedEntries.length > 0) {
+                genConfig.toolConfig = {
+                    ...genConfig.toolConfig,
+                    includeServerSideToolInvocations: true,
+                };
+            }
         }
         if (config.responseFormat) {
             genConfig.responseMimeType = "application/json";
@@ -277,7 +285,11 @@ export class SmolGoogle extends BaseClient {
                 candidate.content.parts.forEach((part) => {
                     if (part.functionCall) {
                         const functionCall = part.functionCall;
-                        toolCalls.push(new ToolCall("", functionCall.name, functionCall.args));
+                        // Gemini 3 rides the thought signature on the same part as the
+                        // function call; capture it so it can be echoed back during tool use.
+                        toolCalls.push(new ToolCall("", functionCall.name, functionCall.args, {
+                            thoughtSignature: part.thoughtSignature,
+                        }));
                     }
                     else if (part.thoughtSignature) {
                         // Capture thought parts (thought: true indicates a thinking part)
@@ -352,7 +364,38 @@ export class SmolGoogle extends BaseClient {
             for (const candidate of chunk.candidates || []) {
                 for (const part of candidate?.content?.parts || []) {
                     const p = part;
-                    if (p.thoughtSignature) {
+                    // Check functionCall first: Gemini 3 attaches the thought signature to
+                    // the same part as the function call, so a thoughtSignature-first check
+                    // would misfile the tool call as a thinking block and drop it.
+                    if (p.functionCall) {
+                        const id = p.functionCall.id || p.functionCall.name || "";
+                        const name = p.functionCall.name || "";
+                        const existing = toolCallsMap.get(id);
+                        if (!existing) {
+                            toolCallsMap.set(id, {
+                                id,
+                                name,
+                                arguments: p.functionCall.args,
+                                thoughtSignature: p.thoughtSignature,
+                            });
+                        }
+                        else {
+                            // A later chunk can carry the thought signature (or fuller
+                            // args/name) for a function call first seen without them.
+                            // Backfill missing fields rather than dropping the update, so the
+                            // signature isn't lost during tool-use round trips.
+                            if (p.thoughtSignature && !existing.thoughtSignature) {
+                                existing.thoughtSignature = p.thoughtSignature;
+                            }
+                            if (p.functionCall.args && !existing.arguments) {
+                                existing.arguments = p.functionCall.args;
+                            }
+                            if (name && !existing.name) {
+                                existing.name = name;
+                            }
+                        }
+                    }
+                    else if (p.thoughtSignature) {
                         const block = {
                             text: p.text || "",
                             signature: p.thoughtSignature,
@@ -368,17 +411,6 @@ export class SmolGoogle extends BaseClient {
                         content += p.text;
                         yield { type: "text", text: p.text };
                     }
-                    else if (p.functionCall) {
-                        const id = p.functionCall.id || p.functionCall.name || "";
-                        const name = p.functionCall.name || "";
-                        if (!toolCallsMap.has(id)) {
-                            toolCallsMap.set(id, {
-                                id,
-                                name,
-                                arguments: p.functionCall.args,
-                            });
-                        }
-                    }
                 }
             }
         }
@@ -387,7 +419,9 @@ export class SmolGoogle extends BaseClient {
         // Yield tool calls
         const toolCalls = [];
         for (const tc of toolCallsMap.values()) {
-            const toolCall = new ToolCall(tc.id, tc.name, tc.arguments);
+            const toolCall = new ToolCall(tc.id, tc.name, tc.arguments, {
+                thoughtSignature: tc.thoughtSignature,
+            });
             toolCalls.push(toolCall);
             yield { type: "tool_call", toolCall };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [
@@ -28,12 +28,12 @@
   "author": "Aditya Bhargava",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.78.0",
-    "@google/genai": "^1.34.0",
+    "@anthropic-ai/sdk": "^0.109.0",
+    "@google/genai": "^2.10.0",
     "nanoid": "^5.1.6",
     "ollama": "^0.6.3",
-    "openai": "^6.15.0",
-    "zod": "^4.3.6"
+    "openai": "^6.45.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "tsx": "^4.19.2"