smoltalk 0.13.0 → 0.13.2

package/dist/clients/anthropic.d.ts

@@ -1,3 +1,4 @@
+import Anthropic from "@anthropic-ai/sdk";
 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";
@@ -13,6 +14,16 @@ export declare function mergeConsecutiveMessages(messages: MessageParam[]): Mess
  * supported (forward-looking).
  */
 export declare function anthropicSupportsStructuredOutput(model: string): boolean;
+/**
+ * A 400 whose message is only the generic "Invalid request data", with no
+ * field named, is not a malformed request. Anthropic returns it seconds into
+ * generation, intermittently, for a request that succeeds unchanged on the
+ * next try (seen with `output_config.format` plus tools on Opus 4.8). A real
+ * validation failure always names what it rejected, e.g.
+ * `messages.1.content: ...`. Treat the bare form as transient so it is retried
+ * like a 5xx.
+ */
+export declare function isBareInvalidRequest(error: InstanceType<typeof Anthropic.APIError>): boolean;
 export declare function anthropicWebSearchEntries(hostedTools?: string[]): any[];
 export declare function parseAnthropicHostedTools(response: any, provider: string): HostedToolResult[];
 type EphemeralCacheControl = {

package/dist/clients/anthropic.js

@@ -8,7 +8,7 @@ import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hosted
 import { zodToAnthropicTool } from "../util/tool.js";
 import { responseFormatToJsonSchema } from "../util/jsonSchema.js";
 import { normalizeAnthropicStopReason } from "../util/stopReason.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, SmolOverloadedError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
 import { BaseClient } from "./baseClient.js";
 import { getModel, isTextModel } from "../models.js";
@@ -60,6 +60,27 @@ export function mergeConsecutiveMessages(messages) {
 export function anthropicSupportsStructuredOutput(model) {
     return !/^claude-(?:3(?:[-.]|$)|2(?:[-.]|$)|instant(?:[-.]|$))/i.test(model);
 }
+/**
+ * A 400 whose message is only the generic "Invalid request data", with no
+ * field named, is not a malformed request. Anthropic returns it seconds into
+ * generation, intermittently, for a request that succeeds unchanged on the
+ * next try (seen with `output_config.format` plus tools on Opus 4.8). A real
+ * validation failure always names what it rejected, e.g.
+ * `messages.1.content: ...`. Treat the bare form as transient so it is retried
+ * like a 5xx.
+ */
+export function isBareInvalidRequest(error) {
+    if (error.status !== 400) {
+        return false;
+    }
+    const body = error.error;
+    const bodyMessage = body?.error?.message;
+    if (typeof bodyMessage === "string") {
+        return bodyMessage.trim() === BARE_INVALID_REQUEST;
+    }
+    return error.message.trim() === BARE_INVALID_REQUEST;
+}
+const BARE_INVALID_REQUEST = "Invalid request data";
 export function anthropicWebSearchEntries(hostedTools) {
     if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
         return [{ type: "web_search_20250305", name: "web_search" }];
@@ -333,6 +354,9 @@ export class SmolAnthropic extends BaseClient {
                 msg.includes("violates our")) {
                 throw new SmolContentPolicyError(error.message, http);
             }
+            if (isBareInvalidRequest(error)) {
+                throw new SmolOverloadedError(error.message, http);
+            }
             throw smolErrorForStatus(error.message, http);
         }
         throw error;

package/dist/clients/google.js

@@ -4,7 +4,7 @@ import { getLogger } from "../util/logger.js";
 import { redactAttachments } from "../util/redact.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
-import { responseFormatToJsonSchema } from "../util/jsonSchema.js";
+import { responseFormatToJsonSchema, constToEnum } from "../util/jsonSchema.js";
 import { normalizeGoogleStopReason } from "../util/stopReason.js";
 import { SmolError, SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
@@ -297,7 +297,8 @@ export class SmolGoogle extends BaseClient {
         }
         if (config.responseFormat) {
             genConfig.responseMimeType = "application/json";
-            genConfig.responseJsonSchema = responseFormatToJsonSchema(config.responseFormat);
+            // Gemini ignores `const` but honours `enum`; see constToEnum.
+            genConfig.responseJsonSchema = constToEnum(responseFormatToJsonSchema(config.responseFormat));
         }
         if (config.thinking?.enabled) {
             // Gemini only returns thought-summary parts (parts with `thought: true`,
@@ -520,7 +521,7 @@ export class SmolGoogle extends BaseClient {
         const hasTools = config.tools && config.tools.length > 0;
         const hasStructuredResponse = !!config.responseFormat;
         if (hasTools && hasStructuredResponse) {
-            this.logger.debug("Gemini does not support streaming responses with both tool calls and structured response formats. Response format will be ignored.");
+            this.logger.warn("Gemini does not support streaming responses with both tool calls and structured response formats. Response format will be ignored.");
             this.statelogClient?.debug("Google Gemini: streaming with tools + structured response not supported, ignoring response format", {});
             request.config.responseMimeType = undefined;
             request.config.responseJsonSchema = undefined;

package/dist/smolError.d.ts

@@ -72,7 +72,9 @@ export declare class SmolContextWindowExceededError extends SmolError {
 export declare class SmolRateLimitError extends SmolError {
     constructor(message: string, options?: SmolErrorOptions);
 }
-/** Provider temporarily overloaded/unavailable (HTTP 503, or Anthropic's 529). */
+/** Provider temporarily overloaded/unavailable (HTTP 503, or Anthropic's 529).
+ *  Also raised for Anthropic's bare "Invalid request data" 400, which is a
+ *  transient generation failure rather than a malformed request. */
 export declare class SmolOverloadedError extends SmolError {
     constructor(message: string, options?: SmolErrorOptions);
 }

package/dist/smolError.js

@@ -121,7 +121,9 @@ export class SmolRateLimitError extends SmolError {
         this.name = "SmolRateLimitError";
     }
 }
-/** Provider temporarily overloaded/unavailable (HTTP 503, or Anthropic's 529). */
+/** Provider temporarily overloaded/unavailable (HTTP 503, or Anthropic's 529).
+ *  Also raised for Anthropic's bare "Invalid request data" 400, which is a
+ *  transient generation failure rather than a malformed request. */
 export class SmolOverloadedError extends SmolError {
     constructor(message, options = {}) {
         super(message, options);

package/dist/util/jsonSchema.d.ts

@@ -36,3 +36,17 @@ export declare function responseFormatToJsonSchema(schema: {
  * there are left as-is and only an object subschema is sanitized.
  */
 export declare function sanitizeJsonSchema(node: unknown): unknown;
+/**
+ * Rewrite `const` to a one-value `enum`, recursing through the same
+ * subschema positions as `sanitizeJsonSchema` (value slots and the
+ * anyOf/oneOf/allOf/prefixItems arrays; assertion positions such as `not` and
+ * `contains` are left untouched), and collapse an `anyOf` whose branches are
+ * all single-type enums of the same type into one `{type, enum}` node.
+ *
+ * Gemini's `responseJsonSchema` silently ignores `const` (verified live: a Zod
+ * union of string literals — emitted as `anyOf: [{type:"string", const:"a"}, …]`
+ * — came back as free prose), but it enforces `enum`. Other providers accept
+ * `const`, so only the Google client applies this. Annotations on each node
+ * are preserved; a mixed-type anyOf stays an anyOf with each const rewritten.
+ */
+export declare function constToEnum(node: unknown): unknown;

package/dist/util/jsonSchema.js

@@ -131,3 +131,86 @@ function sanitizeSubschema(value) {
         return value;
     return sanitizeJsonSchema(value);
 }
+/**
+ * Rewrite `const` to a one-value `enum`, recursing through the same
+ * subschema positions as `sanitizeJsonSchema` (value slots and the
+ * anyOf/oneOf/allOf/prefixItems arrays; assertion positions such as `not` and
+ * `contains` are left untouched), and collapse an `anyOf` whose branches are
+ * all single-type enums of the same type into one `{type, enum}` node.
+ *
+ * Gemini's `responseJsonSchema` silently ignores `const` (verified live: a Zod
+ * union of string literals — emitted as `anyOf: [{type:"string", const:"a"}, …]`
+ * — came back as free prose), but it enforces `enum`. Other providers accept
+ * `const`, so only the Google client applies this. Annotations on each node
+ * are preserved; a mixed-type anyOf stays an anyOf with each const rewritten.
+ */
+export function constToEnum(node) {
+    if (typeof node !== "object" || node === null || Array.isArray(node)) {
+        return node;
+    }
+    const out = { ...node };
+    if ("const" in out) {
+        out.enum = [out.const];
+        delete out.const;
+    }
+    for (const key of SCHEMA_KEYS) {
+        if (key in out) {
+            out[key] = constToEnumSubschema(out[key]);
+        }
+    }
+    for (const key of SCHEMA_MAP_KEYS) {
+        const map = out[key];
+        if (map && typeof map === "object" && !Array.isArray(map)) {
+            const rewritten = Object.create(null);
+            for (const [name, sub] of Object.entries(map)) {
+                rewritten[name] = constToEnum(sub);
+            }
+            out[key] = rewritten;
+        }
+    }
+    for (const key of SCHEMA_ARRAY_KEYS) {
+        const arr = out[key];
+        if (Array.isArray(arr)) {
+            out[key] = arr.map((sub) => constToEnum(sub));
+        }
+    }
+    if ("additionalProperties" in out) {
+        out.additionalProperties = constToEnumSubschema(out.additionalProperties);
+    }
+    return collapseEnumAnyOf(out);
+}
+function constToEnumSubschema(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return constToEnum(value);
+}
+/**
+ * `{anyOf: [{type:"string", enum:["a"]}, {type:"string", enum:["b"]}]}` →
+ * `{type:"string", enum:["a","b"]}`. Only collapses when every branch is
+ * exactly `{type, enum}` with one shared `type`, so no constraint is lost.
+ */
+function collapseEnumAnyOf(node) {
+    const branches = node.anyOf;
+    if (!Array.isArray(branches) || branches.length === 0) {
+        return node;
+    }
+    const first = branches[0];
+    const sharedType = typeof first === "object" && first !== null
+        ? first.type
+        : undefined;
+    if (typeof sharedType !== "string") {
+        return node;
+    }
+    const isPlainEnum = (branch) => typeof branch === "object" &&
+        branch !== null &&
+        Object.keys(branch).every((key) => key === "type" || key === "enum") &&
+        branch.type === sharedType &&
+        Array.isArray(branch.enum);
+    if (!branches.every(isPlainEnum)) {
+        return node;
+    }
+    const { anyOf, ...rest } = node;
+    const values = branches.flatMap((branch) => branch.enum);
+    return { ...rest, type: sharedType, enum: values };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [