smoltalk 0.0.62 → 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

@@ -150,7 +150,7 @@ export class BaseClient {
             }
         }
         // 1.5 Look for { type: "object", properties: { response: { ... } } } pattern
-        if (rawValue.type === "object" && rawValue.properties) {
+        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

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/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.62",
+  "version": "0.0.63",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {