smoltalk 0.7.1 → 0.8.0

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/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.0",
   "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"