smoltalk 0.4.0 → 0.4.2

package/dist/classes/ToolCall.js

@@ -47,9 +47,10 @@ export class ToolCall {
     static fromJSON(json) {
         const result = ToolCallJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse ToolCall");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse ToolCall:", z.prettifyError(result.error));
+            // Raw payload can contain tool-call arguments (often secrets) — only at debug level.
+            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);

package/dist/classes/message/AssistantMessage.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
 import { CostEstimateSchema, TextPartSchema, ThinkingBlockSchema, TokenUsageSchema, } from "../../types.js";
 import { ToolCall, ToolCallJSONSchema } from "../ToolCall.js";
+import { getLogger } from "../../util/logger.js";
 export const AssistantMessageJSONSchema = z.object({
     role: z.literal("assistant"),
     content: z.union([z.string(), z.array(TextPartSchema), z.null()]),
@@ -86,9 +87,10 @@ export class AssistantMessage extends BaseMessage {
     static fromJSON(json) {
         const result = AssistantMessageJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse AssistantMessage");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse AssistantMessage:", z.prettifyError(result.error));
+            // Raw payload can contain assistant content / tool args — only at debug level.
+            logger.debug("AssistantMessage payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse AssistantMessage");
         }
         return new AssistantMessage(result.data.content, {

package/dist/classes/message/DeveloperMessage.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
 import { TextPartSchema } from "../../types.js";
+import { getLogger } from "../../util/logger.js";
 export const DeveloperMessageJSONSchema = z.object({
     role: z.literal("developer"),
     content: z.union([z.string(), z.array(TextPartSchema)]),
@@ -43,9 +44,10 @@ export class DeveloperMessage extends BaseMessage {
     static fromJSON(json) {
         const result = DeveloperMessageJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse DeveloperMessage");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse DeveloperMessage:", z.prettifyError(result.error));
+            // Raw payload can contain developer-message content — only at debug level.
+            logger.debug("DeveloperMessage payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse DeveloperMessage");
         }
         return new DeveloperMessage(result.data.content, {

package/dist/classes/message/SystemMessage.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
 import { TextPartSchema } from "../../types.js";
+import { getLogger } from "../../util/logger.js";
 export const SystemMessageJSONSchema = z.object({
     role: z.literal("system"),
     content: z.union([z.string(), z.array(TextPartSchema)]),
@@ -43,9 +44,10 @@ export class SystemMessage extends BaseMessage {
     static fromJSON(json) {
         const result = SystemMessageJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse SystemMessage");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse SystemMessage:", z.prettifyError(result.error));
+            // Raw payload can contain system prompt content — only at debug level.
+            logger.debug("SystemMessage payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse SystemMessage");
         }
         return new SystemMessage(result.data.content, {

package/dist/classes/message/ToolMessage.js

@@ -52,9 +52,10 @@ export class ToolMessage extends BaseMessage {
     static fromJSON(json) {
         const result = ToolMessageJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse ToolMessage");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse ToolMessage:", z.prettifyError(result.error));
+            // Raw payload can contain tool results (file paths, secrets) — only at debug level.
+            logger.debug("ToolMessage payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse ToolMessage");
         }
         const TextPartArraySchema = z.array(TextPartSchema);

package/dist/classes/message/UserMessage.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
+import { getLogger } from "../../util/logger.js";
 export const UserMessageJSONSchema = z.object({
     role: z.literal("user"),
     content: z.string(),
@@ -42,9 +43,10 @@ export class UserMessage extends BaseMessage {
     static fromJSON(json) {
         const result = UserMessageJSONSchema.safeParse(json);
         if (!result.success) {
-            console.error("Failed to parse UserMessage");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
+            const logger = getLogger();
+            logger.error("Failed to parse UserMessage:", z.prettifyError(result.error));
+            // Raw payload can contain user prompts / PII — only at debug level.
+            logger.debug("UserMessage payload that failed to parse:", JSON.stringify(json, null, 2));
             throw new Error("Failed to parse UserMessage");
         }
         return new UserMessage(result.data.content, {

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

@@ -4,10 +4,25 @@ import { SystemMessage, DeveloperMessage } from "../classes/message/index.js";
 import { getLogger } from "../util/logger.js";
 import { success, } from "../types.js";
 import { zodToAnthropicTool } from "../util/tool.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.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
@@ -152,49 +167,72 @@ export class SmolAnthropic extends BaseClient {
                 description: tool.description,
             }))
             : undefined;
-        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;
+        // 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 };
+        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 budget_tokens = wantsThinking
+            ? (config.thinking?.budgetTokens ?? 5000)
+            : reasoningBudgetMap[effort];
+        return {
+            thinking: { type: "enabled", budget_tokens },
+            outputConfig: undefined,
+        };
     }
     rethrowAsSmolError(error) {
         if (error instanceof Anthropic.APIError) {
+            const http = { ...extractHttpErrorFields(error), cause: error };
             const msg = error.message.toLowerCase();
             if (msg.includes("prompt is too long") ||
                 msg.includes("context length") ||
                 msg.includes("context window") ||
                 msg.includes("too many tokens")) {
-                throw new SmolContextWindowExceededError(error.message);
+                throw new SmolContextWindowExceededError(error.message, http);
             }
             if (msg.includes("content policy") ||
                 msg.includes("usage policies") ||
                 msg.includes("content filtering") ||
                 msg.includes("violates our")) {
-                throw new SmolContentPolicyError(error.message);
+                throw new SmolContentPolicyError(error.message, http);
             }
+            throw smolErrorForStatus(error.message, http);
         }
         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,
@@ -202,6 +240,7 @@ export class SmolAnthropic extends BaseClient {
             system,
             tools,
             thinking,
+            output_config: outputConfig,
         };
         this.logger.debug("Sending request to Anthropic:", debugData);
         this.statelogClient?.promptRequest(debugData);
@@ -215,6 +254,7 @@ export class SmolAnthropic extends BaseClient {
                 ...(system && { system }),
                 ...(tools && { tools }),
                 ...(thinking && { thinking }),
+                ...(outputConfig && { output_config: outputConfig }),
                 ...(config.temperature !== undefined && {
                     temperature: config.temperature,
                 }),
@@ -253,7 +293,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,
@@ -261,6 +301,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);
@@ -274,6 +315,7 @@ export class SmolAnthropic extends BaseClient {
                 ...(system && { system }),
                 ...(tools && { tools }),
                 ...(thinking && { thinking }),
+                ...(outputConfig && { output_config: outputConfig }),
                 ...(config.temperature !== undefined && {
                     temperature: config.temperature,
                 }),

package/dist/clients/google.d.ts

@@ -17,6 +17,7 @@ export declare class SmolGoogle extends BaseClient implements SmolClient {
     getModel(): ModelName;
     private calculateUsageAndCost;
     private buildRequest;
+    private rethrowAsSmolError;
     _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
     __textSync(request: GeneratedRequest): Promise<Result<PromptResult>>;
     _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;

package/dist/clients/google.js

@@ -3,7 +3,8 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../util/logger.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { BaseClient } from "./baseClient.js";
 import { Model } from "../model.js";
@@ -88,6 +89,18 @@ export class SmolGoogle extends BaseClient {
             ...sanitizeAttributes(config.rawAttributes),
         };
     }
+    rethrowAsSmolError(error) {
+        const http = { ...extractHttpErrorFields(error), cause: error };
+        const msg = (error.message || "").toLowerCase();
+        if (msg.includes("token") &&
+            (msg.includes("exceed") || msg.includes("too long") || msg.includes("limit"))) {
+            throw new SmolContextWindowExceededError(error.message, http);
+        }
+        if (http.status !== undefined) {
+            throw smolErrorForStatus(error.message, http);
+        }
+        throw error;
+    }
     async _textSync(config) {
         const signal = this.getAbortSignal(config);
         const request = {
@@ -180,14 +193,7 @@ export class SmolGoogle extends BaseClient {
             result = await this.client.models.generateContent(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("token") &&
-                (msg.includes("exceed") ||
-                    msg.includes("too long") ||
-                    msg.includes("limit"))) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         this.logger.debug("Response from Google Gemini:", JSON.stringify(result, null, 2));
         this.statelogClient?.promptResponse(result);
@@ -257,14 +263,7 @@ export class SmolGoogle extends BaseClient {
             stream = await this.client.models.generateContentStream(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("token") &&
-                (msg.includes("exceed") ||
-                    msg.includes("too long") ||
-                    msg.includes("limit"))) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         let content = "";
         const toolCallsMap = new Map();

package/dist/clients/ollama.d.ts

@@ -12,6 +12,7 @@ export declare class SmolOllama extends BaseClient implements SmolClient {
     getClient(): Ollama;
     getModel(): ModelName;
     private calculateUsageAndCost;
+    private rethrowAsSmolError;
     _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
     _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }

package/dist/clients/ollama.js

@@ -5,7 +5,8 @@ import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { BaseClient } from "./baseClient.js";
-import { SmolContextWindowExceededError } from "../smolError.js";
+import { SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { Model } from "../model.js";
 export const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
 export class SmolOllama extends BaseClient {
@@ -51,6 +52,17 @@ export class SmolOllama extends BaseClient {
         }
         return { usage, cost };
     }
+    rethrowAsSmolError(error) {
+        const http = { ...extractHttpErrorFields(error), cause: error };
+        const msg = (error.message || "").toLowerCase();
+        if (msg.includes("context length") || msg.includes("context window")) {
+            throw new SmolContextWindowExceededError(error.message, http);
+        }
+        if (http.status !== undefined) {
+            throw smolErrorForStatus(error.message, http);
+        }
+        throw error;
+    }
     async _textSync(config) {
         const messages = config.messages.map((msg) => msg.toOpenAIMessage());
         const tools = (config.tools || []).map((tool) => {
@@ -82,11 +94,7 @@ export class SmolOllama extends BaseClient {
             result = await this.client.chat(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("context length") || msg.includes("context window")) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         finally {
             if (signal && abortHandler) {
@@ -201,6 +209,9 @@ export class SmolOllama extends BaseClient {
                 },
             };
         }
+        catch (error) {
+            this.rethrowAsSmolError(error);
+        }
         finally {
             if (signal && abortHandler) {
                 signal.removeEventListener("abort", abortHandler);

package/dist/clients/openai.js

@@ -4,7 +4,8 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { isFunctionToolCall, sanitizeAttributes } from "../util/util.js";
 import { getLogger } from "../util/logger.js";
 import { BaseClient } from "./baseClient.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { zodToOpenAITool } from "../util/tool.js";
 import { Model } from "../model.js";
 export class SmolOpenAi extends BaseClient {
@@ -74,12 +75,14 @@ export class SmolOpenAi extends BaseClient {
     }
     rethrowAsSmolError(error) {
         if (error instanceof OpenAI.APIError) {
+            const http = { ...extractHttpErrorFields(error), cause: error };
             if (error.code === "context_length_exceeded") {
-                throw new SmolContextWindowExceededError(error.message);
+                throw new SmolContextWindowExceededError(error.message, http);
             }
             if (error.code === "content_policy_violation") {
-                throw new SmolContentPolicyError(error.message);
+                throw new SmolContentPolicyError(error.message, http);
             }
+            throw smolErrorForStatus(error.message, http);
         }
         throw error;
     }

package/dist/clients/openaiResponses.js

@@ -6,7 +6,8 @@ import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { Model } from "../model.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 export class SmolOpenAiResponses extends BaseClient {
     client;
     logger;
@@ -107,12 +108,14 @@ export class SmolOpenAiResponses extends BaseClient {
     }
     rethrowAsSmolError(error) {
         if (error instanceof OpenAI.APIError) {
+            const http = { ...extractHttpErrorFields(error), cause: error };
             if (error.code === "context_length_exceeded") {
-                throw new SmolContextWindowExceededError(error.message);
+                throw new SmolContextWindowExceededError(error.message, http);
             }
             if (error.code === "content_policy_violation") {
-                throw new SmolContentPolicyError(error.message);
+                throw new SmolContentPolicyError(error.message, http);
             }
+            throw smolErrorForStatus(error.message, http);
         }
         throw error;
     }