smoltalk 0.0.37 → 0.0.39

package/dist/models.js

@@ -1,5 +1,3 @@
-import { SmolError } from "./smolError.js";
-import { round } from "./util.js";
 export const speechToTextModels = [
     { type: "speech-to-text", modelName: "whisper-local", provider: "local" },
     {
@@ -485,103 +483,3 @@ export function isSpeechToTextModel(model) {
 export function isEmbeddingsModel(model) {
     return model.type === "embeddings";
 }
-export function isModelConfig(model) {
-    return typeof model === "object" && "optimizeFor" in model;
-}
-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],
-};
-function getRawMetric(model, optimization) {
-    const m = model;
-    switch (optimization) {
-        case "cost":
-            return (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
-        case "speed":
-            return m.outputTokensPerSecond ?? 0;
-        case "accuracy":
-            return (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
-        case "large-context":
-            return m.maxInputTokens;
-    }
-}
-function isLowerBetter(optimization) {
-    return optimization === "cost";
-}
-export function pickModel(config, models = textModels) {
-    let candidates = models.filter((m) => config.providers.includes(m.provider) &&
-        !("disabled" in m && m.disabled));
-    if (config.limit?.cost !== undefined) {
-        candidates = candidates.filter((m) => {
-            const cost = (m.inputTokenCost ?? 0) + (m.outputTokenCost ?? 0);
-            return cost <= config.limit.cost;
-        });
-    }
-    if (candidates.length === 0) {
-        throw new SmolError("No models available for providers: " +
-            config.providers.join(", ") +
-            ". Check that the providers have non-disabled models.");
-    }
-    if (candidates.length === 1) {
-        return candidates[0].modelName;
-    }
-    const optimizations = config.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) => 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 (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;
-}
-export function calculateCost(modelName, usage) {
-    const model = getModel(modelName);
-    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",
-    };
-}

package/dist/smolError.d.ts

@@ -1,3 +1,9 @@
 export declare class SmolError extends Error {
     constructor(message: string);
 }
+export declare class SmolStructuredOutputError extends SmolError {
+    constructor(message: string);
+}
+export declare class SmolTimeoutError extends SmolError {
+    constructor(message: string);
+}

package/dist/smolError.js

@@ -4,3 +4,15 @@ export class SmolError extends Error {
         this.name = "SmolTalkError";
     }
 }
+export class SmolStructuredOutputError extends SmolError {
+    constructor(message) {
+        super(message);
+        this.name = "SmolStructuredOutputError";
+    }
+}
+export class SmolTimeoutError extends SmolError {
+    constructor(message) {
+        super(message);
+        this.name = "SmolTimeoutError";
+    }
+}

package/dist/statelogClient.d.ts

@@ -1,5 +1,6 @@
 import { Result } from "./types/result.js";
-import { ModelConfig, ModelName } from "./models.js";
+import { ModelName } from "./models.js";
+import { ModelConfig } from "./model.js";
 export type AgencyFile = {
     name: string;
     contents: string;

package/dist/strategies/baseStrategy.d.ts

@@ -0,0 +1,10 @@
+import { PromptResult, Result, SmolPromptConfig } from "../types.js";
+import { Strategy, StrategyJSON } from "./types.js";
+export declare class BaseStrategy implements Strategy {
+    text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    textStream(config: SmolPromptConfig): Promise<Result<AsyncIterable<PromptResult>>>;
+    _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    toJSON(): StrategyJSON;
+}

package/dist/strategies/baseStrategy.js

@@ -0,0 +1,20 @@
+export class BaseStrategy {
+    async text(config) {
+        return this._text({ ...config, strategy: undefined });
+    }
+    async textSync(config) {
+        return this._textSync({ ...config, strategy: undefined });
+    }
+    async textStream(config) {
+        throw new Error("textStream method not implemented.");
+    }
+    async _text(config) {
+        throw new Error("_text method not implemented.");
+    }
+    async _textSync(config) {
+        throw new Error("_textSync method not implemented.");
+    }
+    toJSON() {
+        throw new Error("toJSON method not implemented.");
+    }
+}

package/dist/strategies/fallbackStrategy.d.ts

@@ -0,0 +1,10 @@
+import { SmolPromptConfig } from "../types.js";
+import { BaseStrategy } from "./baseStrategy.js";
+import { FallbackStrategyConfig, Strategy, StrategyJSON } from "./types.js";
+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>>;
+    toJSON(): StrategyJSON;
+}

package/dist/strategies/fallbackStrategy.js

@@ -0,0 +1,48 @@
+import { SmolStructuredOutputError, SmolTimeoutError } from "../smolError.js";
+import { BaseStrategy } from "./baseStrategy.js";
+export class FallbackStrategy extends BaseStrategy {
+    strategies;
+    config;
+    constructor(strategies, config) {
+        super();
+        this.strategies = strategies;
+        this.config = config;
+    }
+    async _text(config) {
+        for (let i = 0; i < this.strategies.length; i++) {
+            const strategy = this.strategies[i];
+            try {
+                const result = await strategy.text(config);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof SmolTimeoutError) {
+                    if (this.config.fallbackOn.includes("timeout")) {
+                        continue;
+                    }
+                }
+                else if (error instanceof SmolStructuredOutputError) {
+                    if (this.config.fallbackOn.includes("structuredOutputFailure")) {
+                        continue;
+                    }
+                }
+                else {
+                    if (this.config.fallbackOn.includes("error")) {
+                        continue;
+                    }
+                }
+                throw error;
+            }
+        }
+        throw new Error(`All fallback strategies failed.`);
+    }
+    toJSON() {
+        return {
+            type: "fallback",
+            params: {
+                strategies: this.strategies.map((s) => s.toJSON()),
+                config: this.config,
+            },
+        };
+    }
+}

package/dist/strategies/idStrategy.d.ts

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

package/dist/strategies/idStrategy.js

@@ -0,0 +1,22 @@
+import { text } from "../functions.js";
+import { BaseStrategy } from "./baseStrategy.js";
+export class IDStrategy extends BaseStrategy {
+    model;
+    constructor(model) {
+        super();
+        this.model = model;
+    }
+    async _text(_config) {
+        const config = {
+            ..._config,
+            model: this.model.getResolvedModel(),
+        };
+        if (config.hooks?.onStrategyStart) {
+            config.hooks.onStrategyStart(config);
+        }
+        return text({ ...config, stream: false });
+    }
+    toJSON() {
+        return { type: "id", params: { model: this.model.getResolvedModel() } };
+    }
+}

package/dist/strategies/index.d.ts

@@ -0,0 +1,11 @@
+import { ModelLike } from "../types.js";
+import { FallbackStrategyConfig, Strategy, StrategyJSON } from "./types.js";
+export * from "./baseStrategy.js";
+export * from "./fallbackStrategy.js";
+export * from "./idStrategy.js";
+export * from "./raceStrategy.js";
+export * from "./types.js";
+export declare function race(..._strategies: (Strategy | ModelLike)[]): Strategy;
+export declare function id(model: ModelLike): Strategy;
+export declare function fallback(_strategies: (Strategy | ModelLike)[], config: FallbackStrategyConfig): Strategy;
+export declare function fromJSON(json: StrategyJSON): Strategy;

package/dist/strategies/index.js

@@ -0,0 +1,40 @@
+import { Model } from "../model.js";
+import { BaseStrategy } from "./baseStrategy.js";
+import { FallbackStrategy } from "./fallbackStrategy.js";
+import { IDStrategy } from "./idStrategy.js";
+import { RaceStrategy } from "./raceStrategy.js";
+export * from "./baseStrategy.js";
+export * from "./fallbackStrategy.js";
+export * from "./idStrategy.js";
+export * from "./raceStrategy.js";
+export * from "./types.js";
+export function race(..._strategies) {
+    const strategies = _strategies.map((s) => s instanceof BaseStrategy
+        ? s
+        : new IDStrategy(Model.create(s)));
+    return new RaceStrategy(strategies);
+}
+export function id(model) {
+    return new IDStrategy(Model.create(model));
+}
+export function fallback(_strategies, config) {
+    const strategies = _strategies.map((s) => s instanceof BaseStrategy
+        ? s
+        : new IDStrategy(Model.create(s)));
+    return new FallbackStrategy(strategies, config);
+}
+export function fromJSON(json) {
+    if (typeof json === "string") {
+        return id(json);
+    }
+    switch (json.type) {
+        case "id":
+            return id(json.params.model);
+        case "race":
+            return race(...json.params.strategies.map(fromJSON));
+        case "fallback":
+            return fallback(json.params.strategies.map(fromJSON), json.params.config);
+        default:
+            throw new Error(`Unknown strategy type: ${json.type}`);
+    }
+}

package/dist/strategies/raceStrategy.d.ts

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

package/dist/strategies/raceStrategy.js

@@ -0,0 +1,37 @@
+import { BaseStrategy } from "./baseStrategy.js";
+export class RaceStrategy extends BaseStrategy {
+    strategies;
+    constructor(strategies) {
+        super();
+        this.strategies = strategies;
+    }
+    async _text(config) {
+        const controllers = this.strategies.map(() => new AbortController());
+        // Link to any existing abort signal so external cancellation still works
+        if (config.abortSignal) {
+            const external = config.abortSignal;
+            for (const controller of controllers) {
+                external.addEventListener("abort", () => controller.abort(external.reason), { once: true });
+            }
+        }
+        const promises = this.strategies.map((strategy, i) => {
+            return strategy.text({
+                ...config,
+                abortSignal: controllers[i].signal,
+            });
+        });
+        return Promise.race(promises.map((p, i) => p.then((result) => {
+            for (let j = 0; j < controllers.length; j++) {
+                if (j !== i)
+                    controllers[j].abort();
+            }
+            return result;
+        })));
+    }
+    toJSON() {
+        return {
+            type: "race",
+            params: { strategies: this.strategies.map((s) => s.toJSON()) },
+        };
+    }
+}

package/dist/strategies/types.d.ts

@@ -0,0 +1,31 @@
+import { SmolPromptConfig, Result, PromptResult } from "../types.js";
+export interface Strategy {
+    text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _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>>>;
+    toJSON(): StrategyJSON;
+}
+type FallbackReason = "error" | "timeout" | "structuredOutputFailure";
+export type FallbackStrategyConfig = {
+    fallbackOn: FallbackReason[];
+};
+export type StrategyJSON = string | {
+    type: "id";
+    params: {
+        model: string;
+    };
+} | {
+    type: "race";
+    params: {
+        strategies: StrategyJSON[];
+    };
+} | {
+    type: "fallback";
+    params: {
+        strategies: StrategyJSON[];
+        config: FallbackStrategyConfig;
+    };
+};
+export {};

package/dist/strategies/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -3,12 +3,23 @@ import { LogLevel } from "egonlog";
 import { ZodType } from "zod";
 import { Message } from "./classes/message/index.js";
 import { ToolCall } from "./classes/ToolCall.js";
-import { ModelConfig, ModelName, Provider } from "./models.js";
+import { ModelName, Provider } from "./models.js";
 import { Result } from "./types/result.js";
+import { Model, ModelConfig } from "./model.js";
+import { Strategy, StrategyJSON } from "./strategies/types.js";
 export type ThinkingBlock = {
     text: string;
     signature: string;
 };
+export type Budget = {
+    timeBudgetMs?: number;
+    tokenBudget?: number;
+    tokensUsed?: number;
+    costBudget?: number;
+    costUsed?: number;
+    requestBudget?: number;
+    requestsUsed?: number;
+};
 export type PromptConfig = {
     messages: Message[];
     tools?: {
@@ -27,6 +38,7 @@ export type PromptConfig = {
         enabled: boolean;
         budgetTokens?: number;
     };
+    reasoningEffort?: "low" | "medium" | "high";
     responseFormatOptions?: Partial<{
         name: string;
         strict: boolean;
@@ -35,6 +47,16 @@ export type PromptConfig = {
     }>;
     rawAttributes?: Record<string, any>;
     maxMessages?: number;
+    budget?: Budget;
+    abortSignal?: AbortSignal;
+    hooks?: Partial<{
+        onStart: (config: PromptConfig) => void;
+        onToolCall: (toolCall: ToolCall) => void;
+        onEnd: (result: PromptResult) => void;
+        onError: (error: Error) => void;
+        onStrategyStart: (config: SmolPromptConfig) => void;
+    }>;
+    strategy?: Strategy | StrategyJSON;
 };
 export type SmolConfig = {
     openAiApiKey?: string;
@@ -100,6 +122,9 @@ export type StreamChunk = {
 } | {
     type: "error";
     error: string;
+} | {
+    type: "timeout";
+    error: string;
 };
 export interface SmolClient {
     text(promptConfig: PromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
@@ -114,3 +139,4 @@ export type TextPart = {
     type: "text";
     text: string;
 };
+export type ModelLike = ModelName | ModelConfig | Model;

package/package.json

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