smoltalk 0.0.61 → 0.0.63

package/dist/classes/ToolCall.js

@@ -45,8 +45,14 @@ export class ToolCall {
         };
     }
     static fromJSON(json) {
-        const parsed = ToolCallJSONSchema.parse(json);
-        return new ToolCall(parsed.id, parsed.name, parsed.arguments);
+        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));
+            throw new Error("Failed to parse ToolCall");
+        }
+        return new ToolCall(result.data.id, result.data.name, result.data.arguments);
     }
     toOpenAI() {
         return {

package/dist/classes/message/AssistantMessage.js

@@ -84,16 +84,22 @@ export class AssistantMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        const parsed = AssistantMessageJSONSchema.parse(json);
-        return new AssistantMessage(parsed.content, {
-            name: parsed.name,
-            audio: parsed.audio,
-            refusal: parsed.refusal,
-            toolCalls: parsed.toolCalls?.map((tc) => ToolCall.fromJSON(tc)),
-            thinkingBlocks: parsed.thinkingBlocks,
-            rawData: parsed.rawData,
-            usage: parsed.usage,
-            cost: parsed.cost,
+        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));
+            throw new Error("Failed to parse AssistantMessage");
+        }
+        return new AssistantMessage(result.data.content, {
+            name: result.data.name,
+            audio: result.data.audio,
+            refusal: result.data.refusal,
+            toolCalls: result.data.toolCalls?.map((tc) => ToolCall.fromJSON(tc)),
+            thinkingBlocks: result.data.thinkingBlocks,
+            rawData: result.data.rawData,
+            usage: result.data.usage,
+            cost: result.data.cost,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/DeveloperMessage.js

@@ -41,10 +41,16 @@ export class DeveloperMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        const parsed = DeveloperMessageJSONSchema.parse(json);
-        return new DeveloperMessage(parsed.content, {
-            name: parsed.name,
-            rawData: parsed.rawData,
+        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));
+            throw new Error("Failed to parse DeveloperMessage");
+        }
+        return new DeveloperMessage(result.data.content, {
+            name: result.data.name,
+            rawData: result.data.rawData,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/SystemMessage.js

@@ -41,10 +41,16 @@ export class SystemMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        const parsed = SystemMessageJSONSchema.parse(json);
-        return new SystemMessage(parsed.content, {
-            name: parsed.name,
-            rawData: parsed.rawData,
+        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));
+            throw new Error("Failed to parse SystemMessage");
+        }
+        return new SystemMessage(result.data.content, {
+            name: result.data.name,
+            rawData: result.data.rawData,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/ToolMessage.js

@@ -48,11 +48,17 @@ export class ToolMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        const parsed = ToolMessageJSONSchema.parse(json);
-        return new ToolMessage(parsed.content, {
-            tool_call_id: parsed.tool_call_id,
-            name: parsed.name,
-            rawData: parsed.rawData,
+        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));
+            throw new Error("Failed to parse ToolMessage");
+        }
+        return new ToolMessage(result.data.content, {
+            tool_call_id: result.data.tool_call_id,
+            name: result.data.name,
+            rawData: result.data.rawData,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/UserMessage.js

@@ -40,10 +40,16 @@ export class UserMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        const parsed = UserMessageJSONSchema.parse(json);
-        return new UserMessage(parsed.content, {
-            name: parsed.name,
-            rawData: parsed.rawData,
+        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));
+            throw new Error("Failed to parse UserMessage");
+        }
+        return new UserMessage(result.data.content, {
+            name: result.data.name,
+            rawData: result.data.rawData,
         });
     }
     toOpenAIMessage() {

package/dist/clients/baseClient.js

@@ -1,4 +1,4 @@
-import { userMessage, assistantMessage, } from "../classes/message/index.js";
+import { userMessage, assistantMessage } from "../classes/message/index.js";
 import { latencyTracker } from "../latencyTracker.js";
 import { getLogger } from "../util/logger.js";
 import { SmolStructuredOutputError } from "../smolError.js";
@@ -149,6 +149,10 @@ export class BaseClient {
                 return rawValue;
             }
         }
+        // 1.5 Look for { type: "object", properties: { response: { ... } } } pattern
+        if (rawValue && typeof rawValue === "object" && rawValue.type === "object" && rawValue.properties) {
+            return this.extractResponse(promptConfig, rawValue.properties, schema, depth + 1);
+        }
         // 2. String → try JSON.parse, then recurse
         if (typeof rawValue === "string") {
             const stripped = rawValue

package/dist/clients/google.js

@@ -109,7 +109,7 @@ export class SmolGoogle extends BaseClient {
         this.statelogClient?.debug("Detected both tool calls and structured response in call to Google Gemini. Making separate request to Google Gemini for tool calls.", {
             contents: request.contents,
             tools: config.tools,
-            responseFormat: config.responseFormat,
+            responseFormat: config.responseFormat?.toJSONSchema(),
         });
         const toolRequest = {
             ...request,

package/dist/functions.js

@@ -1,6 +1,8 @@
+import { BaseMessage, messageFromJSON, } from "./classes/message/index.js";
 import { Model } from "./model.js";
 import { BaseStrategy } from "./strategies/baseStrategy.js";
 import { fromJSON } from "./strategies/index.js";
+import { getLogger } from "./util/logger.js";
 function getStrategy(model) {
     if (model instanceof BaseStrategy)
         return model;
@@ -28,15 +30,27 @@ export function splitConfig(config) {
         promptConfig,
     };
 }
+function fixMessagesIfNecessary(messages) {
+    if (messages && messages.length > 0) {
+        if (!(messages[0] instanceof BaseMessage)) {
+            getLogger().warn("Messages are not instances of smoltalk.BaseMessage");
+            return messages.map((m) => messageFromJSON(m));
+        }
+    }
+    return messages;
+}
 export function text(config) {
     const strategy = getStrategy(config.model);
+    config.messages = fixMessagesIfNecessary(config.messages);
     return strategy.text(config);
 }
 export function textSync(config) {
     const strategy = getStrategy(config.model);
+    config.messages = fixMessagesIfNecessary(config.messages);
     return strategy.textSync(config);
 }
 export function textStream(config) {
     const strategy = getStrategy(config.model);
+    config.messages = fixMessagesIfNecessary(config.messages);
     return strategy.textStream(config);
 }

package/dist/strategies/fallbackStrategy.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { SmolContentPolicyError, SmolContextWindowExceededError, SmolStructuredOutputError, SmolTimeoutError, } from "../smolError.js";
 import { success, } from "../types.js";
 import { BaseStrategy } from "./baseStrategy.js";
@@ -108,8 +109,14 @@ export class FallbackStrategy extends BaseStrategy {
         };
     }
     static fromJSON(json) {
-        const parsed = FallbackStrategyJSONSchema.parse(json);
-        const primaryStrategy = fromJSON(parsed.params.primaryStrategy);
-        return new FallbackStrategy(primaryStrategy, parsed.params.config);
+        const result = FallbackStrategyJSONSchema.safeParse(json);
+        if (!result.success) {
+            console.error("Failed to parse FallbackStrategy");
+            console.error(JSON.stringify(json, null, 2));
+            console.error(z.prettifyError(result.error));
+            throw new Error("Failed to parse FallbackStrategy");
+        }
+        const primaryStrategy = fromJSON(result.data.params.primaryStrategy);
+        return new FallbackStrategy(primaryStrategy, result.data.params.config);
     }
 }

package/dist/strategies/fastestStrategy.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { latencyTracker } from "../latencyTracker.js";
 import { getLogger } from "../util/logger.js";
 import { Model } from "../model.js";
@@ -94,8 +95,14 @@ export class FastestStrategy extends BaseStrategy {
         };
     }
     static fromJSON(json) {
-        const parsed = FastestStrategyJSONSchema.parse(json);
-        const models = parsed.params.models;
+        const result = FastestStrategyJSONSchema.safeParse(json);
+        if (!result.success) {
+            console.error("Failed to parse FastestStrategy");
+            console.error(JSON.stringify(json, null, 2));
+            console.error(z.prettifyError(result.error));
+            throw new Error("Failed to parse FastestStrategy");
+        }
+        const models = result.data.params.models;
         return new FastestStrategy(models);
     }
 }

package/dist/strategies/raceStrategy.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { getLogger } from "../util/logger.js";
 import { BaseStrategy } from "./baseStrategy.js";
 import { fromJSON, IDStrategy } from "./index.js";
@@ -58,8 +59,14 @@ export class RaceStrategy extends BaseStrategy {
         };
     }
     static fromJSON(json) {
-        const parsed = RaceStrategyJSONSchema.parse(json);
-        const strategies = parsed.params.strategies.map((s) => fromJSON(s));
+        const result = RaceStrategyJSONSchema.safeParse(json);
+        if (!result.success) {
+            console.error("Failed to parse RaceStrategy");
+            console.error(JSON.stringify(json, null, 2));
+            console.error(z.prettifyError(result.error));
+            throw new Error("Failed to parse RaceStrategy");
+        }
+        const strategies = result.data.params.strategies.map((s) => fromJSON(s));
         return new RaceStrategy(strategies);
     }
 }

package/dist/strategies/randomStrategy.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { BaseStrategy } from "./baseStrategy.js";
 import { IDStrategy } from "./idStrategy.js";
 import { fromJSON } from "./index.js";
@@ -40,8 +41,14 @@ export class RandomStrategy extends BaseStrategy {
         };
     }
     static fromJSON(json) {
-        const parsed = RandomStrategyJSONSchema.parse(json);
-        const strategies = parsed.params.strategies.map((s) => fromJSON(s));
+        const result = RandomStrategyJSONSchema.safeParse(json);
+        if (!result.success) {
+            console.error("Failed to parse RandomStrategy");
+            console.error(JSON.stringify(json, null, 2));
+            console.error(z.prettifyError(result.error));
+            throw new Error("Failed to parse RandomStrategy");
+        }
+        const strategies = result.data.params.strategies.map((s) => fromJSON(s));
         return new RandomStrategy(...strategies);
     }
 }

package/dist/strategies/timeoutStrategy.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { SmolTimeoutError } from "../smolError.js";
 import { BaseStrategy } from "./baseStrategy.js";
 import { IDStrategy } from "./idStrategy.js";
@@ -51,8 +52,14 @@ export class TimeoutStrategy extends BaseStrategy {
         };
     }
     static fromJSON(json) {
-        const parsed = TimeoutStrategyJSONSchema.parse(json);
-        const strategy = fromJSON(parsed.params.strategy);
-        return new TimeoutStrategy(strategy, parsed.params.timeoutMs);
+        const result = TimeoutStrategyJSONSchema.safeParse(json);
+        if (!result.success) {
+            console.error("Failed to parse TimeoutStrategy");
+            console.error(JSON.stringify(json, null, 2));
+            console.error(z.prettifyError(result.error));
+            throw new Error("Failed to parse TimeoutStrategy");
+        }
+        const strategy = fromJSON(result.data.params.strategy);
+        return new TimeoutStrategy(strategy, result.data.params.timeoutMs);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {