smoltalk 0.3.1 → 0.4.1

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

@@ -29,12 +29,14 @@ export declare const AssistantMessageJSONSchema: z.ZodObject<{
         inputTokens: z.ZodNumber;
         outputTokens: z.ZodNumber;
         cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
         totalTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     cost: z.ZodOptional<z.ZodObject<{
         inputCost: z.ZodNumber;
         outputCost: z.ZodNumber;
         cachedInputCost: z.ZodOptional<z.ZodNumber>;
+        cacheCreationInputCost: z.ZodOptional<z.ZodNumber>;
         totalCost: z.ZodNumber;
         currency: z.ZodString;
     }, z.core.$strip>>;

package/dist/clients/anthropic.d.ts

@@ -12,6 +12,13 @@ export declare class SmolAnthropic extends BaseClient implements SmolClient {
     getModel(): ModelName;
     private calculateUsageAndCost;
     private buildRequest;
+    /**
+     * Translate `thinking` / `reasoningEffort` into the correct Anthropic
+     * parameters for this model. Callers shouldn't have to know whether a model
+     * speaks the legacy `budget_tokens` API or the newer adaptive + effort API —
+     * that's exactly the vendor difference this package smooths over.
+     */
+    private resolveThinking;
     private rethrowAsSmolError;
     _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
     _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;

package/dist/clients/anthropic.js

@@ -6,8 +6,98 @@ import { success, } from "../types.js";
 import { zodToAnthropicTool } from "../util/tool.js";
 import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
 import { BaseClient } from "./baseClient.js";
+import { getModel, isTextModel } from "../models.js";
 import { Model } from "../model.js";
 const DEFAULT_MAX_TOKENS = 4096;
+/**
+ * Which thinking API a model speaks. New flagship Anthropic models (Opus 4.7+)
+ * reject the legacy `{type: "enabled", budget_tokens}` form with a 400, so we
+ * default unknown/unregistered models to "adaptive" (the forward-looking shape)
+ * rather than the form that's being phased out.
+ */
+function thinkingStyleFor(modelName) {
+    const model = getModel(modelName);
+    if (model && isTextModel(model) && model.reasoning?.thinkingStyle) {
+        return model.reasoning.thinkingStyle;
+    }
+    return "adaptive";
+}
+/**
+ * Attach ephemeral cache_control breakpoints to (up to) three places:
+ *   1. the last tool definition
+ *   2. the last system block (promoting system from string to array form)
+ *   3. the last block of the last user message
+ *
+ * Anthropic enforces minimum prefix sizes; smaller prefixes silently no-op.
+ */
+function applyCacheBreakpoints(req) {
+    const cc = { type: "ephemeral" };
+    // Tools: mark the last tool.
+    let tools = req.tools;
+    if (tools && tools.length > 0) {
+        const lastIdx = tools.length - 1;
+        const marked = [];
+        for (let i = 0; i < tools.length; i++) {
+            if (i === lastIdx) {
+                marked.push({ ...tools[i], cache_control: cc });
+            }
+            else {
+                marked.push(tools[i]);
+            }
+        }
+        tools = marked;
+    }
+    // System: promote string to array form so the last block can be marked.
+    let system = req.system;
+    if (typeof system === "string" && system.length > 0) {
+        system = [{ type: "text", text: system, cache_control: cc }];
+    }
+    else if (Array.isArray(system) && system.length > 0) {
+        const lastIdx = system.length - 1;
+        const marked = [];
+        for (let i = 0; i < system.length; i++) {
+            if (i === lastIdx) {
+                marked.push({ ...system[i], cache_control: cc });
+            }
+            else {
+                marked.push(system[i]);
+            }
+        }
+        system = marked;
+    }
+    // Messages: mark the last block of the last user message.
+    let messages = req.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== "user")
+            continue;
+        let blocks;
+        if (typeof m.content === "string") {
+            blocks = [{ type: "text", text: m.content }];
+        }
+        else {
+            blocks = [...m.content];
+        }
+        if (blocks.length === 0)
+            break;
+        blocks[blocks.length - 1] = {
+            ...blocks[blocks.length - 1],
+            cache_control: cc,
+        };
+        const rebuilt = [];
+        for (let j = 0; j < messages.length; j++) {
+            if (j === i) {
+                rebuilt.push({ ...m, content: blocks });
+            }
+            else {
+                rebuilt.push(messages[j]);
+            }
+        }
+        messages = rebuilt;
+        break;
+    }
+    return { system, messages, tools };
+}
 export class SmolAnthropic extends BaseClient {
     client;
     logger;
@@ -22,11 +112,22 @@ export class SmolAnthropic extends BaseClient {
         return this.model.getModel();
     }
     calculateUsageAndCost(usageData) {
+        const cacheRead = usageData.cache_read_input_tokens ?? 0;
+        const cacheCreation = usageData.cache_creation_input_tokens ?? 0;
         const usage = {
             inputTokens: usageData.input_tokens,
             outputTokens: usageData.output_tokens,
-            totalTokens: usageData.input_tokens + usageData.output_tokens,
+            totalTokens: usageData.input_tokens +
+                cacheRead +
+                cacheCreation +
+                usageData.output_tokens,
         };
+        if (cacheRead > 0) {
+            usage.cachedInputTokens = cacheRead;
+        }
+        if (cacheCreation > 0) {
+            usage.cacheCreationInputTokens = cacheCreation;
+        }
         const cost = this.model.calculateCost(usage) ?? undefined;
         return { usage, cost };
     }
@@ -65,23 +166,49 @@ export class SmolAnthropic extends BaseClient {
                 description: tool.description,
             }))
             : undefined;
+        // Normalize the user's provider-agnostic thinking/effort config into the
+        // shape this specific model accepts. Both `thinking.enabled` and
+        // `reasoningEffort` are treated as a request to think.
+        const { thinking, outputConfig } = this.resolveThinking(config);
+        const cachingEnabled = config.caching?.enabled !== false;
+        const baseRequest = { system, messages: anthropicMessages, tools };
+        const finalRequest = cachingEnabled
+            ? applyCacheBreakpoints(baseRequest)
+            : baseRequest;
+        return { ...finalRequest, thinking, outputConfig };
+    }
+    /**
+     * Translate `thinking` / `reasoningEffort` into the correct Anthropic
+     * parameters for this model. Callers shouldn't have to know whether a model
+     * speaks the legacy `budget_tokens` API or the newer adaptive + effort API —
+     * that's exactly the vendor difference this package smooths over.
+     */
+    resolveThinking(config) {
+        const wantsThinking = config.thinking?.enabled === true;
+        const effort = config.reasoningEffort;
+        if (!wantsThinking && !effort) {
+            return { thinking: undefined, outputConfig: undefined };
+        }
+        if (thinkingStyleFor(this.getModel()) === "adaptive") {
+            // `output_config.effort` controls depth; the budget is irrelevant here.
+            return {
+                thinking: { type: "adaptive" },
+                outputConfig: effort ? { effort } : undefined,
+            };
+        }
+        // Legacy budget-based thinking (Haiku 4.5 and older models).
         const reasoningBudgetMap = {
             low: 2048,
             medium: 5000,
             high: 10000,
         };
-        const thinking = config.thinking?.enabled
-            ? {
-                type: "enabled",
-                budget_tokens: config.thinking.budgetTokens ?? 5000,
-            }
-            : config.reasoningEffort
-                ? {
-                    type: "enabled",
-                    budget_tokens: reasoningBudgetMap[config.reasoningEffort],
-                }
-                : undefined;
-        return { system, messages: anthropicMessages, tools, thinking };
+        const budget_tokens = wantsThinking
+            ? (config.thinking?.budgetTokens ?? 5000)
+            : reasoningBudgetMap[effort];
+        return {
+            thinking: { type: "enabled", budget_tokens },
+            outputConfig: undefined,
+        };
     }
     rethrowAsSmolError(error) {
         if (error instanceof Anthropic.APIError) {
@@ -102,7 +229,7 @@ export class SmolAnthropic extends BaseClient {
         throw error;
     }
     async _textSync(config) {
-        const { system, messages, tools, thinking } = this.buildRequest(config);
+        const { system, messages, tools, thinking, outputConfig } = this.buildRequest(config);
         let debugData = {
             model: this.getModel(),
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
@@ -110,6 +237,7 @@ export class SmolAnthropic extends BaseClient {
             system,
             tools,
             thinking,
+            output_config: outputConfig,
         };
         this.logger.debug("Sending request to Anthropic:", debugData);
         this.statelogClient?.promptRequest(debugData);
@@ -123,6 +251,7 @@ export class SmolAnthropic extends BaseClient {
                 ...(system && { system }),
                 ...(tools && { tools }),
                 ...(thinking && { thinking }),
+                ...(outputConfig && { output_config: outputConfig }),
                 ...(config.temperature !== undefined && {
                     temperature: config.temperature,
                 }),
@@ -161,7 +290,7 @@ export class SmolAnthropic extends BaseClient {
         });
     }
     async *_textStream(config) {
-        const { system, messages, tools, thinking } = this.buildRequest(config);
+        const { system, messages, tools, thinking, outputConfig } = this.buildRequest(config);
         const streamDebugData = {
             model: this.model,
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
@@ -169,6 +298,7 @@ export class SmolAnthropic extends BaseClient {
             system,
             tools,
             thinking,
+            output_config: outputConfig,
         };
         this.logger.debug("Sending streaming request to Anthropic:", streamDebugData);
         this.statelogClient?.promptRequest(streamDebugData);
@@ -182,6 +312,7 @@ export class SmolAnthropic extends BaseClient {
                 ...(system && { system }),
                 ...(tools && { tools }),
                 ...(thinking && { thinking }),
+                ...(outputConfig && { output_config: outputConfig }),
                 ...(config.temperature !== undefined && {
                     temperature: config.temperature,
                 }),
@@ -198,10 +329,15 @@ export class SmolAnthropic extends BaseClient {
         // Track thinking blocks by index: index -> { text, signature }
         const thinkingBlockMap = new Map();
         let inputTokens = 0;
+        let cacheReadTokens = 0;
+        let cacheCreationTokens = 0;
         let outputTokens = 0;
         for await (const event of stream) {
             if (event.type === "message_start") {
-                inputTokens = event.message.usage.input_tokens;
+                const u = event.message.usage;
+                inputTokens = u.input_tokens;
+                cacheReadTokens = u.cache_read_input_tokens ?? 0;
+                cacheCreationTokens = u.cache_creation_input_tokens ?? 0;
             }
             else if (event.type === "content_block_start") {
                 if (event.content_block.type === "tool_use") {
@@ -252,6 +388,15 @@ export class SmolAnthropic extends BaseClient {
             }
             else if (event.type === "message_delta") {
                 outputTokens = event.usage.output_tokens;
+                // Defensive: in practice Anthropic only sends cache fields on
+                // message_start, but read them here too so we don't miss an
+                // update if the SDK changes.
+                if (event.usage.cache_read_input_tokens != null) {
+                    cacheReadTokens = event.usage.cache_read_input_tokens;
+                }
+                if (event.usage.cache_creation_input_tokens != null) {
+                    cacheCreationTokens = event.usage.cache_creation_input_tokens;
+                }
             }
         }
         this.logger.debug("Streaming response completed from Anthropic");
@@ -269,8 +414,14 @@ export class SmolAnthropic extends BaseClient {
         const usage = {
             inputTokens,
             outputTokens,
-            totalTokens: inputTokens + outputTokens,
+            totalTokens: inputTokens + cacheReadTokens + cacheCreationTokens + outputTokens,
         };
+        if (cacheReadTokens > 0) {
+            usage.cachedInputTokens = cacheReadTokens;
+        }
+        if (cacheCreationTokens > 0) {
+            usage.cacheCreationInputTokens = cacheCreationTokens;
+        }
         const cost = this.model.calculateCost(usage) ?? undefined;
         yield {
             type: "done",

package/dist/clients/google.js

@@ -31,12 +31,15 @@ export class SmolGoogle extends BaseClient {
         let usage;
         let cost;
         if (usageMetadata) {
+            const cached = usageMetadata.cachedContentTokenCount ?? 0;
             usage = {
-                inputTokens: usageMetadata.promptTokenCount || 0,
+                inputTokens: Math.max(0, (usageMetadata.promptTokenCount || 0) - cached),
                 outputTokens: usageMetadata.candidatesTokenCount || 0,
-                cachedInputTokens: usageMetadata.cachedContentTokenCount,
                 totalTokens: usageMetadata.totalTokenCount,
             };
+            if (cached > 0) {
+                usage.cachedInputTokens = cached;
+            }
             const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;

package/dist/clients/openai.js

@@ -30,12 +30,15 @@ export class SmolOpenAi extends BaseClient {
         let usage;
         let cost;
         if (usageData) {
+            const cached = usageData.prompt_tokens_details?.cached_tokens ?? 0;
             usage = {
-                inputTokens: usageData.prompt_tokens || 0,
+                inputTokens: Math.max(0, (usageData.prompt_tokens || 0) - cached),
                 outputTokens: usageData.completion_tokens || 0,
-                cachedInputTokens: usageData.prompt_tokens_details?.cached_tokens,
                 totalTokens: usageData.total_tokens,
             };
+            if (cached > 0) {
+                usage.cachedInputTokens = cached;
+            }
             const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;

package/dist/clients/openaiResponses.js

@@ -89,12 +89,15 @@ export class SmolOpenAiResponses extends BaseClient {
         let usage;
         let cost;
         if (usageData) {
+            const cached = usageData.input_tokens_details?.cached_tokens ?? 0;
             usage = {
-                inputTokens: usageData.input_tokens || 0,
+                inputTokens: Math.max(0, (usageData.input_tokens || 0) - cached),
                 outputTokens: usageData.output_tokens || 0,
-                cachedInputTokens: usageData.input_tokens_details?.cached_tokens,
                 totalTokens: usageData.total_tokens,
             };
+            if (cached > 0) {
+                usage.cachedInputTokens = cached;
+            }
             const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;

package/dist/model.d.ts

@@ -11,10 +11,12 @@ export declare class Model {
         inputTokens: number;
         outputTokens: number;
         cachedInputTokens?: number;
+        cacheCreationInputTokens?: number;
     }): {
         inputCost: number;
         outputCost: number;
         cachedInputCost?: number;
+        cacheCreationInputCost?: number;
         totalCost: number;
         currency: string;
     } | null;

package/dist/model.js

@@ -26,16 +26,49 @@ export class Model {
         if (!model || !isTextModel(model)) {
             return null;
         }
+        const cachedTokens = usage.cachedInputTokens ?? 0;
+        const cacheCreationTokens = usage.cacheCreationInputTokens ?? 0;
+        // Disjoint buckets. If a discount price isn't defined for this model,
+        // the tokens were still billed by the provider — charge them at the
+        // full input rate so totalCost stays honest.
+        const cachedRate = model.cachedInputTokenCost ?? model.inputTokenCost ?? 0;
+        const cacheCreationRate = model.cacheCreationInputTokenCost ?? model.inputTokenCost ?? 0;
         const inputCost = round((usage.inputTokens * (model.inputTokenCost || 0)) / 1_000_000, 6);
         const outputCost = round((usage.outputTokens * (model.outputTokenCost || 0)) / 1_000_000, 6);
-        const cachedInputCost = usage.cachedInputTokens && model.cachedInputTokenCost
-            ? round((usage.cachedInputTokens * model.cachedInputTokenCost) / 1_000_000, 6)
-            : undefined;
-        const totalCost = round(inputCost + outputCost + (cachedInputCost || 0), 6);
+        // Only expose cachedInputCost / cacheCreationInputCost when the model
+        // actually has a distinct discount price. Otherwise, fold those dollars
+        // into inputCost so the user isn't misled by a $0 cached field.
+        let cachedInputCost;
+        let cacheCreationInputCost;
+        let foldedInputDollars = 0;
+        if (cachedTokens > 0) {
+            const dollars = (cachedTokens * cachedRate) / 1_000_000;
+            if (model.cachedInputTokenCost != null) {
+                cachedInputCost = round(dollars, 6);
+            }
+            else {
+                foldedInputDollars += dollars;
+            }
+        }
+        if (cacheCreationTokens > 0) {
+            const dollars = (cacheCreationTokens * cacheCreationRate) / 1_000_000;
+            if (model.cacheCreationInputTokenCost != null) {
+                cacheCreationInputCost = round(dollars, 6);
+            }
+            else {
+                foldedInputDollars += dollars;
+            }
+        }
+        const finalInputCost = round(inputCost + foldedInputDollars, 6);
+        const totalCost = round(finalInputCost +
+            outputCost +
+            (cachedInputCost || 0) +
+            (cacheCreationInputCost || 0), 6);
         return {
-            inputCost,
+            inputCost: finalInputCost,
             outputCost,
             cachedInputCost,
+            cacheCreationInputCost,
             totalCost,
             currency: "USD",
         };