smoltalk 0.0.67 → 0.2.1

package/dist/middleware.js

@@ -1,321 +0,0 @@
-import { success } from "./types.js";
-import { addTokenUsage } from "./types/tokenUsage.js";
-import { addCosts } from "./types/costEstimate.js";
-/**
- * Run a single middleware check. Returns a MiddlewareResult indicating
- * whether the check blocked and what output to use.
- */
-export async function runMiddlewareCheck(check, parentConfig, textSyncFn) {
-    const middlewareConfig = {
-        ...parentConfig,
-        messages: [...check.messages, ...parentConfig.messages],
-        responseFormat: check.responseFormat,
-        responseFormatOptions: check.responseFormatOptions,
-        middleware: undefined,
-        stream: undefined,
-    };
-    let llmResult;
-    try {
-        llmResult = await textSyncFn(middlewareConfig);
-    }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        return {
-            blocked: true,
-            result: success({
-                output: `Middleware check failed: ${errorMsg}`,
-                toolCalls: [],
-            }),
-        };
-    }
-    if (!llmResult.success) {
-        return {
-            blocked: true,
-            result: success({
-                output: `Middleware check failed: ${llmResult.error}`,
-                toolCalls: [],
-            }),
-            usage: undefined,
-            cost: undefined,
-        };
-    }
-    const middlewareUsage = llmResult.value.usage;
-    const middlewareCost = llmResult.value.cost;
-    let decision;
-    try {
-        decision = check.decide(llmResult.value);
-    }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        return {
-            blocked: true,
-            result: success({
-                output: `Middleware decide() failed: ${errorMsg}`,
-                toolCalls: [],
-                usage: middlewareUsage,
-                cost: middlewareCost,
-            }),
-            usage: middlewareUsage,
-            cost: middlewareCost,
-        };
-    }
-    if (decision !== null && decision !== undefined) {
-        return {
-            blocked: true,
-            result: success({
-                output: decision,
-                toolCalls: [],
-                usage: middlewareUsage,
-                cost: middlewareCost,
-            }),
-            usage: middlewareUsage,
-            cost: middlewareCost,
-        };
-    }
-    return {
-        blocked: false,
-        result: llmResult,
-        usage: middlewareUsage,
-        cost: middlewareCost,
-    };
-}
-/**
- * Run multiple middleware checks in sequential or parallel mode.
- * Returns a combined MiddlewareResult.
- */
-export async function runMiddlewareChecks(checks, mode, parentConfig, textSyncFn) {
-    if (mode === "sequential") {
-        return runSequential(checks, parentConfig, textSyncFn);
-    }
-    else {
-        return runParallel(checks, parentConfig, textSyncFn);
-    }
-}
-async function runSequential(checks, parentConfig, textSyncFn) {
-    let aggregatedUsage;
-    let aggregatedCost;
-    for (const check of checks) {
-        const checkResult = await runMiddlewareCheck(check, parentConfig, textSyncFn);
-        aggregatedUsage = addTokenUsage(aggregatedUsage, checkResult.usage);
-        aggregatedCost = safeAddCosts(aggregatedCost, checkResult.cost);
-        if (checkResult.blocked) {
-            if (checkResult.result.success) {
-                checkResult.result.value.usage = aggregatedUsage;
-                checkResult.result.value.cost = aggregatedCost;
-            }
-            return { ...checkResult, usage: aggregatedUsage, cost: aggregatedCost };
-        }
-    }
-    // When all checks pass, result is a placeholder — callers check `blocked` first
-    return {
-        blocked: false,
-        result: success({ output: null, toolCalls: [] }),
-        usage: aggregatedUsage,
-        cost: aggregatedCost,
-    };
-}
-async function runParallel(checks, parentConfig, textSyncFn) {
-    const results = await Promise.all(checks.map((check) => runMiddlewareCheck(check, parentConfig, textSyncFn)));
-    let aggregatedUsage;
-    let aggregatedCost;
-    for (const r of results) {
-        aggregatedUsage = addTokenUsage(aggregatedUsage, r.usage);
-        aggregatedCost = safeAddCosts(aggregatedCost, r.cost);
-    }
-    const firstBlocked = results.find((r) => r.blocked);
-    if (firstBlocked) {
-        if (firstBlocked.result.success) {
-            firstBlocked.result.value.usage = aggregatedUsage;
-            firstBlocked.result.value.cost = aggregatedCost;
-        }
-        return { ...firstBlocked, usage: aggregatedUsage, cost: aggregatedCost };
-    }
-    // When all checks pass, result is a placeholder — callers check `blocked` first
-    return {
-        blocked: false,
-        result: success({ output: null, toolCalls: [] }),
-        usage: aggregatedUsage,
-        cost: aggregatedCost,
-    };
-}
-/**
- * Wrapper around addCosts that handles currency mismatch gracefully.
- * If currencies differ, returns the first non-undefined cost (best effort).
- */
-function safeAddCosts(a, b) {
-    try {
-        return addCosts(a, b);
-    }
-    catch {
-        // addCosts throws on currency mismatch — return whichever is available
-        return a ?? b;
-    }
-}
-function stripMiddleware(config) {
-    const { middleware, ...rest } = config;
-    return rest;
-}
-/**
- * High-level middleware orchestration for sync calls.
- * Returns the blocked result if middleware blocks, the main prompt result for parallel timing,
- * or null to indicate "proceed normally" (no middleware or middleware passed with "before" timing).
- */
-export async function executeMiddlewareSync(config, runMainPrompt, textSyncFn) {
-    const middleware = config.middleware;
-    if (!middleware || middleware.checks.length === 0)
-        return null;
-    const configWithoutMiddleware = stripMiddleware(config);
-    if (middleware.timing === "before") {
-        const middlewareResult = await runMiddlewareChecks(middleware.checks, middleware.mode, configWithoutMiddleware, textSyncFn);
-        return middlewareResult.blocked ? middlewareResult.result : null;
-    }
-    if (middleware.timing === "parallel") {
-        const mainAbort = new AbortController();
-        const middlewareAbort = new AbortController();
-        const parentAbortSignal = configWithoutMiddleware.abortSignal;
-        const parentAbortHandler = parentAbortSignal
-            ? () => { mainAbort.abort(); middlewareAbort.abort(); }
-            : undefined;
-        if (parentAbortSignal && parentAbortHandler) {
-            parentAbortSignal.addEventListener("abort", parentAbortHandler, { once: true });
-        }
-        try {
-            const mainPromise = runMainPrompt({
-                ...configWithoutMiddleware,
-                abortSignal: mainAbort.signal,
-            });
-            const middlewareResult = await runMiddlewareChecks(middleware.checks, middleware.mode, { ...configWithoutMiddleware, abortSignal: middlewareAbort.signal }, textSyncFn);
-            if (middlewareResult.blocked) {
-                mainAbort.abort();
-                // Await the aborted main promise to capture any partial usage/cost
-                const mainPartialResult = await mainPromise.catch(() => undefined);
-                if (mainPartialResult?.success && middlewareResult.result.success) {
-                    const mainUsage = mainPartialResult.value.usage;
-                    const mainCost = mainPartialResult.value.cost;
-                    middlewareResult.result.value.usage = addTokenUsage(middlewareResult.result.value.usage, mainUsage);
-                    middlewareResult.result.value.cost = safeAddCosts(middlewareResult.result.value.cost, mainCost);
-                }
-                return middlewareResult.result;
-            }
-            return await mainPromise;
-        }
-        finally {
-            if (parentAbortSignal && parentAbortHandler) {
-                parentAbortSignal.removeEventListener("abort", parentAbortHandler);
-            }
-        }
-    }
-    return null;
-}
-/**
- * High-level middleware orchestration for streaming calls.
- * Yields stream chunks, handling middleware checks according to timing config.
- * Only call this when middleware is configured — the caller should check first.
- */
-export async function* executeMiddlewareStream(config, getStream, textSyncFn) {
-    const middleware = config.middleware;
-    const configWithoutMiddleware = stripMiddleware(config);
-    if (middleware.timing === "before") {
-        const middlewareResult = await runMiddlewareChecks(middleware.checks, middleware.mode, configWithoutMiddleware, textSyncFn);
-        if (middlewareResult.blocked) {
-            if (middlewareResult.result.success) {
-                yield { type: "done", result: middlewareResult.result.value };
-            }
-            else {
-                yield { type: "error", error: middlewareResult.result.error };
-            }
-            return;
-        }
-        yield* getStream(configWithoutMiddleware);
-        return;
-    }
-    if (middleware.timing === "parallel") {
-        const mainAbort = new AbortController();
-        const middlewareAbort = new AbortController();
-        const parentAbortSignal = configWithoutMiddleware.abortSignal;
-        const parentAbortHandler = parentAbortSignal
-            ? () => { mainAbort.abort(); middlewareAbort.abort(); }
-            : undefined;
-        if (parentAbortSignal && parentAbortHandler) {
-            parentAbortSignal.addEventListener("abort", parentAbortHandler, { once: true });
-        }
-        try {
-            const stream = getStream({
-                ...configWithoutMiddleware,
-                abortSignal: mainAbort.signal,
-            });
-            const middlewarePromise = runMiddlewareChecks(middleware.checks, middleware.mode, { ...configWithoutMiddleware, abortSignal: middlewareAbort.signal }, textSyncFn);
-            const buffer = [];
-            let streamDone = false;
-            let middlewareSettled = false;
-            let middlewareResult;
-            const middlewareFinished = middlewarePromise.then((r) => {
-                middlewareSettled = true;
-                middlewareResult = r;
-                return r;
-            });
-            const iterator = stream[Symbol.asyncIterator]();
-            while (true) {
-                // Race the next chunk against middleware completion so we can
-                // abort the main stream promptly when middleware blocks.
-                const next = iterator.next();
-                const raceResult = await Promise.race([
-                    next.then((v) => ({ source: "stream", ...v })),
-                    middlewareFinished.then(() => ({ source: "middleware", done: false, value: undefined })),
-                ]);
-                if (raceResult.source === "middleware") {
-                    // Middleware settled before the next chunk arrived.
-                    // The stream iterator is still pending — we'll handle it below.
-                    break;
-                }
-                if (raceResult.done) {
-                    streamDone = true;
-                    break;
-                }
-                const chunk = raceResult.value;
-                buffer.push(chunk);
-                if (chunk.type === "done" || chunk.type === "error") {
-                    streamDone = true;
-                }
-                if (middlewareSettled)
-                    break;
-            }
-            if (!middlewareSettled) {
-                middlewareResult = await middlewareFinished;
-            }
-            if (middlewareResult.blocked) {
-                mainAbort.abort();
-                // Check buffer for a done chunk that may contain partial usage/cost
-                const doneChunk = buffer.find((c) => c.type === "done");
-                if (doneChunk && middlewareResult.result.success) {
-                    middlewareResult.result.value.usage = addTokenUsage(middlewareResult.result.value.usage, doneChunk.result.usage);
-                    middlewareResult.result.value.cost = safeAddCosts(middlewareResult.result.value.cost, doneChunk.result.cost);
-                }
-                if (middlewareResult.result.success) {
-                    yield { type: "done", result: middlewareResult.result.value };
-                }
-                else {
-                    yield { type: "error", error: middlewareResult.result.error };
-                }
-                return;
-            }
-            for (const chunk of buffer) {
-                yield chunk;
-            }
-            if (!streamDone) {
-                while (true) {
-                    const { value: chunk, done } = await iterator.next();
-                    if (done)
-                        break;
-                    yield chunk;
-                }
-            }
-            return;
-        }
-        finally {
-            if (parentAbortSignal && parentAbortHandler) {
-                parentAbortSignal.removeEventListener("abort", parentAbortHandler);
-            }
-        }
-    }
-}

package/dist/strategies/baseStrategy.d.ts

@@ -1,22 +0,0 @@
-import { StatelogClient } from "../statelogClient.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: 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): 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,62 +0,0 @@
-import { getStatelogClient } from "../statelogClient.js";
-export class BaseStrategy {
-    statelogClient;
-    text(config) {
-        this.statelogClient = config.statelog
-            ? getStatelogClient(config.statelog)
-            : undefined;
-        this.statelogClient?.debug(`Starting strategy ${this.toString()}`);
-        if (config.hooks?.onStrategyStart) {
-            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) {
-        this.statelogClient = config.statelog
-            ? getStatelogClient(config.statelog)
-            : undefined;
-        this.statelogClient?.debug(`Starting strategy (sync) ${this.toString()}`);
-        return this._textSync(config);
-    }
-    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.");
-    }
-    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.");
-    }
-    toString() {
-        return "BaseStrategy";
-    }
-    toShortString() {
-        return this.toString();
-    }
-}

package/dist/strategies/fallbackStrategy.d.ts

@@ -1,14 +0,0 @@
-import { ModelParam, PromptResult, Result, SmolPromptConfig } from "../types.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { FallbackStrategyConfig, Strategy, StrategyJSON } from "./types.js";
-export declare class FallbackStrategy extends BaseStrategy {
-    primaryStrategy: Strategy;
-    config: FallbackStrategyConfig;
-    constructor(primaryStrategy: ModelParam, config: FallbackStrategyConfig);
-    toString(): string;
-    toShortString(): string;
-    _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
-    _textWithFallbacks(config: SmolPromptConfig, strategy: Strategy, fallbackStrategies: FallbackStrategyConfig): Promise<Result<PromptResult>>;
-    toJSON(): StrategyJSON;
-    static fromJSON(json: unknown): FallbackStrategy;
-}

package/dist/strategies/fallbackStrategy.js

@@ -1,122 +0,0 @@
-import { z } from "zod";
-import { SmolContentPolicyError, SmolContextWindowExceededError, SmolStructuredOutputError, SmolTimeoutError, } from "../smolError.js";
-import { success, } from "../types.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { IDStrategy } from "./idStrategy.js";
-import { fromJSON } from "./index.js";
-import { FallbackStrategyJSONSchema, } from "./types.js";
-export class FallbackStrategy extends BaseStrategy {
-    primaryStrategy;
-    config;
-    constructor(primaryStrategy, config) {
-        super();
-        this.primaryStrategy =
-            primaryStrategy instanceof BaseStrategy
-                ? primaryStrategy
-                : new IDStrategy(primaryStrategy);
-        this.config = config;
-    }
-    toString() {
-        return `FallbackStrategy([${this.primaryStrategy.toString()}], config: ${JSON.stringify(this.config)})`;
-    }
-    toShortString() {
-        return `fallback([${this.primaryStrategy.toString()}])`;
-    }
-    async _text(config) {
-        return this._textWithFallbacks(config, this.primaryStrategy, this.config);
-    }
-    async _textWithFallbacks(config, strategy, fallbackStrategies) {
-        try {
-            const result = await strategy.text(config);
-            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 (fallbackStrategies.timeout &&
-                    fallbackStrategies.timeout.length > 0) {
-                    this.statelogClient?.debug("FallbackStrategy: falling back due to timeout", {
-                        failedStrategy: strategy.toString(),
-                    });
-                    return this._textWithFallbacks(config, fromJSON(fallbackStrategies.timeout[0]), 
-                    // from here on, only consider the remaining fallbacks for this specific reason
-                    { timeout: fallbackStrategies.timeout.slice(1) });
-                }
-            }
-            else if (error instanceof SmolStructuredOutputError) {
-                if (fallbackStrategies.structuredOutputFailure &&
-                    fallbackStrategies.structuredOutputFailure.length > 0) {
-                    this.statelogClient?.debug("FallbackStrategy: falling back due to structured output failure", {
-                        failedStrategy: strategy.toString(),
-                    });
-                    return this._textWithFallbacks(config, fromJSON(fallbackStrategies.structuredOutputFailure[0]), 
-                    // from here on, only consider the remaining fallbacks for this specific reason
-                    {
-                        structuredOutputFailure: fallbackStrategies.structuredOutputFailure.slice(1),
-                    });
-                }
-            }
-            else if (error instanceof SmolContentPolicyError) {
-                if (fallbackStrategies.contentPolicyViolation &&
-                    fallbackStrategies.contentPolicyViolation.length > 0) {
-                    this.statelogClient?.debug("FallbackStrategy: falling back due to content policy violation", {
-                        failedStrategy: strategy.toString(),
-                    });
-                    return this._textWithFallbacks(config, fromJSON(fallbackStrategies.contentPolicyViolation[0]), {
-                        contentPolicyViolation: fallbackStrategies.contentPolicyViolation.slice(1),
-                    });
-                }
-            }
-            else if (error instanceof SmolContextWindowExceededError) {
-                if (fallbackStrategies.contextWindowExceeded &&
-                    fallbackStrategies.contextWindowExceeded.length > 0) {
-                    this.statelogClient?.debug("FallbackStrategy: falling back due to context window exceeded", {
-                        failedStrategy: strategy.toString(),
-                    });
-                    return this._textWithFallbacks(config, fromJSON(fallbackStrategies.contextWindowExceeded[0]), {
-                        contextWindowExceeded: fallbackStrategies.contextWindowExceeded.slice(1),
-                    });
-                }
-            }
-            if (fallbackStrategies.error && fallbackStrategies.error.length > 0) {
-                this.statelogClient?.debug("FallbackStrategy: falling back due to error", {
-                    failedStrategy: strategy.toString(),
-                    error: error.message,
-                });
-                return this._textWithFallbacks(config, fromJSON(fallbackStrategies.error[0]), 
-                // from here on, only consider the remaining fallbacks for this specific reason
-                { error: fallbackStrategies.error.slice(1) });
-            }
-            this.statelogClient?.debug("All strategies in FallbackStrategy failed", {
-                fallbackStrategy: this.toJSON(),
-                strategy,
-                fallbackStrategies,
-            });
-            throw error;
-        }
-    }
-    toJSON() {
-        return {
-            type: "fallback",
-            params: {
-                primaryStrategy: this.primaryStrategy.toJSON(),
-                config: this.config,
-            },
-        };
-    }
-    static fromJSON(json) {
-        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.d.ts

@@ -1,19 +0,0 @@
-import { Model } from "../model.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 {
-    models: (string | Model)[];
-    epsilon: number;
-    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;
-    toJSON(): StrategyJSON;
-    static fromJSON(json: unknown): FastestStrategy;
-}

package/dist/strategies/fastestStrategy.js

@@ -1,108 +0,0 @@
-import { z } from "zod";
-import { latencyTracker } from "../latencyTracker.js";
-import { getLogger } from "../util/logger.js";
-import { Model } from "../model.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { IDStrategy } from "./idStrategy.js";
-import { FastestStrategyJSONSchema, } from "./types.js";
-// what percentage of the time to explore (pick a random model instead of the fastest) - this prevents us from getting stuck on a model that was fast in the past but has since become slow
-const DEFAULT_EPSILON = 0.1;
-export class FastestStrategy extends BaseStrategy {
-    models;
-    epsilon;
-    constructor(models, epsilon = DEFAULT_EPSILON) {
-        super();
-        this.models = models;
-        this.epsilon = epsilon;
-    }
-    toString() {
-        return `FastestStrategy([${this.models.map((s) => s.toString()).join(", ")}])`;
-    }
-    toShortString() {
-        return `fastest([${this.models.map((s) => s.toString()).join(", ")}])`;
-    }
-    chooseModel(config) {
-        const resolved = this.models.map((model) => Model.create(model));
-        const logger = getLogger(config.logLevel);
-        if (Math.random() < this.epsilon) {
-            // Explore: pick a random model
-            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;
-        }
-        // 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;
-        for (let model of models) {
-            const speed = this.getSpeed(model);
-            if (speed && speed > bestSpeed) {
-                bestSpeed = speed;
-                best = model;
-            }
-        }
-        return best;
-    }
-    /** Get tokens/sec for a model: tracked latency first, then static estimate, then 0. */
-    getSpeed(model) {
-        const MIN_SAMPLES = 3;
-        const tracked = latencyTracker.getTokensPerSecond(model.getResolvedModel(), MIN_SAMPLES);
-        return tracked;
-    }
-    toJSON() {
-        return {
-            type: "fastest",
-            params: {
-                models: this.models.map((s) => (s instanceof Model ? s.toJSON() : s)),
-            },
-        };
-    }
-    static fromJSON(json) {
-        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);
-    }
-}