smoltalk 0.0.52 → 0.0.53

package/dist/statelogClient.js

@@ -24,9 +24,9 @@ export class StatelogClient {
         this.debugMode = debugMode || false;
         this.traceId = traceId || nanoid();
         if (this.debugMode) {
-            console.log(`Statelog client initialized with host: ${host} and traceId: ${this.traceId}`, { config });
+            console.log(`Statelog client initialized with host: ${host} and traceId: ${this.traceId}`, { ...config, apiKey: "unset or [REDACTED]" });
         }
-        if (!this.apiKey) {
+        if (!this.apiKey || this.apiKey.trim() === "") {
             throw new Error("API key is required for StatelogClient");
         }
     }
@@ -141,7 +141,8 @@ export class StatelogClient {
             const fullUrl = new URL(`/api/projects/${projectId}/upload`, this.host);
             const url = fullUrl.toString();
             const postBody = JSON.stringify({ entrypoint, files });
-            console.log({ entrypoint, files }, postBody);
+            if (this.debugMode)
+                console.log({ entrypoint, fileCount: files.length });
             const result = await fetch(url, {
                 method: "POST",
                 headers: {
@@ -183,7 +184,8 @@ export class StatelogClient {
                 entrypoint,
                 args,
             });
-            console.log({ entrypoint, args }, body);
+            if (this.debugMode)
+                console.log({ entrypoint, argCount: args?.length });
             const result = await fetch(url, {
                 method: "POST",
                 headers: {

package/dist/strategies/baseStrategy.js

@@ -10,14 +10,14 @@ export class BaseStrategy {
             this.statelogClient?.debug(`Calling onStrategyStart hook for strategy ${this.toString()}`);
             config.hooks.onStrategyStart(this, config);
         }
-        return this._text({ ...config, strategy: undefined });
+        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, strategy: undefined });
+        return this._textSync(config);
     }
     async textStream(config) {
         throw new Error("textStream method not implemented.");

package/dist/strategies/fallbackStrategy.d.ts

@@ -1,15 +1,14 @@
-import { SmolPromptConfig } from "../types.js";
+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 {
-    strategies: Strategy[];
+    primaryStrategy: Strategy;
     config: FallbackStrategyConfig;
-    constructor(strategies: Strategy[], config: FallbackStrategyConfig);
+    constructor(primaryStrategy: ModelParam, config: FallbackStrategyConfig);
     toString(): string;
     toShortString(): string;
-    _text(config: SmolPromptConfig): Promise<import("../types.js").Result<import("../types.js").PromptResult> | import("../types.js").Success<{
-        output: null;
-        toolCalls: never[];
-    }>>;
+    _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,80 +1,93 @@
 import { SmolStructuredOutputError, SmolTimeoutError } from "../smolError.js";
-import { success } from "../types.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 {
-    strategies;
+    primaryStrategy;
     config;
-    constructor(strategies, config) {
+    constructor(primaryStrategy, config) {
         super();
-        this.strategies = strategies;
+        this.primaryStrategy =
+            primaryStrategy instanceof BaseStrategy
+                ? primaryStrategy
+                : new IDStrategy(primaryStrategy);
         this.config = config;
     }
     toString() {
-        return `FallbackStrategy([${this.strategies.map((s) => s.toString()).join(", ")}], config: ${JSON.stringify(this.config)})`;
+        return `FallbackStrategy([${this.primaryStrategy.toString()}], config: ${JSON.stringify(this.config)})`;
     }
     toShortString() {
-        return `fallback([${this.strategies.map((s) => s.toShortString?.() || s.toString()).join(", ")}])`;
+        return `fallback([${this.primaryStrategy.toString()}])`;
     }
     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;
+        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: [] });
             }
-            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 (this.config.fallbackOn.includes("timeout")) {
-                        this.statelogClient?.debug("FallbackStrategy: falling back due to timeout", {
-                            failedStrategy: strategy.toString(),
-                            strategyIndex: i,
-                        });
-                        continue;
-                    }
-                }
-                else if (error instanceof SmolStructuredOutputError) {
-                    if (this.config.fallbackOn.includes("structuredOutputFailure")) {
-                        this.statelogClient?.debug("FallbackStrategy: falling back due to structured output failure", {
-                            failedStrategy: strategy.toString(),
-                            strategyIndex: i,
-                        });
-                        continue;
-                    }
+            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) });
                 }
-                if (this.config.fallbackOn.includes("error")) {
-                    this.statelogClient?.debug("FallbackStrategy: falling back due to error", {
+            }
+            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(),
-                        strategyIndex: i,
-                        error: error.message,
                     });
-                    continue;
+                    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),
+                    });
                 }
-                this.statelogClient?.debug("FallbackStrategy error", {
+            }
+            if (fallbackStrategies.error && fallbackStrategies.error.length > 0) {
+                this.statelogClient?.debug("FallbackStrategy: falling back due to error", {
                     failedStrategy: strategy.toString(),
-                    strategyIndex: i,
-                    strategies: this.strategies.map((s) => s.toString()),
                     error: error.message,
                 });
-                throw error;
+                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;
         }
-        this.statelogClient?.debug("All strategies in FallbackStrategy failed", {
-            strategies: this.strategies.map((s) => s.toString()),
-        });
-        throw new Error(`All fallback strategies failed.`);
     }
     toJSON() {
         return {
             type: "fallback",
             params: {
-                strategies: this.strategies.map((s) => s.toJSON()),
+                primaryStrategy: this.primaryStrategy.toJSON(),
                 config: this.config,
             },
         };
     }
+    static fromJSON(json) {
+        const parsed = FallbackStrategyJSONSchema.parse(json);
+        const primaryStrategy = fromJSON(parsed.params.primaryStrategy);
+        return new FallbackStrategy(primaryStrategy, parsed.params.config);
+    }
 }

package/dist/strategies/idStrategy.d.ts

@@ -1,12 +1,14 @@
 import { Model } from "../model.js";
-import { SmolPromptConfig } from "../types.js";
+import { ModelLike, PromptResult, Result, 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);
+    constructor(model: ModelLike, provider?: string);
     toString(): string;
     toShortString(): string;
-    _text(_config: SmolPromptConfig): Promise<import("../types.js").Result<import("../types.js").PromptResult>>;
+    _text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
+    _textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
     toJSON(): StrategyJSON;
+    static fromJSON(json: unknown): IDStrategy;
 }

package/dist/strategies/idStrategy.js

@@ -1,25 +1,59 @@
-import { text } from "../functions.js";
+import { getClient } from "../client.js";
+import { splitConfig } from "../functions.js";
+import { Model } from "../model.js";
 import { BaseStrategy } from "./baseStrategy.js";
+import { IDStrategyJSONSchema, ModelNameAndProviderSchema, } from "./types.js";
 export class IDStrategy extends BaseStrategy {
     model;
-    constructor(model) {
+    constructor(model, provider) {
         super();
-        this.model = model;
+        this.model = Model.create(model, provider);
     }
     toString() {
-        return `IDStrategy(model: ${this.model.getResolvedModel()})`;
+        return `IDStrategy(${this.model.toString()})`;
     }
     toShortString() {
-        return `id(${this.model.getResolvedModel()})`;
+        return `id(${this.model.toString()})`;
     }
-    async _text(_config) {
-        const config = {
-            ..._config,
+    async _text(config) {
+        return this._textSync(config);
+    }
+    async _textSync(config) {
+        const configOverrides = {
             model: this.model.getResolvedModel(),
+            provider: this.model.getProvider(),
         };
-        return text({ ...config, stream: false });
+        const { smolConfig, promptConfig } = splitConfig({
+            ...config,
+            ...configOverrides,
+        });
+        const client = getClient({
+            ...smolConfig,
+            ...configOverrides,
+        });
+        return client.textSync(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() } };
+        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);
+        }
+        const parsedNameAndProvider = ModelNameAndProviderSchema.safeParse(json);
+        if (parsedNameAndProvider.success) {
+            const { model, provider } = parsedNameAndProvider.data;
+            return new IDStrategy(model, provider);
+        }
+        throw new Error(`Invalid IDStrategy JSON: ${JSON.stringify(json)}`);
     }
 }

package/dist/strategies/index.d.ts

@@ -1,11 +1,11 @@
-import { ModelLike } from "../types.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 "./types.js";
-export declare function race(..._strategies: (Strategy | ModelLike)[]): Strategy;
+export declare function race(...strategies: ModelParam[]): Strategy;
 export declare function id(model: ModelLike): Strategy;
-export declare function fallback(_strategies: (Strategy | ModelLike)[], config: FallbackStrategyConfig): Strategy;
+export declare function fallback(primaryStrategy: ModelParam, config: FallbackStrategyConfig): Strategy;
 export declare function fromJSON(json: StrategyJSON): Strategy;

package/dist/strategies/index.js

@@ -1,40 +1,38 @@
-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";
+import { FallbackStrategyJSONSchema, IDStrategyJSONSchema, ModelNameAndProviderSchema, RaceStrategyJSONSchema, } from "./types.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)));
+export function race(...strategies) {
     return new RaceStrategy(strategies);
 }
 export function id(model) {
-    return new IDStrategy(Model.create(model));
+    return new IDStrategy(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 fallback(primaryStrategy, config) {
+    return new FallbackStrategy(primaryStrategy, config);
 }
 export function fromJSON(json) {
-    if (typeof json === "string") {
+    if (IDStrategyJSONSchema.safeParse(json).success) {
+        return IDStrategy.fromJSON(json);
+    }
+    else if (ModelNameAndProviderSchema.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 (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}`);
+    else {
+        throw new Error(`Unknown strategy JSON: ${JSON.stringify(json)}`);
     }
 }

package/dist/strategies/raceStrategy.d.ts

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

package/dist/strategies/raceStrategy.js

@@ -1,10 +1,12 @@
 import { getLogger } from "../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;
+        this.strategies = strategies.map((s) => s instanceof BaseStrategy ? s : new IDStrategy(s));
     }
     toString() {
         return `RaceStrategy([${this.strategies.map((s) => s.toString()).join(", ")}])`;
@@ -55,4 +57,9 @@ export class RaceStrategy extends BaseStrategy {
             params: { strategies: this.strategies.map((s) => s.toJSON()) },
         };
     }
+    static fromJSON(json) {
+        const parsed = RaceStrategyJSONSchema.parse(json);
+        const strategies = parsed.params.strategies.map((s) => fromJSON(s));
+        return new RaceStrategy(strategies);
+    }
 }

package/dist/strategies/types.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { SmolPromptConfig, Result, PromptResult } from "../types.js";
 export interface Strategy {
     text(config: SmolPromptConfig): Promise<Result<PromptResult>>;
@@ -9,25 +10,79 @@ export interface Strategy {
     toString(): string;
     toShortString(): string;
 }
-type FallbackReason = "error" | "timeout" | "structuredOutputFailure";
-export type FallbackStrategyConfig = {
-    fallbackOn: FallbackReason[];
-};
-export type StrategyJSON = string | {
-    type: "id";
-    params: {
-        model: string;
-    };
-} | {
+export declare const FallbackReasonSchema: z.ZodEnum<{
+    error: "error";
+    timeout: "timeout";
+    structuredOutputFailure: "structuredOutputFailure";
+}>;
+export declare const FallbackStrategyConfigSchema: z.ZodLazy<z.ZodRecord<z.ZodEnum<{
+    error: "error";
+    timeout: "timeout";
+    structuredOutputFailure: "structuredOutputFailure";
+}> & 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 | ModelNameAndProvider | IDStrategyJSON | RaceStrategyJSON | FallbackStrategyJSON;
+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: {
-        strategies: StrategyJSON[];
+        primaryStrategy: StrategyJSON;
         config: FallbackStrategyConfig;
     };
 };
-export {};
+export type ModelNameAndProvider = {
+    model: string;
+    provider: string;
+};
+export declare const ModelNameAndProviderSchema: z.ZodObject<{
+    model: z.ZodString;
+    provider: z.ZodString;
+}, z.core.$strip>;
+export declare const ModelNameSchema: z.ZodString;
+export declare const OptimizationSchema: z.ZodEnum<{
+    reasoning: "reasoning";
+    speed: "speed";
+    cost: "cost";
+    "large-context": "large-context";
+}>;
+export type Optimization = z.infer<typeof OptimizationSchema>;
+export declare const ModelConfigSchema: z.ZodObject<{
+    optimizeFor: z.ZodArray<z.ZodEnum<{
+        reasoning: "reasoning";
+        speed: "speed";
+        cost: "cost";
+        "large-context": "large-context";
+    }>>;
+    providers: z.ZodArray<z.ZodEnum<{
+        local: "local";
+        ollama: "ollama";
+        openai: "openai";
+        "openai-responses": "openai-responses";
+        anthropic: "anthropic";
+        google: "google";
+        replicate: "replicate";
+        modal: "modal";
+    }>>;
+    limit: z.ZodOptional<z.ZodObject<{
+        cost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+export declare const StrategyJSONSchema: z.ZodType<StrategyJSON>;
+export declare function isStrategy(value: unknown): value is StrategyJSON;

package/dist/strategies/types.js

@@ -1 +1,57 @@
-export {};
+import { z } from "zod";
+import { ProviderSchema } from "../models.js";
+export const FallbackReasonSchema = z.enum([
+    "error",
+    "timeout",
+    "structuredOutputFailure",
+]);
+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 ModelNameAndProviderSchema = z.object({
+    model: z.string(),
+    provider: z.string(),
+});
+export const ModelNameSchema = z
+    .string()
+    .regex(/^[a-zA-Z0-9._:-]+$/, "Model name must only contain letters, numbers, dots, underscores, hyphens, and colons");
+export const OptimizationSchema = z.enum([
+    "speed",
+    "reasoning",
+    "cost",
+    "large-context",
+]);
+export const ModelConfigSchema = z.object({
+    optimizeFor: z.array(OptimizationSchema),
+    providers: z.array(ProviderSchema),
+    limit: z
+        .object({
+        cost: z.number().optional(),
+    })
+        .optional(),
+});
+export const StrategyJSONSchema = z.lazy(() => z.union([
+    ModelNameSchema,
+    ModelNameAndProviderSchema,
+    IDStrategyJSONSchema,
+    RaceStrategyJSONSchema,
+    FallbackStrategyJSONSchema,
+]));
+// 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;
+}