smoltalk 0.0.60 → 0.0.62

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.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/functions.js

@@ -1,7 +1,8 @@
-import { getClient } from "./client.js";
+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;
@@ -29,16 +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 { smolConfig, promptConfig } = splitConfig(config);
-    const client = getClient(smolConfig);
-    return client.textStream(promptConfig);
+    const strategy = getStrategy(config.model);
+    config.messages = fixMessagesIfNecessary(config.messages);
+    return strategy.textStream(config);
 }

package/dist/strategies/baseStrategy.d.ts

@@ -1,13 +1,21 @@
 import { StatelogClient } from "../statelogClient.js";
-import { PromptResult, Result, SmolPromptConfig } from "../types.js";
+import { PromptResult, Result, SmolPromptConfig, StreamChunk } from "../types.js";
 import { Strategy, StrategyJSON } from "./types.js";
 export declare class BaseStrategy implements Strategy {
     statelogClient?: StatelogClient;
-    text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    text(config: Omit<SmolPromptConfig, "stream">): Promise<Result<PromptResult>>;
+    text(config: Omit<SmolPromptConfig, "stream"> & {
+        stream: false;
+    }): Promise<Result<PromptResult>>;
+    text(config: Omit<SmolPromptConfig, "stream"> & {
+        stream: true;
+    }): AsyncGenerator<StreamChunk>;
+    text(config: SmolPromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
     textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
-    textStream(config: SmolPromptConfig): Promise<Result<AsyncIterable<PromptResult>>>;
+    textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
     _textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     toJSON(): StrategyJSON;
     toString(): string;
     toShortString(): string;

package/dist/strategies/baseStrategy.js

@@ -1,7 +1,7 @@
 import { getStatelogClient } from "../statelogClient.js";
 export class BaseStrategy {
     statelogClient;
-    async text(config) {
+    text(config) {
         this.statelogClient = config.statelog
             ? getStatelogClient(config.statelog)
             : undefined;
@@ -10,6 +10,9 @@ export class BaseStrategy {
             this.statelogClient?.debug(`Calling onStrategyStart hook for strategy ${this.toString()}`);
             config.hooks.onStrategyStart(this, config);
         }
+        if (config.stream) {
+            return this.textStream(config);
+        }
         return this._text(config);
     }
     async textSync(config) {
@@ -19,8 +22,12 @@ export class BaseStrategy {
         this.statelogClient?.debug(`Starting strategy (sync) ${this.toString()}`);
         return this._textSync(config);
     }
-    async textStream(config) {
-        throw new Error("textStream method not implemented.");
+    textStream(config) {
+        this.statelogClient = config.statelog
+            ? getStatelogClient(config.statelog)
+            : undefined;
+        this.statelogClient?.debug(`Starting strategy (stream) ${this.toString()}`);
+        return this._textStream(config);
     }
     async _text(config) {
         throw new Error("_text method not implemented.");
@@ -28,6 +35,21 @@ export class BaseStrategy {
     async _textSync(config) {
         throw new Error("_textSync method not implemented.");
     }
+    async *_textStream(config) {
+        const result = await this._textSync(config);
+        if (result.success) {
+            if (result.value.output) {
+                yield { type: "text", text: result.value.output };
+            }
+            for (const tc of result.value.toolCalls) {
+                yield { type: "tool_call", toolCall: tc };
+            }
+            yield { type: "done", result: result.value };
+        }
+        else {
+            yield { type: "error", error: result.error };
+        }
+    }
     toJSON() {
         throw new Error("toJSON method not implemented.");
     }

package/dist/strategies/fastestStrategy.d.ts

@@ -1,5 +1,5 @@
 import { Model } from "../model.js";
-import { PromptResult, Result, SmolPromptConfig } from "../types.js";
+import { PromptResult, Result, SmolPromptConfig, StreamChunk } from "../types.js";
 import { BaseStrategy } from "./baseStrategy.js";
 import { StrategyJSON } from "./types.js";
 export declare class FastestStrategy extends BaseStrategy {
@@ -8,7 +8,9 @@ export declare class FastestStrategy extends BaseStrategy {
     constructor(models: (string | Model)[], epsilon?: number);
     toString(): string;
     toShortString(): string;
+    private chooseModel;
     _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     private pickFastest;
     /** Get tokens/sec for a model: tracked latency first, then static estimate, then 0. */
     private getSpeed;

package/dist/strategies/fastestStrategy.js

@@ -20,47 +20,53 @@ export class FastestStrategy extends BaseStrategy {
     toShortString() {
         return `fastest([${this.models.map((s) => s.toString()).join(", ")}])`;
     }
-    async _text(config) {
+    chooseModel(config) {
         const resolved = this.models.map((model) => Model.create(model));
-        let chosen = null;
         const logger = getLogger(config.logLevel);
         if (Math.random() < this.epsilon) {
             // Explore: pick a random model
-            chosen = resolved[Math.floor(Math.random() * resolved.length)];
+            const chosen = resolved[Math.floor(Math.random() * resolved.length)];
             logger.debug("fastest strategy - exploring random model", {
                 model: chosen.getResolvedModel(),
             });
             this.statelogClient?.debug("fastest strategy - picking random model", {
                 model: chosen.getResolvedModel(),
             });
+            return chosen;
         }
-        else {
-            // Exploit: pick the fastest model by tracked latency
-            chosen = this.pickFastest(resolved);
-            if (chosen) {
-                logger.debug("fastest strategy - exploiting fastest model", {
-                    model: chosen.getResolvedModel(),
-                });
-                this.statelogClient?.debug("fastest strategy - using fastest model", {
-                    model: chosen.getResolvedModel(),
-                });
-            }
-            else {
-                // we don't have latency data for any model, so just pick randomly
-                chosen = resolved[Math.floor(Math.random() * resolved.length)];
-                logger.debug("fastest strategy - no latency data, picking random model", {
-                    models: resolved.map((m) => m.getResolvedModel()),
-                    chosen: chosen.getResolvedModel(),
-                });
-                this.statelogClient?.debug("fastest strategy - no latency data, picking random model", {
-                    models: resolved.map((m) => m.getResolvedModel()),
-                    chosen,
-                });
-            }
+        // Exploit: pick the fastest model by tracked latency
+        const fastest = this.pickFastest(resolved);
+        if (fastest) {
+            logger.debug("fastest strategy - exploiting fastest model", {
+                model: fastest.getResolvedModel(),
+            });
+            this.statelogClient?.debug("fastest strategy - using fastest model", {
+                model: fastest.getResolvedModel(),
+            });
+            return fastest;
         }
+        // we don't have latency data for any model, so just pick randomly
+        const chosen = resolved[Math.floor(Math.random() * resolved.length)];
+        logger.debug("fastest strategy - no latency data, picking random model", {
+            models: resolved.map((m) => m.getResolvedModel()),
+            chosen: chosen.getResolvedModel(),
+        });
+        this.statelogClient?.debug("fastest strategy - no latency data, picking random model", {
+            models: resolved.map((m) => m.getResolvedModel()),
+            chosen,
+        });
+        return chosen;
+    }
+    async _text(config) {
+        const chosen = this.chooseModel(config);
         const strategy = new IDStrategy(chosen);
         return strategy.text(config);
     }
+    async *_textStream(config) {
+        const chosen = this.chooseModel(config);
+        const strategy = new IDStrategy(chosen);
+        yield* strategy.textStream(config);
+    }
     pickFastest(models) {
         let best = null;
         let bestSpeed = 0;

package/dist/strategies/idStrategy.d.ts

@@ -1,5 +1,5 @@
 import { Model } from "../model.js";
-import { ModelLike, PromptResult, Result, SmolPromptConfig } from "../types.js";
+import { ModelLike, PromptResult, Result, SmolPromptConfig, StreamChunk } from "../types.js";
 import { BaseStrategy } from "./baseStrategy.js";
 import { StrategyJSON } from "./types.js";
 export declare class IDStrategy extends BaseStrategy {
@@ -7,8 +7,10 @@ export declare class IDStrategy extends BaseStrategy {
     constructor(model: ModelLike, provider?: string);
     toString(): string;
     toShortString(): string;
+    private _getClientAndConfig;
     _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
     _textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     toJSON(): StrategyJSON;
     static fromJSON(json: unknown): IDStrategy;
 }

package/dist/strategies/idStrategy.js

@@ -15,10 +15,7 @@ export class IDStrategy extends BaseStrategy {
     toShortString() {
         return `id(${this.model.toString()})`;
     }
-    async _text(config) {
-        return this._textSync(config);
-    }
-    async _textSync(config) {
+    _getClientAndConfig(config) {
         const configOverrides = {
             model: this.model.getResolvedModel(),
             provider: this.model.getProvider(),
@@ -31,8 +28,19 @@ export class IDStrategy extends BaseStrategy {
             ...smolConfig,
             ...configOverrides,
         });
+        return { client, promptConfig };
+    }
+    async _text(config) {
+        return this._textSync(config);
+    }
+    async _textSync(config) {
+        const { client, promptConfig } = this._getClientAndConfig(config);
         return client.textSync(promptConfig);
     }
+    async *_textStream(config) {
+        const { client, promptConfig } = this._getClientAndConfig(config);
+        yield* client.textStream(promptConfig);
+    }
     // todo: this toJSON isn't fully accurate as it resolves the model,
     // so strategy vs strategy.fromJSON(strategy.toJSON()) won't be the same
     toJSON() {

package/dist/strategies/raceStrategy.d.ts

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

package/dist/strategies/randomStrategy.d.ts

@@ -1,4 +1,4 @@
-import { ModelParam, PromptResult, Result, SmolPromptConfig } from "../types.js";
+import { ModelParam, PromptResult, Result, SmolPromptConfig, StreamChunk } from "../types.js";
 import { BaseStrategy } from "./baseStrategy.js";
 import { Strategy, StrategyJSON } from "./types.js";
 export declare class RandomStrategy extends BaseStrategy {
@@ -7,6 +7,7 @@ export declare class RandomStrategy extends BaseStrategy {
     toString(): string;
     toShortString(): string;
     _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     toJSON(): StrategyJSON;
     static fromJSON(json: unknown): RandomStrategy;
 }

package/dist/strategies/randomStrategy.js

@@ -23,6 +23,14 @@ export class RandomStrategy extends BaseStrategy {
         const result = await strategy.text(config);
         return result;
     }
+    async *_textStream(config) {
+        const randomIndex = Math.floor(Math.random() * this.strategies.length);
+        const strategy = this.strategies[randomIndex];
+        this.statelogClient?.debug("random strategy chosen (stream)", {
+            strategy,
+        });
+        yield* strategy.textStream(config);
+    }
     toJSON() {
         return {
             type: "random",

package/dist/strategies/types.d.ts

@@ -1,11 +1,12 @@
 import { z } from "zod";
-import { SmolPromptConfig, Result, PromptResult } from "../types.js";
+import { SmolPromptConfig, Result, PromptResult, StreamChunk } from "../types.js";
 export interface Strategy {
-    text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    text(config: SmolPromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
     _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
     textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
     _textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
-    textStream(config: SmolPromptConfig): Promise<Result<AsyncIterable<PromptResult>>>;
+    textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
+    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
     toJSON(): StrategyJSON;
     toString(): string;
     toShortString(): string;

package/package.json

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