smoltalk 0.0.37 → 0.0.39

package/dist/clients/ollama.js

@@ -4,7 +4,7 @@ import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { BaseClient } from "./baseClient.js";
-import { calculateCost } from "../models.js";
+import { Model } from "../model.js";
 export const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
 export class SmolOllama extends BaseClient {
     logger;
@@ -13,7 +13,7 @@ export class SmolOllama extends BaseClient {
     constructor(config) {
         super(config);
         this.logger = getLogger();
-        this.model = config.model;
+        this.model = new Model(config.model);
         if (config.ollamaApiKey) {
             this.client = new Ollama({
                 host: "https://cloud.ollama.com",
@@ -29,7 +29,7 @@ export class SmolOllama extends BaseClient {
         return this.client;
     }
     getModel() {
-        return this.model;
+        return this.model.getResolvedModel();
     }
     calculateUsageAndCost(responseData) {
         let usage;
@@ -42,7 +42,7 @@ export class SmolOllama extends BaseClient {
                 outputTokens,
                 totalTokens: inputTokens + outputTokens,
             };
-            const calculatedCost = calculateCost(this.model, usage);
+            const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;
             }
@@ -58,7 +58,7 @@ export class SmolOllama extends BaseClient {
         });
         const request = {
             messages: messages,
-            model: this.model,
+            model: this.getModel(),
         };
         if (tools.length > 0) {
             request.tools = tools.map((t) => ({ type: "function", function: t }));
@@ -70,8 +70,16 @@ export class SmolOllama extends BaseClient {
             Object.assign(request, config.rawAttributes);
         }
         this.logger.debug("Sending request to Ollama:", JSON.stringify(request, null, 2));
+        const signal = this.getAbortSignal(config);
+        const abortHandler = signal ? () => this.client.abort() : undefined;
+        if (signal && abortHandler) {
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
         // @ts-ignore
         const result = await this.client.chat(request);
+        if (signal && abortHandler) {
+            signal.removeEventListener("abort", abortHandler);
+        }
         this.logger.debug("Response from Ollama:", JSON.stringify(result, null, 2));
         const output = result.message?.content || null;
         const toolCalls = [];
@@ -84,7 +92,7 @@ export class SmolOllama extends BaseClient {
         // Extract usage and calculate cost
         const { usage, cost } = this.calculateUsageAndCost(result);
         // Return the response, updating the chat history
-        return success({ output, toolCalls, usage, cost, model: this.model });
+        return success({ output, toolCalls, usage, cost, model: this.getModel() });
     }
     async *_textStream(config) {
         const messages = config.messages.map((msg) => msg.toOpenAIMessage());
@@ -95,7 +103,7 @@ export class SmolOllama extends BaseClient {
         });
         const request = {
             messages: messages,
-            model: this.model,
+            model: this.getModel(),
             stream: true,
         };
         if (tools.length > 0) {
@@ -108,6 +116,11 @@ export class SmolOllama extends BaseClient {
             Object.assign(request, config.rawAttributes);
         }
         this.logger.debug("Sending streaming request to Ollama:", JSON.stringify(request, null, 2));
+        const signal = this.getAbortSignal(config);
+        const abortHandler = signal ? () => this.client.abort() : undefined;
+        if (signal && abortHandler) {
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
         // @ts-ignore
         const stream = await this.client.chat(request);
         let content = "";
@@ -148,6 +161,9 @@ export class SmolOllama extends BaseClient {
                 }
             }
         }
+        if (signal && abortHandler) {
+            signal.removeEventListener("abort", abortHandler);
+        }
         this.logger.debug("Streaming response completed from Ollama");
         // Extract usage from the last chunk
         if (lastChunk) {
@@ -164,7 +180,13 @@ export class SmolOllama extends BaseClient {
         }
         yield {
             type: "done",
-            result: { output: content || null, toolCalls, usage, cost, model: this.model },
+            result: {
+                output: content || null,
+                toolCalls,
+                usage,
+                cost,
+                model: this.getModel(),
+            },
         };
     }
 }

package/dist/clients/openai.d.ts

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ModelName } from "../models.js";
 export type SmolOpenAiConfig = BaseClientConfig;
 export declare class SmolOpenAi extends BaseClient implements SmolClient {
     private client;
@@ -8,7 +9,7 @@ export declare class SmolOpenAi extends BaseClient implements SmolClient {
     private model;
     constructor(config: SmolOpenAiConfig);
     getClient(): OpenAI;
-    getModel(): string;
+    getModel(): ModelName;
     private calculateUsageAndCost;
     private buildRequest;
     _textSync(config: PromptConfig): Promise<Result<PromptResult>>;

package/dist/clients/openai.js

@@ -5,7 +5,7 @@ import { isFunctionToolCall } from "../util.js";
 import { getLogger } from "../logger.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAITool } from "../util/tool.js";
-import { calculateCost } from "../models.js";
+import { Model } from "../model.js";
 export class SmolOpenAi extends BaseClient {
     client;
     logger;
@@ -17,13 +17,13 @@ export class SmolOpenAi extends BaseClient {
         }
         this.client = new OpenAI({ apiKey: config.openAiApiKey });
         this.logger = getLogger();
-        this.model = config.model;
+        this.model = new Model(config.model);
     }
     getClient() {
         return this.client;
     }
     getModel() {
-        return this.model;
+        return this.model.getResolvedModel();
     }
     calculateUsageAndCost(usageData) {
         let usage;
@@ -35,7 +35,7 @@ export class SmolOpenAi extends BaseClient {
                 cachedInputTokens: usageData.prompt_tokens_details?.cached_tokens,
                 totalTokens: usageData.total_tokens,
             };
-            const calculatedCost = calculateCost(this.model, usage);
+            const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;
             }
@@ -45,13 +45,16 @@ export class SmolOpenAi extends BaseClient {
     buildRequest(config) {
         const messages = config.messages.map((msg) => msg.toOpenAIMessage());
         const request = {
-            model: this.model,
+            model: this.getModel(),
             messages,
             tools: config.tools?.map((tool) => {
                 return zodToOpenAITool(tool.name, tool.schema, {
                     description: tool.description,
                 });
             }),
+            ...(config.reasoningEffort && {
+                reasoning_effort: config.reasoningEffort,
+            }),
             ...(config.rawAttributes || {}),
         };
         if (config.responseFormat) {
@@ -68,10 +71,11 @@ export class SmolOpenAi extends BaseClient {
     async _textSync(config) {
         const request = this.buildRequest(config);
         this.logger.debug("Sending request to OpenAI:", JSON.stringify(request, null, 2));
+        const signal = this.getAbortSignal(config);
         const completion = await this.client.chat.completions.create({
             ...request,
             stream: false,
-        });
+        }, { ...(signal && { signal }) });
         this.logger.debug("Response from OpenAI:", JSON.stringify(completion, null, 2));
         const message = completion.choices[0].message;
         const output = message.content;
@@ -94,17 +98,18 @@ export class SmolOpenAi extends BaseClient {
             toolCalls,
             usage,
             cost,
-            model: request.model,
+            model: this.getModel(),
         });
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);
         this.logger.debug("Sending streaming request to OpenAI:", JSON.stringify(request, null, 2));
+        const signal = this.getAbortSignal(config);
         const completion = await this.client.chat.completions.create({
             ...request,
             stream: true,
             stream_options: { include_usage: true },
-        });
+        }, { ...(signal && { signal }) });
         let content = "";
         const toolCallsMap = new Map();
         let usage;
@@ -159,7 +164,7 @@ export class SmolOpenAi extends BaseClient {
                 toolCalls,
                 usage,
                 cost,
-                model: request.model,
+                model: this.getModel(),
             },
         };
     }

package/dist/clients/openaiResponses.d.ts

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ModelName } from "../models.js";
 export type SmolOpenAiResponsesConfig = BaseClientConfig;
 export declare class SmolOpenAiResponses extends BaseClient implements SmolClient {
     private client;
@@ -8,7 +9,7 @@ export declare class SmolOpenAiResponses extends BaseClient implements SmolClien
     private model;
     constructor(config: SmolOpenAiResponsesConfig);
     getClient(): OpenAI;
-    getModel(): string;
+    getModel(): ModelName;
     private convertMessages;
     private buildRequest;
     private calculateUsageAndCost;

package/dist/clients/openaiResponses.js

@@ -4,7 +4,7 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../logger.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
-import { calculateCost } from "../models.js";
+import { Model } from "../model.js";
 export class SmolOpenAiResponses extends BaseClient {
     client;
     logger;
@@ -16,13 +16,13 @@ export class SmolOpenAiResponses extends BaseClient {
         }
         this.client = new OpenAI({ apiKey: config.openAiApiKey });
         this.logger = getLogger();
-        this.model = config.model;
+        this.model = new Model(config.model);
     }
     getClient() {
         return this.client;
     }
     getModel() {
-        return this.model;
+        return this.model.getResolvedModel();
     }
     convertMessages(config) {
         let instructions = config.instructions;
@@ -48,7 +48,7 @@ export class SmolOpenAiResponses extends BaseClient {
     buildRequest(config) {
         const { instructions, input } = this.convertMessages(config);
         const request = {
-            model: this.model,
+            model: this.getModel(),
             input,
         };
         if (instructions) {
@@ -77,6 +77,9 @@ export class SmolOpenAiResponses extends BaseClient {
                 },
             };
         }
+        if (config.reasoningEffort) {
+            request.reasoning = { effort: config.reasoningEffort };
+        }
         if (config.rawAttributes) {
             Object.assign(request, config.rawAttributes);
         }
@@ -92,7 +95,7 @@ export class SmolOpenAiResponses extends BaseClient {
                 cachedInputTokens: usageData.input_tokens_details?.cached_tokens,
                 totalTokens: usageData.total_tokens,
             };
-            const calculatedCost = calculateCost(this.model, usage);
+            const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;
             }
@@ -102,10 +105,11 @@ export class SmolOpenAiResponses extends BaseClient {
     async _textSync(config) {
         const request = this.buildRequest(config);
         this.logger.debug("Sending request to OpenAI Responses API:", JSON.stringify(request, null, 2));
+        const signal = this.getAbortSignal(config);
         const response = await this.client.responses.create({
             ...request,
             stream: false,
-        });
+        }, { ...(signal && { signal }) });
         this.logger.debug("Response from OpenAI Responses API:", JSON.stringify(response, null, 2));
         const output = response.output_text || null;
         const toolCalls = [];
@@ -120,13 +124,16 @@ export class SmolOpenAiResponses extends BaseClient {
             toolCalls,
             usage,
             cost,
-            model: request.model,
+            model: this.getModel(),
         });
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);
         this.logger.debug("Sending streaming request to OpenAI Responses API:", JSON.stringify(request, null, 2));
-        const stream = this.client.responses.stream(request);
+        const signal = this.getAbortSignal(config);
+        const stream = this.client.responses.stream(request, {
+            ...(signal && { signal }),
+        });
         let content = "";
         const functionCalls = new Map();
         let usage;
@@ -206,7 +213,7 @@ export class SmolOpenAiResponses extends BaseClient {
                 toolCalls,
                 usage,
                 cost,
-                model: request.model,
+                model: this.getModel(),
             },
         };
     }

package/dist/functions.js

@@ -1,8 +1,17 @@
 import { getClient } from "./client.js";
-import { isModelConfig, pickModel } from "./models.js";
+import { Model } from "./model.js";
+import { BaseStrategy } from "./strategies/baseStrategy.js";
+import { fromJSON } from "./strategies/index.js";
+function hydrateStrategy(config) {
+    if (config.strategy && !(config.strategy instanceof BaseStrategy)) {
+        return { ...config, strategy: fromJSON(config.strategy) };
+    }
+    return config;
+}
 function splitConfig(config) {
     const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, statelog, ...promptConfig } = config;
-    const model = isModelConfig(rawModel) ? pickModel(rawModel) : rawModel;
+    const _model = new Model(rawModel);
+    const model = _model.getResolvedModel();
     return {
         smolConfig: {
             openAiApiKey,
@@ -20,17 +29,29 @@ function splitConfig(config) {
     };
 }
 export function text(config) {
+    config = hydrateStrategy(config);
+    if (config.strategy) {
+        return config.strategy.text(config);
+    }
     const { smolConfig, promptConfig } = splitConfig(config);
     const client = getClient(smolConfig);
     return client.text(promptConfig);
 }
 export function textSync(config) {
+    config = hydrateStrategy(config);
+    if (config.strategy) {
+        return config.strategy.textSync(config);
+    }
     const { smolConfig, promptConfig } = splitConfig(config);
     const client = getClient(smolConfig);
     return client.textSync(promptConfig);
 }
 export function textStream(config) {
-    const { smolConfig, promptConfig } = splitConfig(config);
+    config = hydrateStrategy(config);
+    /*   if (config.strategy) {
+      return (config.strategy as import("./strategies/types.js").Strategy).textStream(config);
+    }
+   */ const { smolConfig, promptConfig } = splitConfig(config);
     const client = getClient(smolConfig);
     return client.textStream(promptConfig);
 }

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
 export * from "./classes/ToolCall.js";
+export * from "./strategies/index.js";

package/dist/index.js

@@ -1,8 +1,10 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
 export * from "./classes/ToolCall.js";
+export * from "./strategies/index.js";

package/dist/model.d.ts

@@ -0,0 +1,33 @@
+import { ModelName, Provider, TextModel } from "./models.js";
+import { ModelLike } from "./types.js";
+export type Optimization = "speed" | "reasoning" | "cost" | "large-context";
+export type ModelConfig = {
+    optimizeFor: Optimization[];
+    providers: Provider[];
+    limit?: {
+        cost?: number;
+    };
+};
+export declare class Model {
+    private model;
+    private resolvedModel;
+    constructor(model: ModelName | ModelConfig);
+    getModel(): ModelName | ModelConfig;
+    getResolvedModel(): ModelName;
+    isModelConfig(model: ModelName | ModelConfig): model is ModelConfig;
+    resolveModel(models?: readonly TextModel[]): ModelName;
+    private getRawMetric;
+    private isLowerBetter;
+    calculateCost(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens?: number;
+    }): {
+        inputCost: number;
+        outputCost: number;
+        cachedInputCost?: number;
+        totalCost: number;
+        currency: string;
+    } | null;
+    static create(model: ModelLike): Model;
+}

package/dist/model.js

@@ -0,0 +1,132 @@
+import { getModel, isTextModel, textModels, } from "./models.js";
+import { SmolError } from "./smolError.js";
+import { round } from "./util.js";
+const WEIGHTS = {
+    1: [1],
+    2: [0.6, 0.4],
+    3: [0.5, 0.3, 0.2],
+    4: [0.4, 0.3, 0.2, 0.1],
+};
+export class Model {
+    model;
+    resolvedModel;
+    constructor(model) {
+        this.model = model;
+        this.resolvedModel = this.resolveModel();
+    }
+    getModel() {
+        return this.model;
+    }
+    getResolvedModel() {
+        return this.resolvedModel;
+    }
+    isModelConfig(model) {
+        return typeof model === "object" && "optimizeFor" in model;
+    }
+    resolveModel(models = textModels) {
+        if (!this.isModelConfig(this.model)) {
+            const modelName = this.model;
+            const model = getModel(modelName);
+            if (!model) {
+                throw new SmolError(`Model ${modelName} is not recognized. Please specify a known model or a valid ModelConfig.`);
+            }
+            return modelName;
+        }
+        const model = this.model;
+        let candidates = models.filter((m) => model.providers.includes(m.provider) &&
+            !("disabled" in m && m.disabled));
+        if (model.limit?.cost !== undefined) {
+            candidates = candidates.filter((m) => {
+                const cost = (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
+                return cost <= model.limit.cost;
+            });
+        }
+        if (candidates.length === 0) {
+            throw new SmolError("No models available for providers: " +
+                model.providers.join(", ") +
+                ". Check that the providers have non-disabled models.");
+        }
+        if (candidates.length === 1) {
+            return candidates[0].modelName;
+        }
+        const optimizations = model.optimizeFor;
+        const weights = WEIGHTS[optimizations.length] ?? WEIGHTS[4];
+        const scores = new Map();
+        for (const c of candidates) {
+            scores.set(c.modelName, 0);
+        }
+        for (let i = 0; i < optimizations.length; i++) {
+            const opt = optimizations[i];
+            const weight = weights[i];
+            const rawValues = candidates.map((c) => this.getRawMetric(c, opt));
+            const min = Math.min(...rawValues);
+            const max = Math.max(...rawValues);
+            const range = max - min;
+            for (let j = 0; j < candidates.length; j++) {
+                const raw = rawValues[j];
+                let normalized;
+                if (range === 0) {
+                    normalized = 0;
+                }
+                else if (this.isLowerBetter(opt)) {
+                    normalized = (raw - min) / range;
+                }
+                else {
+                    normalized = (max - raw) / range;
+                }
+                scores.set(candidates[j].modelName, scores.get(candidates[j].modelName) + weight * normalized);
+            }
+        }
+        let bestModel = candidates[0];
+        let bestScore = scores.get(candidates[0].modelName);
+        for (let i = 1; i < candidates.length; i++) {
+            const score = scores.get(candidates[i].modelName);
+            if (score < bestScore) {
+                bestScore = score;
+                bestModel = candidates[i];
+            }
+        }
+        return bestModel.modelName;
+    }
+    getRawMetric(model, optimization) {
+        const m = model;
+        switch (optimization) {
+            case "cost":
+                return (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
+            case "speed":
+                return m.outputTokensPerSecond ?? 0;
+            case "reasoning":
+                return (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
+            case "large-context":
+                return m.maxInputTokens;
+        }
+    }
+    isLowerBetter(optimization) {
+        return optimization === "cost";
+    }
+    calculateCost(usage) {
+        const model = getModel(this.getResolvedModel());
+        if (!model || !isTextModel(model)) {
+            return null;
+        }
+        const inputCost = round((usage.inputTokens * (model.inputTokenCost || 0)) / 1_000_000, 2);
+        const outputCost = round((usage.outputTokens * (model.outputTokenCost || 0)) / 1_000_000, 2);
+        const cachedInputCost = usage.cachedInputTokens && model.cachedInputTokenCost
+            ? round((usage.cachedInputTokens * model.cachedInputTokenCost) / 1_000_000, 2)
+            : undefined;
+        const totalCost = round(inputCost + outputCost + (cachedInputCost || 0), 2);
+        return {
+            inputCost,
+            outputCost,
+            cachedInputCost,
+            totalCost,
+            currency: "USD",
+        };
+    }
+    static create(model) {
+        if (model instanceof Model) {
+            return model;
+        }
+        return new Model(model);
+    }
+}

package/dist/models.d.ts

@@ -30,7 +30,7 @@ export type EmbeddingsModel = {
     modelName: string;
     tokenCost?: number;
 };
-export type Model = SpeechToTextModel | TextModel | EmbeddingsModel | ImageModel;
+export type ModelType = SpeechToTextModel | TextModel | EmbeddingsModel | ImageModel;
 export declare const speechToTextModels: readonly [{
     readonly type: "speech-to-text";
     readonly modelName: "whisper-local";
@@ -805,28 +805,7 @@ export declare function getModel(modelName: ModelName): {
     readonly description: "High-fidelity image generation with reasoning-enhanced composition. Supports legible text rendering, complex multi-turn editing, and character consistency using up to 14 reference inputs.";
     readonly costPerImage: 0.05;
 } | undefined;
-export declare function isImageModel(model: Model): model is ImageModel;
-export declare function isTextModel(model: Model): model is TextModel;
-export declare function isSpeechToTextModel(model: Model): model is SpeechToTextModel;
-export declare function isEmbeddingsModel(model: Model): model is EmbeddingsModel;
-export type Optimization = "speed" | "accuracy" | "cost" | "large-context";
-export type ModelConfig = {
-    optimizeFor: Optimization[];
-    providers: Provider[];
-    limit?: {
-        cost?: number;
-    };
-};
-export declare function isModelConfig(model: ModelName | ModelConfig): model is ModelConfig;
-export declare function pickModel(config: ModelConfig, models?: readonly TextModel[]): TextModelName;
-export declare function calculateCost(modelName: ModelName, usage: {
-    inputTokens: number;
-    outputTokens: number;
-    cachedInputTokens?: number;
-}): {
-    inputCost: number;
-    outputCost: number;
-    cachedInputCost?: number;
-    totalCost: number;
-    currency: string;
-} | null;
+export declare function isImageModel(model: ModelType): model is ImageModel;
+export declare function isTextModel(model: ModelType): model is TextModel;
+export declare function isSpeechToTextModel(model: ModelType): model is SpeechToTextModel;
+export declare function isEmbeddingsModel(model: ModelType): model is EmbeddingsModel;