smoltalk 0.0.67 → 0.2.2

package/dist/strategies/idStrategy.d.ts

@@ -1,16 +0,0 @@
-import { Model } from "../model.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 {
-    model: Model;
-    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

@@ -1,62 +0,0 @@
-import { getClient } from "../client.js";
-import { splitConfig } from "../functions.js";
-import { Model } from "../model.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { IDStrategyJSONSchema, } from "./types.js";
-export class IDStrategy extends BaseStrategy {
-    model;
-    constructor(model, provider) {
-        super();
-        this.model = Model.create(model, provider);
-    }
-    toString() {
-        return `IDStrategy(${this.model.toString()})`;
-    }
-    toShortString() {
-        return `id(${this.model.toString()})`;
-    }
-    _getClientAndConfig(config) {
-        const configOverrides = {
-            model: this.model.getResolvedModel(),
-            provider: this.model.getProvider(),
-        };
-        const { smolConfig, promptConfig } = splitConfig({
-            ...config,
-            ...configOverrides,
-        });
-        const client = getClient({
-            ...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() {
-        return {
-            type: "id",
-            params: {
-                model: this.model.getResolvedModel(),
-                provider: this.model.getProvider(),
-            },
-        };
-    }
-    static fromJSON(json) {
-        const parsed = IDStrategyJSONSchema.safeParse(json);
-        if (parsed.success) {
-            return new IDStrategy(parsed.data.params.model, parsed.data.params.provider);
-        }
-        throw new Error(`Invalid IDStrategy JSON: ${JSON.stringify(json)}`);
-    }
-}

package/dist/strategies/index.d.ts

@@ -1,17 +0,0 @@
-import { Model } from "../model.js";
-import { ModelLike, ModelParam } 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 "./randomStrategy.js";
-export * from "./timeoutStrategy.js";
-export * from "./types.js";
-export declare function race(...strategies: ModelParam[]): Strategy;
-export declare function random(...strategies: ModelParam[]): Strategy;
-export declare function fastest(models: (string | Model)[], epsilon?: number): Strategy;
-export declare function id(model: ModelLike): Strategy;
-export declare function timeout(strategy: ModelParam, timeoutMs: number): Strategy;
-export declare function fallback(primaryStrategy: ModelParam, config: FallbackStrategyConfig | string | string[]): Strategy;
-export declare function fromJSON(json: StrategyJSON): Strategy;

package/dist/strategies/index.js

@@ -1,68 +0,0 @@
-import { FallbackStrategy } from "./fallbackStrategy.js";
-import { FastestStrategy } from "./fastestStrategy.js";
-import { IDStrategy } from "./idStrategy.js";
-import { RaceStrategy } from "./raceStrategy.js";
-import { RandomStrategy } from "./randomStrategy.js";
-import { TimeoutStrategy } from "./timeoutStrategy.js";
-import { FallbackStrategyJSONSchema, FastestStrategyJSONSchema, IDStrategyJSONSchema, RaceStrategyJSONSchema, RandomStrategyJSONSchema, TimeoutStrategyJSONSchema, } from "./types.js";
-export * from "./baseStrategy.js";
-export * from "./fallbackStrategy.js";
-export * from "./idStrategy.js";
-export * from "./raceStrategy.js";
-export * from "./randomStrategy.js";
-export * from "./timeoutStrategy.js";
-export * from "./types.js";
-export function race(...strategies) {
-    return new RaceStrategy(strategies);
-}
-export function random(...strategies) {
-    return new RandomStrategy(...strategies);
-}
-export function fastest(models, epsilon) {
-    return new FastestStrategy(models, epsilon);
-}
-export function id(model) {
-    return new IDStrategy(model);
-}
-export function timeout(strategy, timeoutMs) {
-    return new TimeoutStrategy(strategy, timeoutMs);
-}
-export function fallback(primaryStrategy, config) {
-    let resolvedConfig;
-    if (typeof config === "string") {
-        resolvedConfig = { error: [config] };
-    }
-    else if (Array.isArray(config)) {
-        resolvedConfig = { error: config };
-    }
-    else {
-        resolvedConfig = config;
-    }
-    return new FallbackStrategy(primaryStrategy, resolvedConfig);
-}
-export function fromJSON(json) {
-    if (IDStrategyJSONSchema.safeParse(json).success) {
-        return IDStrategy.fromJSON(json);
-    }
-    else if (RaceStrategyJSONSchema.safeParse(json).success) {
-        return RaceStrategy.fromJSON(json);
-    }
-    else if (FallbackStrategyJSONSchema.safeParse(json).success) {
-        return FallbackStrategy.fromJSON(json);
-    }
-    else if (RandomStrategyJSONSchema.safeParse(json).success) {
-        return RandomStrategy.fromJSON(json);
-    }
-    else if (FastestStrategyJSONSchema.safeParse(json).success) {
-        return FastestStrategy.fromJSON(json);
-    }
-    else if (TimeoutStrategyJSONSchema.safeParse(json).success) {
-        return TimeoutStrategy.fromJSON(json);
-    }
-    else if (typeof json === "string") {
-        return id(json);
-    }
-    else {
-        throw new Error(`Unknown strategy JSON: ${JSON.stringify(json)}`);
-    }
-}

package/dist/strategies/raceStrategy.d.ts

@@ -1,12 +0,0 @@
-import { ModelParam, PromptResult, 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: ModelParam[]);
-    toString(): string;
-    toShortString(): string;
-    _text(config: SmolPromptConfig): Promise<import("../types.js").Failure | import("../types.js").Success<PromptResult>>;
-    toJSON(): StrategyJSON;
-    static fromJSON(json: unknown): RaceStrategy;
-}

package/dist/strategies/raceStrategy.js

@@ -1,72 +0,0 @@
-import { z } from "zod";
-import { getLogger } from "../util/logger.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { fromJSON, IDStrategy } from "./index.js";
-import { RaceStrategyJSONSchema, } from "./types.js";
-export class RaceStrategy extends BaseStrategy {
-    strategies;
-    constructor(strategies) {
-        super();
-        this.strategies = strategies.map((s) => s instanceof BaseStrategy ? s : new IDStrategy(s));
-    }
-    toString() {
-        return `RaceStrategy([${this.strategies.map((s) => s.toString()).join(", ")}])`;
-    }
-    toShortString() {
-        return `race(${this.strategies.map((s) => s.toShortString?.() || s.toString()).join(", ")})`;
-    }
-    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,
-            });
-        });
-        let winnerIndex = null;
-        return Promise.race(promises.map((p, i) => p.then((result) => {
-            if (winnerIndex !== null) {
-                // This strategy resolved after the winner (e.g. due to being aborted).
-                // Do not attempt to abort other strategies again.
-                return result;
-            }
-            winnerIndex = i;
-            for (let j = 0; j < controllers.length; j++) {
-                if (j !== i) {
-                    const logger = getLogger();
-                    logger.debug(`RaceStrategy: aborting strategy ${this.strategies[j]} because strategy ${this.strategies[i]} won the race.`);
-                    this.statelogClient?.debug("RaceStrategy: aborting losing strategy", {
-                        winner: this.strategies[i].toString(),
-                        aborted: this.strategies[j].toString(),
-                    });
-                    controllers[j].abort();
-                }
-            }
-            return result;
-        })));
-    }
-    toJSON() {
-        return {
-            type: "race",
-            params: { strategies: this.strategies.map((s) => s.toJSON()) },
-        };
-    }
-    static fromJSON(json) {
-        const result = RaceStrategyJSONSchema.safeParse(json);
-        if (!result.success) {
-            console.error("Failed to parse RaceStrategy");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
-            throw new Error("Failed to parse RaceStrategy");
-        }
-        const strategies = result.data.params.strategies.map((s) => fromJSON(s));
-        return new RaceStrategy(strategies);
-    }
-}

package/dist/strategies/randomStrategy.d.ts

@@ -1,13 +0,0 @@
-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 {
-    strategies: Strategy[];
-    constructor(...strategies: (Strategy | ModelParam)[]);
-    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

@@ -1,54 +0,0 @@
-import { z } from "zod";
-import { BaseStrategy } from "./baseStrategy.js";
-import { IDStrategy } from "./idStrategy.js";
-import { fromJSON } from "./index.js";
-import { RandomStrategyJSONSchema } from "./types.js";
-export class RandomStrategy extends BaseStrategy {
-    strategies;
-    constructor(...strategies) {
-        super();
-        this.strategies = strategies.map((s) => s instanceof BaseStrategy ? s : new IDStrategy(s));
-    }
-    toString() {
-        return `RandomStrategy([${this.strategies.map((s) => s.toString()).join(", ")}])`;
-    }
-    toShortString() {
-        return `random([${this.strategies.map((s) => s.toString()).join(", ")}])`;
-    }
-    async _text(config) {
-        const randomIndex = Math.floor(Math.random() * this.strategies.length);
-        const strategy = this.strategies[randomIndex];
-        this.statelogClient?.debug("random strategy chosen", {
-            strategy,
-        });
-        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",
-            params: {
-                strategies: this.strategies.map((s) => s.toJSON()),
-            },
-        };
-    }
-    static fromJSON(json) {
-        const result = RandomStrategyJSONSchema.safeParse(json);
-        if (!result.success) {
-            console.error("Failed to parse RandomStrategy");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
-            throw new Error("Failed to parse RandomStrategy");
-        }
-        const strategies = result.data.params.strategies.map((s) => fromJSON(s));
-        return new RandomStrategy(...strategies);
-    }
-}

package/dist/strategies/timeoutStrategy.d.ts

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

package/dist/strategies/timeoutStrategy.js

@@ -1,65 +0,0 @@
-import { z } from "zod";
-import { SmolTimeoutError } from "../smolError.js";
-import { BaseStrategy } from "./baseStrategy.js";
-import { IDStrategy } from "./idStrategy.js";
-import { fromJSON } from "./index.js";
-import { TimeoutStrategyJSONSchema, } from "./types.js";
-export class TimeoutStrategy extends BaseStrategy {
-    strategy;
-    timeoutMs;
-    constructor(strategy, timeoutMs) {
-        super();
-        this.strategy =
-            strategy instanceof BaseStrategy
-                ? strategy
-                : new IDStrategy(strategy);
-        this.timeoutMs = timeoutMs;
-    }
-    toString() {
-        return `TimeoutStrategy(${this.strategy.toString()}, ${this.timeoutMs}ms)`;
-    }
-    toShortString() {
-        return `timeout(${this.strategy.toShortString?.() || this.strategy.toString()}, ${this.timeoutMs}ms)`;
-    }
-    async _text(config) {
-        const controller = new AbortController();
-        // Link to any existing abort signal
-        if (config.abortSignal) {
-            const external = config.abortSignal;
-            external.addEventListener("abort", () => controller.abort(external.reason), { once: true });
-        }
-        const timeoutPromise = new Promise((_, reject) => {
-            const timer = setTimeout(() => {
-                controller.abort();
-                reject(new SmolTimeoutError(`Strategy timed out after ${this.timeoutMs}ms`));
-            }, this.timeoutMs);
-            // Clear timeout if the controller is aborted externally
-            controller.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
-        });
-        const resultPromise = this.strategy.text({
-            ...config,
-            abortSignal: controller.signal,
-        });
-        return Promise.race([resultPromise, timeoutPromise]);
-    }
-    toJSON() {
-        return {
-            type: "timeout",
-            params: {
-                strategy: this.strategy.toJSON(),
-                timeoutMs: this.timeoutMs,
-            },
-        };
-    }
-    static fromJSON(json) {
-        const result = TimeoutStrategyJSONSchema.safeParse(json);
-        if (!result.success) {
-            console.error("Failed to parse TimeoutStrategy");
-            console.error(JSON.stringify(json, null, 2));
-            console.error(z.prettifyError(result.error));
-            throw new Error("Failed to parse TimeoutStrategy");
-        }
-        const strategy = fromJSON(result.data.params.strategy);
-        return new TimeoutStrategy(strategy, result.data.params.timeoutMs);
-    }
-}

package/dist/strategies/types.d.ts

@@ -1,78 +0,0 @@
-import { z } from "zod";
-import { SmolPromptConfig, Result, PromptResult, StreamChunk } from "../types.js";
-export interface Strategy {
-    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): AsyncGenerator<StreamChunk>;
-    _textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
-    toJSON(): StrategyJSON;
-    toString(): string;
-    toShortString(): string;
-}
-export declare const FallbackReasonSchema: z.ZodEnum<{
-    error: "error";
-    timeout: "timeout";
-    structuredOutputFailure: "structuredOutputFailure";
-    contentPolicyViolation: "contentPolicyViolation";
-    contextWindowExceeded: "contextWindowExceeded";
-}>;
-export declare const FallbackStrategyConfigSchema: z.ZodLazy<z.ZodRecord<z.ZodEnum<{
-    error: "error";
-    timeout: "timeout";
-    structuredOutputFailure: "structuredOutputFailure";
-    contentPolicyViolation: "contentPolicyViolation";
-    contextWindowExceeded: "contextWindowExceeded";
-}> & z.core.$partial, z.ZodArray<z.ZodType<StrategyJSON, unknown, z.core.$ZodTypeInternals<StrategyJSON, unknown>>>>>;
-export type FallbackReason = z.infer<typeof FallbackReasonSchema>;
-export type FallbackStrategyConfig = z.infer<typeof FallbackStrategyConfigSchema>;
-export type StrategyJSON = string | IDStrategyJSON | RaceStrategyJSON | FallbackStrategyJSON | RandomStrategyJSON | FastestStrategyJSON | TimeoutStrategyJSON;
-export declare const IDStrategyJSONSchema: z.ZodObject<{
-    type: z.ZodLiteral<"id">;
-    params: z.ZodObject<{
-        model: z.ZodString;
-        provider: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type IDStrategyJSON = z.infer<typeof IDStrategyJSONSchema>;
-export declare const RaceStrategyJSONSchema: z.ZodType<RaceStrategyJSON>;
-export type RaceStrategyJSON = {
-    type: "race";
-    params: {
-        strategies: StrategyJSON[];
-    };
-};
-export declare const FallbackStrategyJSONSchema: z.ZodType<FallbackStrategyJSON>;
-export type FallbackStrategyJSON = {
-    type: "fallback";
-    params: {
-        primaryStrategy: StrategyJSON;
-        config: FallbackStrategyConfig;
-    };
-};
-export declare const RandomStrategyJSONSchema: z.ZodType<RandomStrategyJSON>;
-export type RandomStrategyJSON = {
-    type: "random";
-    params: {
-        strategies: StrategyJSON[];
-    };
-};
-export declare const FastestStrategyJSONSchema: z.ZodType<FastestStrategyJSON>;
-export type FastestStrategyJSON = {
-    type: "fastest";
-    params: {
-        models: string[];
-    };
-};
-export declare const TimeoutStrategyJSONSchema: z.ZodType<TimeoutStrategyJSON>;
-export type TimeoutStrategyJSON = {
-    type: "timeout";
-    params: {
-        strategy: StrategyJSON;
-        timeoutMs: number;
-    };
-};
-export declare const ModelNameSchema: z.ZodString;
-export declare const StrategyJSONSchema: z.ZodType<StrategyJSON>;
-export declare function isStrategy(value: unknown): value is StrategyJSON;

package/dist/strategies/types.js

@@ -1,58 +0,0 @@
-import { z } from "zod";
-export const FallbackReasonSchema = z.enum([
-    "error",
-    "timeout",
-    "structuredOutputFailure",
-    "contentPolicyViolation",
-    "contextWindowExceeded",
-]);
-export const FallbackStrategyConfigSchema = z.lazy(() => z.partialRecord(FallbackReasonSchema, z.array(StrategyJSONSchema)));
-export const IDStrategyJSONSchema = z.object({
-    type: z.literal("id"),
-    params: z.object({ model: z.string(), provider: z.string().optional() }),
-});
-export const RaceStrategyJSONSchema = z.lazy(() => z.object({
-    type: z.literal("race"),
-    params: z.object({ strategies: z.array(StrategyJSONSchema) }),
-}));
-export const FallbackStrategyJSONSchema = z.lazy(() => z.object({
-    type: z.literal("fallback"),
-    params: z.object({
-        primaryStrategy: StrategyJSONSchema,
-        config: FallbackStrategyConfigSchema,
-    }),
-}));
-export const RandomStrategyJSONSchema = z.lazy(() => z.object({
-    type: z.literal("random"),
-    params: z.object({ strategies: z.array(StrategyJSONSchema) }),
-}));
-export const FastestStrategyJSONSchema = z.lazy(() => z.object({
-    type: z.literal("fastest"),
-    params: z.object({
-        models: z.array(z.string()),
-    }),
-}));
-export const TimeoutStrategyJSONSchema = z.lazy(() => z.object({
-    type: z.literal("timeout"),
-    params: z.object({
-        strategy: StrategyJSONSchema,
-        timeoutMs: z.number(),
-    }),
-}));
-export const ModelNameSchema = z
-    .string()
-    .regex(/^[a-zA-Z0-9._:-]+$/, "Model name must only contain letters, numbers, dots, underscores, hyphens, and colons");
-export const StrategyJSONSchema = z.lazy(() => z.union([
-    ModelNameSchema,
-    IDStrategyJSONSchema,
-    RaceStrategyJSONSchema,
-    FallbackStrategyJSONSchema,
-    RandomStrategyJSONSchema,
-    FastestStrategyJSONSchema,
-    TimeoutStrategyJSONSchema,
-]));
-// Helper to detect if a value is a StrategyJSON object (not a plain string)
-export function isStrategy(value) {
-    const result = StrategyJSONSchema.safeParse(value);
-    return result.success;
-}