smoltalk 0.0.40 → 0.0.42

package/dist/clients/google.js

@@ -65,11 +65,10 @@ export class SmolGoogle extends BaseClient {
         if (tools.length > 0) {
             genConfig.tools = [{ functionDeclarations: tools }];
         }
-        // Google Gemini does not support combining function calling with
-        // responseMimeType 'application/json'. When tools are present, skip
-        // setting the JSON response format — the BaseClient's textWithRetry
-        // will still validate/parse the response against the schema.
-        if (config.responseFormat && tools.length === 0) {
+        if (config.responseFormat && tools.length > 0) {
+            console.error("Warning: Both responseFormat and tools are specified in the prompt config. Google Gemini does not support enforcing a response format when tools are included, so the responseFormat will be ignored.");
+        }
+        else if (config.responseFormat && tools.length === 0) {
             genConfig.responseMimeType = "application/json";
             genConfig.responseJsonSchema = config.responseFormat.toJSONSchema();
         }

package/dist/strategies/baseStrategy.js

@@ -1,5 +1,8 @@
 export class BaseStrategy {
     async text(config) {
+        if (config.hooks?.onStrategyStart) {
+            config.hooks.onStrategyStart(this, config);
+        }
         return this._text({ ...config, strategy: undefined });
     }
     async textSync(config) {

package/dist/strategies/fallbackStrategy.d.ts

@@ -5,6 +5,10 @@ export declare class FallbackStrategy extends BaseStrategy {
     strategies: Strategy[];
     config: FallbackStrategyConfig;
     constructor(strategies: Strategy[], config: FallbackStrategyConfig);
-    _text(config: SmolPromptConfig): Promise<import("../types.js").Result<import("../types.js").PromptResult>>;
+    toString(): string;
+    _text(config: SmolPromptConfig): Promise<import("../types.js").Result<import("../types.js").PromptResult> | import("../types.js").Success<{
+        output: null;
+        toolCalls: never[];
+    }>>;
     toJSON(): StrategyJSON;
 }

package/dist/strategies/fallbackStrategy.js

@@ -1,4 +1,5 @@
 import { SmolStructuredOutputError, SmolTimeoutError } from "../smolError.js";
+import { success } from "../types.js";
 import { BaseStrategy } from "./baseStrategy.js";
 export class FallbackStrategy extends BaseStrategy {
     strategies;
@@ -8,6 +9,9 @@ export class FallbackStrategy extends BaseStrategy {
         this.strategies = strategies;
         this.config = config;
     }
+    toString() {
+        return `FallbackStrategy([${this.strategies.map((s) => s.toString()).join(", ")}], config: ${JSON.stringify(this.config)})`;
+    }
     async _text(config) {
         for (let i = 0; i < this.strategies.length; i++) {
             const strategy = this.strategies[i];
@@ -16,6 +20,11 @@ export class FallbackStrategy extends BaseStrategy {
                 return result;
             }
             catch (error) {
+                // If the abort signal was triggered (e.g. by a race strategy winner
+                // or external cancellation), stop without trying further fallbacks.
+                if (config.abortSignal?.aborted) {
+                    return success({ output: null, toolCalls: [] });
+                }
                 if (error instanceof SmolTimeoutError) {
                     if (this.config.fallbackOn.includes("timeout")) {
                         continue;

package/dist/strategies/idStrategy.d.ts

@@ -5,6 +5,7 @@ import { StrategyJSON } from "./types.js";
 export declare class IDStrategy extends BaseStrategy {
     model: Model;
     constructor(model: Model);
+    toString(): string;
     _text(_config: SmolPromptConfig): Promise<import("../types.js").Result<import("../types.js").PromptResult>>;
     toJSON(): StrategyJSON;
 }

package/dist/strategies/idStrategy.js

@@ -6,14 +6,14 @@ export class IDStrategy extends BaseStrategy {
         super();
         this.model = model;
     }
+    toString() {
+        return `IDStrategy(model: ${this.model.getResolvedModel()})`;
+    }
     async _text(_config) {
         const config = {
             ..._config,
             model: this.model.getResolvedModel(),
         };
-        if (config.hooks?.onStrategyStart) {
-            config.hooks.onStrategyStart(config);
-        }
         return text({ ...config, stream: false });
     }
     toJSON() {

package/dist/strategies/raceStrategy.d.ts

@@ -4,6 +4,7 @@ import { Strategy, StrategyJSON } from "./types.js";
 export declare class RaceStrategy extends BaseStrategy {
     strategies: Strategy[];
     constructor(strategies: Strategy[]);
+    toString(): string;
     _text(config: SmolPromptConfig): Promise<import("../types.js").Failure | import("../types.js").Success<import("../types.js").PromptResult>>;
     toJSON(): StrategyJSON;
 }

package/dist/strategies/raceStrategy.js

@@ -5,6 +5,9 @@ export class RaceStrategy extends BaseStrategy {
         super();
         this.strategies = strategies;
     }
+    toString() {
+        return `RaceStrategy([${this.strategies.map((s) => s.toString()).join(", ")}])`;
+    }
     async _text(config) {
         const controllers = this.strategies.map(() => new AbortController());
         // Link to any existing abort signal so external cancellation still works

package/dist/types.d.ts

@@ -54,7 +54,7 @@ export type PromptConfig = {
         onToolCall: (toolCall: ToolCall) => void;
         onEnd: (result: PromptResult) => void;
         onError: (error: Error) => void;
-        onStrategyStart: (config: SmolPromptConfig) => void;
+        onStrategyStart: (strategy: Strategy, config: SmolPromptConfig) => void;
     }>;
     strategy?: Strategy | StrategyJSON;
 };

package/package.json

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