smoltalk 0.0.30 → 0.0.32

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

@@ -42,4 +42,16 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     toOpenAIResponseInputItem(): ResponseInputItem | ResponseInputItem[];
     toGoogleMessage(): Content;
     toOllamaMessage(): Message;
+    toAnthropicMessage(): {
+        role: "assistant";
+        content: string | Array<{
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, any>;
+        }>;
+    };
 }

package/dist/classes/message/AssistantMessage.js

@@ -112,4 +112,28 @@ export class AssistantMessage extends BaseMessage {
             tool_calls: this.toolCalls?.map((tc) => tc.toOpenAI()),
         };
     }
+    toAnthropicMessage() {
+        const hasText = this._content !== null &&
+            this._content !== undefined &&
+            (typeof this._content === "string"
+                ? this._content.length > 0
+                : this._content.length > 0);
+        const hasToolCalls = this._toolCalls && this._toolCalls.length > 0;
+        if (!hasToolCalls) {
+            return { role: "assistant", content: this.content };
+        }
+        const blocks = [];
+        if (hasText) {
+            const text = typeof this._content === "string"
+                ? this._content
+                : this._content.map((p) => p.text).join("");
+            if (text) {
+                blocks.push({ type: "text", text });
+            }
+        }
+        for (const tc of this._toolCalls) {
+            blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
+        }
+        return { role: "assistant", content: blocks };
+    }
 }

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

@@ -29,4 +29,5 @@ export declare class DeveloperMessage extends BaseMessage implements MessageClas
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;
     toOllamaMessage(): Message;
+    toAnthropicMessage(): null;
 }

package/dist/classes/message/DeveloperMessage.js

@@ -56,4 +56,9 @@ export class DeveloperMessage extends BaseMessage {
     toOllamaMessage() {
         return { role: this.role, content: this.content };
     }
+    // Developer messages are treated like system messages in Anthropic's API.
+    // Returns null to signal they should be collected into the `system` param.
+    toAnthropicMessage() {
+        return null;
+    }
 }

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

@@ -29,4 +29,5 @@ export declare class SystemMessage extends BaseMessage implements MessageClass {
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;
     toOllamaMessage(): Message;
+    toAnthropicMessage(): null;
 }

package/dist/classes/message/SystemMessage.js

@@ -56,4 +56,9 @@ export class SystemMessage extends BaseMessage {
     toOllamaMessage() {
         return { role: this.role, content: this.content };
     }
+    // System messages are passed as the top-level `system` param in Anthropic's API,
+    // not as entries in the messages array. Returns null to signal this.
+    toAnthropicMessage() {
+        return null;
+    }
 }

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

@@ -33,4 +33,12 @@ export declare class ToolMessage extends BaseMessage implements MessageClass {
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;
     toOllamaMessage(): Message;
+    toAnthropicMessage(): {
+        role: "user";
+        content: Array<{
+            type: "tool_result";
+            tool_use_id: string;
+            content: string;
+        }>;
+    };
 }

package/dist/classes/message/ToolMessage.js

@@ -83,4 +83,11 @@ export class ToolMessage extends BaseMessage {
             content: this.content,
         };
     }
+    // In Anthropic's API, tool results are user-role messages containing tool_result blocks.
+    toAnthropicMessage() {
+        return {
+            role: "user",
+            content: [{ type: "tool_result", tool_use_id: this.tool_call_id, content: this.content }],
+        };
+    }
 }

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

@@ -28,4 +28,8 @@ export declare class UserMessage extends BaseMessage implements MessageClass {
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;
     toOllamaMessage(): Message;
+    toAnthropicMessage(): {
+        role: "user";
+        content: string;
+    };
 }

package/dist/classes/message/UserMessage.js

@@ -61,4 +61,7 @@ export class UserMessage extends BaseMessage {
             content: this.content,
         };
     }
+    toAnthropicMessage() {
+        return { role: "user", content: this.content };
+    }
 }

package/dist/client.d.ts

@@ -1,9 +1,11 @@
+export * from "./clients/anthropic.js";
 export * from "./clients/google.js";
 export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
+import { SmolAnthropic } from "./clients/anthropic.js";
 import { SmolGoogle } from "./clients/google.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
 import { SmolConfig } from "./types.js";
 import { SmolOllama } from "./clients/ollama.js";
-export declare function getClient(config: SmolConfig): SmolGoogle | SmolOpenAi | SmolOpenAiResponses | SmolOllama;
+export declare function getClient(config: SmolConfig): SmolAnthropic | SmolGoogle | SmolOpenAi | SmolOpenAiResponses | SmolOllama;

package/dist/client.js

@@ -1,10 +1,12 @@
+export * from "./clients/anthropic.js";
 export * from "./clients/google.js";
 export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
+import { SmolAnthropic } from "./clients/anthropic.js";
 import { SmolGoogle } from "./clients/google.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
-import { getModel, isModelConfig, isTextModel, pickModel } from "./models.js";
+import { getModel, isModelConfig, isTextModel, pickModel, } from "./models.js";
 import { SmolError } from "./smolError.js";
 import { getLogger } from "./logger.js";
 import { SmolOllama } from "./clients/ollama.js";
@@ -28,6 +30,14 @@ export function getClient(config) {
     }
     const clientConfig = { ...config, model: modelName };
     switch (provider) {
+        case "anthropic":
+            if (!config.anthropicApiKey) {
+                throw new SmolError("No Anthropic API key provided. Please provide an Anthropic API key in the config using anthropicApiKey.");
+            }
+            return new SmolAnthropic({
+                ...clientConfig,
+                anthropicApiKey: config.anthropicApiKey,
+            });
         case "openai":
             if (!config.openAiApiKey) {
                 throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey.");

package/dist/clients/anthropic.d.ts

@@ -0,0 +1,16 @@
+import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
+import { BaseClient } from "./baseClient.js";
+export type SmolAnthropicConfig = BaseClientConfig & {
+    anthropicApiKey: string;
+};
+export declare class SmolAnthropic extends BaseClient implements SmolClient {
+    private client;
+    private logger;
+    private model;
+    constructor(config: SmolAnthropicConfig);
+    getModel(): string;
+    private calculateUsageAndCost;
+    private buildRequest;
+    _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
+    _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
+}

package/dist/clients/anthropic.js

@@ -0,0 +1,188 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { ToolCall } from "../classes/ToolCall.js";
+import { SystemMessage, DeveloperMessage, } from "../classes/message/index.js";
+import { getLogger } from "../logger.js";
+import { success, } from "../types.js";
+import { zodToAnthropicTool } from "../util/tool.js";
+import { BaseClient } from "./baseClient.js";
+import { calculateCost } from "../models.js";
+const DEFAULT_MAX_TOKENS = 4096;
+export class SmolAnthropic extends BaseClient {
+    client;
+    logger;
+    model;
+    constructor(config) {
+        super(config);
+        this.client = new Anthropic({ apiKey: config.anthropicApiKey });
+        this.logger = getLogger();
+        this.model = config.model;
+    }
+    getModel() {
+        return this.model;
+    }
+    calculateUsageAndCost(usageData) {
+        const usage = {
+            inputTokens: usageData.input_tokens,
+            outputTokens: usageData.output_tokens,
+            totalTokens: usageData.input_tokens + usageData.output_tokens,
+        };
+        const cost = calculateCost(this.model, usage) ?? undefined;
+        return { usage, cost };
+    }
+    buildRequest(config) {
+        // Split system/developer messages out into the top-level `system` param
+        const systemParts = config.messages
+            .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 = [];
+        for (const msg of config.messages) {
+            if (msg instanceof SystemMessage || msg instanceof DeveloperMessage) {
+                continue;
+            }
+            const converted = msg.toAnthropicMessage();
+            if (converted === 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);
+        }
+        const tools = config.tools && config.tools.length > 0
+            ? config.tools.map((tool) => zodToAnthropicTool(tool.name, tool.schema, {
+                description: tool.description,
+            }))
+            : undefined;
+        return { system, messages: anthropicMessages, tools };
+    }
+    async _textSync(config) {
+        const { system, messages, tools } = this.buildRequest(config);
+        this.logger.debug("Sending request to Anthropic:", {
+            model: this.model,
+            max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+            messages,
+            system,
+            tools,
+        });
+        const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+            messages,
+            ...(system && { system }),
+            ...(tools && { tools }),
+            ...(config.temperature !== undefined && {
+                temperature: config.temperature,
+            }),
+            ...(config.rawAttributes || {}),
+            stream: false,
+        });
+        this.logger.debug("Response from Anthropic:", response);
+        let output = null;
+        const toolCalls = [];
+        for (const block of response.content) {
+            if (block.type === "text") {
+                output = (output ?? "") + block.text;
+            }
+            else if (block.type === "tool_use") {
+                toolCalls.push(new ToolCall(block.id, block.name, block.input));
+            }
+        }
+        const { usage, cost } = this.calculateUsageAndCost(response.usage);
+        return success({
+            output,
+            toolCalls,
+            usage,
+            cost,
+            model: this.model,
+        });
+    }
+    async *_textStream(config) {
+        const { system, messages, tools } = this.buildRequest(config);
+        this.logger.debug("Sending streaming request to Anthropic:", {
+            model: this.model,
+            max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+            messages,
+            system,
+            tools,
+        });
+        const stream = await this.client.messages.create({
+            model: this.model,
+            max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+            messages,
+            ...(system && { system }),
+            ...(tools && { tools }),
+            ...(config.temperature !== undefined && {
+                temperature: config.temperature,
+            }),
+            ...(config.rawAttributes || {}),
+            stream: true,
+        });
+        let content = "";
+        // Track tool blocks by index: index -> { id, name, arguments (partial JSON) }
+        const toolBlocks = new Map();
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const event of stream) {
+            if (event.type === "message_start") {
+                inputTokens = event.message.usage.input_tokens;
+            }
+            else if (event.type === "content_block_start" &&
+                event.content_block.type === "tool_use") {
+                toolBlocks.set(event.index, {
+                    id: event.content_block.id,
+                    name: event.content_block.name,
+                    arguments: "",
+                });
+            }
+            else if (event.type === "content_block_delta") {
+                if (event.delta.type === "text_delta") {
+                    content += event.delta.text;
+                    yield { type: "text", text: event.delta.text };
+                }
+                else if (event.delta.type === "input_json_delta") {
+                    const block = toolBlocks.get(event.index);
+                    if (block) {
+                        block.arguments += event.delta.partial_json;
+                    }
+                }
+            }
+            else if (event.type === "message_delta") {
+                outputTokens = event.usage.output_tokens;
+            }
+        }
+        this.logger.debug("Streaming response completed from Anthropic");
+        const toolCalls = [];
+        for (const block of toolBlocks.values()) {
+            const toolCall = new ToolCall(block.id, block.name, block.arguments);
+            toolCalls.push(toolCall);
+            yield { type: "tool_call", toolCall };
+        }
+        const usage = {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+        };
+        const cost = calculateCost(this.model, usage) ?? undefined;
+        yield {
+            type: "done",
+            result: {
+                output: content || null,
+                toolCalls,
+                usage,
+                cost,
+                model: this.model,
+            },
+        };
+    }
+}

package/dist/clients/baseClient.js

@@ -131,6 +131,12 @@ export class BaseClient {
             if (inner.success)
                 return inner.data;
         }
+        // 7. Wrap object with "response" and see if that matches the schema
+        const wrapped = { response: rawValue };
+        const wrappedParse = schema.safeParse(wrapped);
+        if (wrappedParse.success) {
+            return wrappedParse.data;
+        }
         // 8. Nothing worked — throw error
         throw direct.error;
     }

package/dist/functions.js

@@ -1,13 +1,14 @@
 import { getClient } from "./client.js";
 import { isModelConfig, pickModel } from "./models.js";
 function splitConfig(config) {
-    const { openAiApiKey, googleApiKey, ollamaApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, ...promptConfig } = config;
+    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, ...promptConfig } = config;
     const model = isModelConfig(rawModel) ? pickModel(rawModel) : rawModel;
     return {
         smolConfig: {
             openAiApiKey,
             googleApiKey,
             ollamaApiKey,
+            anthropicApiKey,
             ollamaHost,
             model,
             provider,

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./smolError.js";
 export * from "./util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
+export * from "./classes/ToolCall.js";

package/dist/index.js

@@ -5,3 +5,4 @@ export * from "./smolError.js";
 export * from "./util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
+export * from "./classes/ToolCall.js";

package/dist/models.d.ts

@@ -303,25 +303,54 @@ export declare const textModels: readonly [{
     readonly costUnit: "characters";
     readonly disabled: true;
     readonly provider: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "claude-opus-4-6";
+    readonly description: "The most intelligent Claude model for building agents and coding. 200K context window, 128K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 131072;
+    readonly inputTokenCost: 5;
+    readonly outputTokenCost: 25;
+    readonly provider: "anthropic";
+}, {
+    readonly type: "text";
+    readonly modelName: "claude-sonnet-4-6";
+    readonly description: "The best combination of speed and intelligence. 200K context window, 64K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 64000;
+    readonly inputTokenCost: 3;
+    readonly outputTokenCost: 15;
+    readonly provider: "anthropic";
+}, {
+    readonly type: "text";
+    readonly modelName: "claude-haiku-4-5-20251001";
+    readonly description: "The fastest Claude model with near-frontier intelligence. 200K context window, 64K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 64000;
+    readonly inputTokenCost: 1;
+    readonly outputTokenCost: 5;
+    readonly provider: "anthropic";
 }, {
     readonly type: "text";
     readonly modelName: "claude-3-7-sonnet-latest";
-    readonly description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.";
+    readonly description: "Claude 3.7 Sonnet — legacy model. Use claude-sonnet-4-6 instead.";
     readonly maxInputTokens: 200000;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 3;
     readonly outputTokenCost: 15;
     readonly outputTokensPerSecond: 78;
+    readonly disabled: true;
     readonly provider: "anthropic";
 }, {
     readonly type: "text";
     readonly modelName: "claude-3-5-haiku-latest";
-    readonly description: "Our fastest model";
+    readonly description: "Claude 3.5 Haiku — legacy model. Use claude-haiku-4-5-20251001 instead.";
     readonly maxInputTokens: 200000;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.8;
     readonly outputTokenCost: 4;
     readonly outputTokensPerSecond: 66;
+    readonly disabled: true;
     readonly provider: "anthropic";
 }, {
     readonly type: "text";
@@ -666,25 +695,54 @@ export declare function getModel(modelName: ModelName): {
     readonly costUnit: "characters";
     readonly disabled: true;
     readonly provider: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "claude-opus-4-6";
+    readonly description: "The most intelligent Claude model for building agents and coding. 200K context window, 128K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 131072;
+    readonly inputTokenCost: 5;
+    readonly outputTokenCost: 25;
+    readonly provider: "anthropic";
+} | {
+    readonly type: "text";
+    readonly modelName: "claude-sonnet-4-6";
+    readonly description: "The best combination of speed and intelligence. 200K context window, 64K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 64000;
+    readonly inputTokenCost: 3;
+    readonly outputTokenCost: 15;
+    readonly provider: "anthropic";
+} | {
+    readonly type: "text";
+    readonly modelName: "claude-haiku-4-5-20251001";
+    readonly description: "The fastest Claude model with near-frontier intelligence. 200K context window, 64K max output.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 64000;
+    readonly inputTokenCost: 1;
+    readonly outputTokenCost: 5;
+    readonly provider: "anthropic";
 } | {
     readonly type: "text";
     readonly modelName: "claude-3-7-sonnet-latest";
-    readonly description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.";
+    readonly description: "Claude 3.7 Sonnet — legacy model. Use claude-sonnet-4-6 instead.";
     readonly maxInputTokens: 200000;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 3;
     readonly outputTokenCost: 15;
     readonly outputTokensPerSecond: 78;
+    readonly disabled: true;
     readonly provider: "anthropic";
 } | {
     readonly type: "text";
     readonly modelName: "claude-3-5-haiku-latest";
-    readonly description: "Our fastest model";
+    readonly description: "Claude 3.5 Haiku — legacy model. Use claude-haiku-4-5-20251001 instead.";
     readonly maxInputTokens: 200000;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.8;
     readonly outputTokenCost: 4;
     readonly outputTokensPerSecond: 66;
+    readonly disabled: true;
     readonly provider: "anthropic";
 } | {
     readonly type: "text";

package/dist/models.js

@@ -307,26 +307,58 @@ export const textModels = [
         disabled: true,
         provider: "google",
     },
+    {
+        type: "text",
+        modelName: "claude-opus-4-6",
+        description: "The most intelligent Claude model for building agents and coding. 200K context window, 128K max output.",
+        maxInputTokens: 200_000,
+        maxOutputTokens: 131_072,
+        inputTokenCost: 5,
+        outputTokenCost: 25,
+        provider: "anthropic",
+    },
+    {
+        type: "text",
+        modelName: "claude-sonnet-4-6",
+        description: "The best combination of speed and intelligence. 200K context window, 64K max output.",
+        maxInputTokens: 200_000,
+        maxOutputTokens: 64_000,
+        inputTokenCost: 3,
+        outputTokenCost: 15,
+        provider: "anthropic",
+    },
+    {
+        type: "text",
+        modelName: "claude-haiku-4-5-20251001",
+        description: "The fastest Claude model with near-frontier intelligence. 200K context window, 64K max output.",
+        maxInputTokens: 200_000,
+        maxOutputTokens: 64_000,
+        inputTokenCost: 1,
+        outputTokenCost: 5,
+        provider: "anthropic",
+    },
     {
         type: "text",
         modelName: "claude-3-7-sonnet-latest",
-        description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.",
+        description: "Claude 3.7 Sonnet — legacy model. Use claude-sonnet-4-6 instead.",
         maxInputTokens: 200_000,
         maxOutputTokens: 8192,
         inputTokenCost: 3,
         outputTokenCost: 15,
         outputTokensPerSecond: 78,
+        disabled: true,
         provider: "anthropic",
     },
     {
         type: "text",
         modelName: "claude-3-5-haiku-latest",
-        description: "Our fastest model",
+        description: "Claude 3.5 Haiku — legacy model. Use claude-haiku-4-5-20251001 instead.",
         maxInputTokens: 200_000,
         maxOutputTokens: 8192,
         inputTokenCost: 0.8,
         outputTokenCost: 4,
         outputTokensPerSecond: 66,
+        disabled: true,
         provider: "anthropic",
     },
     /*  {

package/dist/types.d.ts

@@ -31,6 +31,7 @@ export type PromptConfig = {
 export type SmolConfig = {
     openAiApiKey?: string;
     googleApiKey?: string;
+    anthropicApiKey?: string;
     ollamaApiKey?: string;
     ollamaHost?: string;
     model: ModelName | ModelConfig;

package/dist/util/tool.d.ts

@@ -29,6 +29,18 @@ export declare function zodToOpenAIResponsesTool(name: string, schema: z.ZodType
     description?: string;
     strict?: boolean;
 }>): OpenAIResponsesFunctionTool;
+export type AnthropicTool = {
+    name: string;
+    description?: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+};
+export declare function zodToAnthropicTool(name: string, schema: z.ZodType, options?: Partial<{
+    description?: string;
+}>): AnthropicTool;
 /**
  * Converts an OpenAI tool definition to a Google FunctionDeclaration format
  *

package/dist/util/tool.js

@@ -62,6 +62,30 @@ export function zodToOpenAIResponsesTool(name, schema, options = {}) {
     }
     return tool;
 }
+export function zodToAnthropicTool(name, schema, options = {}) {
+    const jsonSchema = schema.toJSONSchema();
+    let description;
+    if (options?.description) {
+        description = options.description;
+    }
+    else if (typeof jsonSchema === "object" &&
+        "description" in jsonSchema &&
+        typeof jsonSchema.description === "string") {
+        description = jsonSchema.description;
+    }
+    const tool = {
+        name,
+        input_schema: {
+            type: "object",
+            properties: jsonSchema.properties || {},
+            required: jsonSchema.required || [],
+        },
+    };
+    if (description) {
+        tool.description = description;
+    }
+    return tool;
+}
 /**
  * Removes properties that Google's API doesn't support from JSON schemas
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {
@@ -41,6 +41,7 @@
     "zod": "^4.3.5"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
     "@google/genai": "^1.34.0",
     "egonlog": "^0.0.2",
     "ollama": "^0.6.3",