smoltalk 0.0.67 → 0.2.1

package/dist/clients/openai.d.ts

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
-import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
+import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
-export type SmolOpenAiConfig = BaseClientConfig;
+export type SmolOpenAiConfig = SmolConfig;
 export declare class SmolOpenAi extends BaseClient implements SmolClient {
     private client;
     private logger;
@@ -13,6 +13,6 @@ export declare class SmolOpenAi extends BaseClient implements SmolClient {
     private calculateUsageAndCost;
     private buildRequest;
     private rethrowAsSmolError;
-    _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
-    _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
+    _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }

package/dist/clients/openai.js

@@ -24,7 +24,7 @@ export class SmolOpenAi extends BaseClient {
         return this.client;
     }
     getModel() {
-        return this.model.getResolvedModel();
+        return this.model.getModel();
     }
     calculateUsageAndCost(usageData) {
         let usage;
@@ -64,6 +64,7 @@ export class SmolOpenAi extends BaseClient {
                 json_schema: {
                     name: config.responseFormatOptions?.name || "response",
                     schema: config.responseFormat.toJSONSchema(),
+                    strict: !!config.responseFormatOptions?.strict,
                 },
             };
         }

package/dist/clients/openaiResponses.d.ts

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
-import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
+import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
-export type SmolOpenAiResponsesConfig = BaseClientConfig;
+export type SmolOpenAiResponsesConfig = SmolConfig;
 export declare class SmolOpenAiResponses extends BaseClient implements SmolClient {
     private client;
     private logger;
@@ -14,6 +14,6 @@ export declare class SmolOpenAiResponses extends BaseClient implements SmolClien
     private buildRequest;
     private calculateUsageAndCost;
     private rethrowAsSmolError;
-    _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
-    _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
+    _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }

package/dist/clients/openaiResponses.js

@@ -24,7 +24,7 @@ export class SmolOpenAiResponses extends BaseClient {
         return this.client;
     }
     getModel() {
-        return this.model.getResolvedModel();
+        return this.model.getModel();
     }
     convertMessages(config) {
         const systemParts = [];
@@ -76,6 +76,7 @@ export class SmolOpenAiResponses extends BaseClient {
                     type: "json_schema",
                     name: config.responseFormatOptions?.name || "response",
                     schema: config.responseFormat.toJSONSchema(),
+                    strict: !!config.responseFormatOptions?.strict,
                 },
             };
         }

package/dist/functions.d.ts

@@ -1,15 +1,18 @@
-import { getClient } from "./client.js";
-import { PromptConfig, PromptResult, SmolPromptConfig, StreamChunk } from "./types.js";
+import { PromptResult, SmolConfig, StreamChunk } from "./types.js";
 import { Result } from "./types/result.js";
-export declare function splitConfig(config: SmolPromptConfig): {
-    smolConfig: Parameters<typeof getClient>[0];
-    promptConfig: PromptConfig;
-};
-export declare function text(config: SmolPromptConfig & {
+import type { z, ZodType } from "zod";
+export declare function text(config: SmolConfig & {
     stream: true;
 }): AsyncGenerator<StreamChunk>;
-export declare function text(config: SmolPromptConfig & {
+export declare function text<S extends ZodType>(config: Omit<SmolConfig, "responseFormat"> & {
+    responseFormat: S;
+    stream?: false;
+}): Promise<Result<PromptResult<z.infer<S>>>>;
+export declare function text(config: SmolConfig & {
     stream?: false;
 }): Promise<Result<PromptResult>>;
-export declare function textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
-export declare function textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
+export declare function textSync<S extends ZodType>(config: Omit<SmolConfig, "responseFormat"> & {
+    responseFormat: S;
+}): Promise<Result<PromptResult<z.infer<S>>>>;
+export declare function textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+export declare function textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;

package/dist/functions.js

@@ -1,42 +1,6 @@
 import { BaseMessage, messageFromJSON, } from "./classes/message/index.js";
-import { executeMiddlewareSync, executeMiddlewareStream } from "./middleware.js";
-import { Model } from "./model.js";
-import { BaseStrategy } from "./strategies/baseStrategy.js";
-import { fromJSON } from "./strategies/index.js";
+import { getClient } from "./client.js";
 import { getLogger } from "./util/logger.js";
-function getStrategy(model) {
-    if (model instanceof BaseStrategy)
-        return model;
-    return fromJSON(model);
-}
-/** Always creates a fresh strategy instance (safe for concurrent use). */
-function getFreshStrategy(model) {
-    if (model instanceof BaseStrategy)
-        return fromJSON(model.toJSON());
-    return fromJSON(model);
-}
-export function splitConfig(config) {
-    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, statelog, metadata, hooks, llamaCppModelDir, middleware, ...promptConfig } = config;
-    const _model = new Model(rawModel);
-    const model = _model.getResolvedModel();
-    return {
-        smolConfig: {
-            openAiApiKey,
-            googleApiKey,
-            ollamaApiKey,
-            anthropicApiKey,
-            ollamaHost,
-            model,
-            provider,
-            logLevel,
-            statelog,
-            metadata,
-            hooks,
-            llamaCppModelDir,
-        },
-        promptConfig,
-    };
-}
 function fixMessagesIfNecessary(messages) {
     if (messages && messages.length > 0) {
         if (!(messages[0] instanceof BaseMessage)) {
@@ -47,30 +11,15 @@ function fixMessagesIfNecessary(messages) {
     return messages;
 }
 export function text(config) {
-    if (config.stream) {
+    if (config.stream)
         return textStream(config);
-    }
     return textSync(config);
 }
 export async function textSync(config) {
     config.messages = fixMessagesIfNecessary(config.messages);
-    if (config.middleware && config.middleware.checks.length > 0) {
-        const runMain = (cfg) => { const s = getFreshStrategy(cfg.model); return s.textSync(cfg); };
-        const middlewareResult = await executeMiddlewareSync(config, runMain, runMain);
-        if (middlewareResult)
-            return middlewareResult;
-    }
-    const strategy = getStrategy(config.model);
-    const { middleware: _, ...configWithoutMiddleware } = config;
-    return strategy.textSync(configWithoutMiddleware);
+    return getClient(config).textSync(config);
 }
 export async function* textStream(config) {
     config.messages = fixMessagesIfNecessary(config.messages);
-    if (config.middleware && config.middleware.checks.length > 0) {
-        yield* executeMiddlewareStream(config, (cfg) => { const s = getFreshStrategy(cfg.model); return s.textStream(cfg); }, (cfg) => { const s = getFreshStrategy(cfg.model); return s.textSync(cfg); });
-        return;
-    }
-    const strategy = getStrategy(config.model);
-    const { middleware: _, ...configWithoutMiddleware } = config;
-    yield* strategy.textStream(configWithoutMiddleware);
+    yield* getClient(config).textStream(config);
 }

package/dist/index.d.ts

@@ -7,7 +7,5 @@ export * from "./util/util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
 export * from "./classes/ToolCall.js";
-export * from "./strategies/index.js";
-export { latencyTracker } from "./latencyTracker.js";
-export type { LatencySample } from "./latencyTracker.js";
-export type { MiddlewareCheck, MiddlewareConfig, MiddlewareResult } from "./middleware.js";
+export { getLogger, EgonLog } from "./util/logger.js";
+export type { LogLevel } from "./util/logger.js";

package/dist/index.js

@@ -7,5 +7,4 @@ export * from "./util/util.js";
 export * from "./classes/message/index.js";
 export * from "./functions.js";
 export * from "./classes/ToolCall.js";
-export * from "./strategies/index.js";
-export { latencyTracker } from "./latencyTracker.js";
+export { getLogger, EgonLog } from "./util/logger.js";

package/dist/model.d.ts

@@ -2,14 +2,11 @@ import { ModelName, Provider } from "./models.js";
 import { ModelLike } from "./types.js";
 export declare class Model {
     private model;
-    private resolvedModel;
     private provider?;
     constructor(model: ModelName, provider?: Provider);
-    getModel(): string;
-    getResolvedModel(): string;
+    getModel(): ModelName;
     getProvider(): Provider | undefined;
-    setProvider(): Provider | undefined;
-    resolveModel(): ModelName;
+    private lookupProvider;
     calculateCost(usage: {
         inputTokens: number;
         outputTokens: number;

package/dist/model.js

@@ -1,44 +1,28 @@
-import { getModel, isTextModel } from "./models.js";
+import { getModel, isTextModel, ModelNameSchema } from "./models.js";
 import { SmolError } from "./smolError.js";
-import { ModelNameSchema } from "./strategies/types.js";
 import { round } from "./util/util.js";
 export class Model {
     model;
-    resolvedModel;
     provider;
     constructor(model, provider) {
+        if (!ModelNameSchema.safeParse(model).success) {
+            throw new SmolError(`Model ${JSON.stringify(model)} is not recognized. Please specify a known model name.`);
+        }
         this.model = model;
-        this.resolvedModel = this.resolveModel();
-        this.provider = provider || this.setProvider();
+        this.provider = provider || this.lookupProvider();
     }
     getModel() {
         return this.model;
     }
-    getResolvedModel() {
-        return this.resolvedModel;
-    }
     getProvider() {
-        if (this.provider) {
-            return this.provider;
-        }
-        return undefined;
+        return this.provider;
     }
-    setProvider() {
-        const resolved = this.getResolvedModel();
-        const modelInfo = getModel(resolved);
-        if (modelInfo) {
-            return modelInfo.provider;
-        }
-        return undefined;
-    }
-    resolveModel() {
-        if (ModelNameSchema.safeParse(this.model).success) {
-            return this.model;
-        }
-        throw new SmolError(`Model ${JSON.stringify(this.model)} is not recognized. Please specify a known model name.`);
+    lookupProvider() {
+        const modelInfo = getModel(this.model);
+        return modelInfo ? modelInfo.provider : undefined;
     }
     calculateCost(usage) {
-        const model = getModel(this.getResolvedModel());
+        const model = getModel(this.model);
         if (!model || !isTextModel(model)) {
             return null;
         }
@@ -60,7 +44,7 @@ export class Model {
         return `Model(${JSON.stringify(this.model)})`;
     }
     toJSON() {
-        return this.getResolvedModel();
+        return this.model;
     }
     static create(model, provider) {
         if (model instanceof Model) {

package/dist/models.d.ts

@@ -1,8 +1,7 @@
 import { z } from "zod";
-export declare const providers: readonly ["ollama", "llama-cpp", "openai", "openai-responses", "anthropic", "google", "replicate", "modal"];
+export declare const providers: readonly ["ollama", "openai", "openai-responses", "anthropic", "google", "replicate", "modal"];
 export declare const ProviderSchema: z.ZodEnum<{
     ollama: "ollama";
-    "llama-cpp": "llama-cpp";
     openai: "openai";
     "openai-responses": "openai-responses";
     anthropic: "anthropic";
@@ -1226,3 +1225,4 @@ export declare function isImageModel(model: ModelType): model is ImageModel;
 export declare function isTextModel(model: ModelType): model is TextModel;
 export declare function isSpeechToTextModel(model: ModelType): model is SpeechToTextModel;
 export declare function isEmbeddingsModel(model: ModelType): model is EmbeddingsModel;
+export declare const ModelNameSchema: z.ZodString;

package/dist/models.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 export const providers = [
     "ollama",
-    "llama-cpp",
     "openai",
     "openai-responses",
     "anthropic",
@@ -673,3 +672,6 @@ export function isSpeechToTextModel(model) {
 export function isEmbeddingsModel(model) {
     return model.type === "embeddings";
 }
+export const ModelNameSchema = z
+    .string()
+    .regex(/^[a-zA-Z0-9._:-]+$/, "Model name must only contain letters, numbers, dots, underscores, hyphens, and colons");

package/dist/testing/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseClient } from "../clients/baseClient.js";
+import type { PromptResult, Result, SmolConfig, StreamChunk } from "../types.js";
+export declare class TestProvider extends BaseClient {
+    private callIndex;
+    private nextResponse;
+    private cannedUsage;
+    _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+    _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
+}

package/dist/testing/index.js

@@ -0,0 +1,41 @@
+import { BaseClient } from "../clients/baseClient.js";
+import { promptResult, success } from "../types.js";
+const DEFAULT_RESPONSE = "test response";
+export class TestProvider extends BaseClient {
+    callIndex = 0;
+    nextResponse(config) {
+        const responses = config.metadata?.testResponses;
+        if (Array.isArray(responses) && responses.length > 0) {
+            const response = responses[this.callIndex % responses.length];
+            this.callIndex += 1;
+            return response;
+        }
+        const single = config.metadata?.testResponse;
+        return single ?? DEFAULT_RESPONSE;
+    }
+    cannedUsage(config) {
+        return config.metadata?.testUsage;
+    }
+    async _textSync(config) {
+        const output = this.nextResponse(config);
+        return success(promptResult({
+            output,
+            toolCalls: [],
+            model: config.model,
+            usage: this.cannedUsage(config),
+        }));
+    }
+    async *_textStream(config) {
+        const output = this.nextResponse(config);
+        yield { type: "text", text: output };
+        yield {
+            type: "done",
+            result: promptResult({
+                output,
+                toolCalls: [],
+                model: config.model,
+                usage: this.cannedUsage(config),
+            }),
+        };
+    }
+}

package/dist/types.d.ts

@@ -1,21 +1,52 @@
 export * from "./types/result.js";
-import { LogLevel } from "egonlog";
-import type { MiddlewareConfig } from "./middleware.js";
+import { LogLevel } from "./util/logger.js";
 import z, { ZodType } from "zod";
 import { Message } from "./classes/message/index.js";
 import { ToolCall } from "./classes/ToolCall.js";
 import { Model } from "./model.js";
 import { ModelName } from "./models.js";
-import { Strategy, StrategyJSON } from "./strategies/types.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
 export * from "./types/costEstimate.js";
 export * from "./types/tokenUsage.js";
-export type PromptConfig = {
+export type SmolConfig = {
+    /** The model to use. */
+    model: ModelName;
+    /** Override the provider for the given model (e.g., use a custom endpoint for an OpenAI-compatible model). */
+    provider?: string;
+    /** API key for OpenAI. Required when using OpenAI models. */
+    openAiApiKey?: string;
+    /** API key for Google Gemini. Required when using Google models. */
+    googleApiKey?: string;
+    /** API key for Anthropic. Required when using Anthropic/Claude models. */
+    anthropicApiKey?: string;
+    /** API key for Ollama. Only needed when connecting to a cloud-hosted Ollama instance. */
+    ollamaApiKey?: string;
+    /** Base URL for the Ollama server. Defaults to localhost if not set. (Ollama only) */
+    ollamaHost?: string;
+    /** Log level for internal debug logging. */
+    logLevel?: LogLevel;
+    /** Configuration for Statelog observability/tracing integration. */
+    statelog?: Partial<{
+        host: string;
+        projectId: string;
+        traceId: string;
+        debugMode: boolean;
+        apiKey: string;
+    }>;
+    /** Lifecycle hooks called at various points during execution. */
+    hooks?: Partial<{
+        onStart: (config: SmolConfig) => void;
+        onToolCall: (toolCall: ToolCall) => void;
+        onEnd: (result: PromptResult) => void;
+        onError: (error: Error) => void;
+    }>;
+    /** Arbitrary metadata passed to custom model providers. */
+    metadata?: Record<string, any>;
     /** The conversation messages to send to the model. */
     messages: Message[];
-    /** Tools (functions) the model can call. Each tool has a name, optional description, and a Zod schema defining its parameters. */
+    /** Tools (functions) the model can call. */
     tools?: {
         name: string;
         description?: string;
@@ -23,9 +54,9 @@ export type PromptConfig = {
     }[];
     /** Maximum number of tokens the model can generate in its response. */
     maxTokens?: number;
-    /** Sampling temperature (0-2). Higher values make output more random, lower values more deterministic. (OpenAI only) */
+    /** Sampling temperature (0-2). (OpenAI only) */
     temperature?: number;
-    /** Number of alternative completions to generate. Not currently used by any provider. */
+    /** Number of alternative completions to generate. */
     numSuggestions?: number;
     /** Whether the model can call multiple tools in a single turn. (OpenAI Responses API only) */
     parallelToolCalls?: boolean;
@@ -33,40 +64,17 @@ export type PromptConfig = {
     responseFormat?: ZodType;
     /** If true, returns an AsyncGenerator of StreamChunks instead of a single result. */
     stream?: boolean;
-    /**
-     * Enable extended thinking / thought signatures.
-     * When enabled, the model returns its reasoning process alongside the response.
-     * (Anthropic and Google only — OpenAI reasoning tokens are not exposed)
-     */
+    /** Enable extended thinking / thought signatures. (Anthropic and Google only) */
     thinking?: {
-        /** Whether to enable extended thinking. */
         enabled: boolean;
-        /** Token budget for the thinking process. Defaults to 5000. (Anthropic only) */
         budgetTokens?: number;
     };
-    /**
-     * Provider-agnostic reasoning effort level.
-     * - OpenAI: passed as reasoning_effort / reasoning.effort
-     * - Anthropic: mapped to thinking budget (low=2048, medium=5000, high=10000)
-     * - Google: mapped to thinkingBudget (low=2048, medium=8192, high=16384)
-     * If `thinking` is also set, it takes precedence for Anthropic/Google.
-     */
+    /** Provider-agnostic reasoning effort level. */
     reasoningEffort?: "low" | "medium" | "high";
     responseFormatOptions?: Partial<{
-        /**
-         * Identifier for the JSON schema sent to OpenAI's structured output API
-         * (e.g. "math_response"). Defaults to "response".
-         * OpenAI's json_schema response format *requires* a name field. The name helps
-         * OpenAI identify and cache the schema. Smoltalk defaults it to "response"
-         * so users don't have to think about it, but the option is there if someone
-         * wants to set a more descriptive name (OpenAI recommends it for clarity in their docs).
-         */
         name: string;
-        /** Whether to enforce strict schema adherence. */
         strict: boolean;
-        /** Number of retries if validation fails. Defaults to 2 when strict is true. */
         numRetries: number;
-        /** If true, strip extra keys from the response instead of failing validation. */
         allowExtraKeys: boolean;
     }>;
     /** Arbitrary provider-specific attributes passed directly to the underlying API call. */
@@ -78,139 +86,21 @@ export type PromptConfig = {
     /** Define behavior if too many repeated tool calls are detected (loop prevention). */
     toolLoopDetection?: ToolLoopDetection;
 };
-export type SmolConfig = {
-    /** API key for OpenAI. Required when using OpenAI models. */
-    openAiApiKey?: string;
-    /** API key for Google Gemini. Required when using Google models. */
-    googleApiKey?: string;
-    /** API key for Anthropic. Required when using Anthropic/Claude models. */
-    anthropicApiKey?: string;
-    /** API key for Ollama. Only needed when connecting to a cloud-hosted Ollama instance. */
-    ollamaApiKey?: string;
-    /** Base URL for the Ollama server. Defaults to localhost if not set. (Ollama only) */
-    ollamaHost?: string;
-    /** Directory path for Llama.cpp models. Required when using the Llama.cpp client. */
-    llamaCppModelDir?: string;
-    /**
-    The given model determines both
-    - what client is used
-    - what strategy is executed.
-  
-    ## 1. Specifying a model directly
-    The simplest case is to specify the name of a model from lib/models.ts.
-    Example:
-  
-    ```
-      model: "claude-sonnet-4-6"
-    ```
-  
-    ## 2. Specifying a strategy
-    You can instead specify a strategy to execute. For example:
-  
-    ```
-      model: {
-        type: "race",
-        params: {
-          strategies: ["gemini-2.5-flash-lite", "gemini-2.5-pro"],
-        },
-      }
-    ```
-  
-    In this case, Smoltalk will run your request over using both LLMs simultaneously,
-    and take the response that finishes first.
-  
-    You can also choose to specify fallbacks in case the first model
-    returns an error for some reason. This can be a good way to try something
-    with a fast model and then use a slower but more powerful model if the first one fails.
-  
-    ```
-      model: {
-        type: "fallback",
-        params: {
-          primaryStrategy: "gemini-2.5-flash-lite",
-          config: {
-            error: ["gemini-2.5-pro"],
-          },
-        },
-      }
-    ```
-  
-    You can of course combine strategies together to create more complex behavior:
-  
-    ```
-      const geminiLiteWithFallback = {
-        type: "fallback",
-        params: {
-          primaryStrategy: "gemini-2.5-flash-lite",
-          config: {
-            error: ["gemini-2.5-pro"],
-          },
-        },
-      };
-  
-      model: {
-        type: "race",
-        params: {
-          strategies: ["gemini-2.5-pro", geminiLiteWithFallback],
-        },
-      }
-    ```
-      */
-    model: ModelParam;
-    /** Override the provider for the given model (e.g., use a custom endpoint for an OpenAI-compatible model). */
-    provider?: string;
-    /** Log level for internal debug logging. */
-    logLevel?: LogLevel;
-    /** Configuration for Statelog observability/tracing integration. */
-    statelog?: Partial<{
-        /** Statelog server host URL. */
-        host: string;
-        /** Project identifier for grouping traces. */
-        projectId: string;
-        /** Trace identifier for correlating related requests. */
-        traceId: string;
-        /** Enable debug mode for verbose Statelog output. */
-        debugMode: boolean;
-        /** API key for authenticating with the Statelog server. */
-        apiKey: string;
-    }>;
-    /** Lifecycle hooks called at various points during execution. */
-    hooks?: Partial<{
-        /** Called when the prompt execution starts. */
-        onStart: (config: PromptConfig) => void;
-        /** Called each time the model invokes a tool. */
-        onToolCall: (toolCall: ToolCall) => void;
-        /** Called when the prompt execution completes successfully. */
-        onEnd: (result: PromptResult) => void;
-        /** Called when an error occurs during execution. */
-        onError: (error: Error) => void;
-        /** Called when a strategy begins execution. */
-        onStrategyStart: (strategy: Strategy, config: SmolPromptConfig) => void;
-    }>;
-    /** Arbitrary metadata passed to custom model providers. */
-    metadata?: Record<string, any>;
-    /** Middleware checks that run LLM-based validation on the prompt before or alongside the main call. */
-    middleware?: MiddlewareConfig;
-};
 export type ToolLoopDetection = {
     enabled: boolean;
     maxCalls: number;
     intervention?: "remove-tool" | "remove-all-tools" | "throw-error" | "halt-execution";
     excludeTools?: string[];
 };
-export type ResolvedSmolConfig = Omit<SmolConfig, "model"> & {
-    model: ModelName;
-};
-export type BaseClientConfig = ResolvedSmolConfig;
-export type PromptResult = {
-    output: string | null;
+export type PromptResult<T = string> = {
+    output: T | null;
     toolCalls: ToolCall[];
     thinkingBlocks?: ThinkingBlock[];
     usage?: TokenUsage;
     cost?: CostEstimate;
     model?: ModelName;
 };
-export declare function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, }: Partial<PromptResult>): PromptResult;
+export declare function promptResult<T = string>({ output, toolCalls, thinkingBlocks, usage, cost, model, }: Partial<PromptResult<T>>): PromptResult<T>;
 export type StreamChunk = {
     type: "text";
     text: string;
@@ -232,19 +122,21 @@ export type StreamChunk = {
     error: string;
 };
 export interface SmolClient {
-    text(promptConfig: PromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
-    textSync(config: PromptConfig): Promise<Result<PromptResult>>;
-    _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
-    textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
-    _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
+    text(config: SmolConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
+    textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+    _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
+    textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
+    _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }
-export type SmolPromptConfig = PromptConfig & SmolConfig;
 export type TextPart = {
     type: "text";
     text: string;
 };
+/** Loose variant of SmolConfig for `getClient()` — messages are not required at construction time. */
+export type SmolClientConfig = Omit<SmolConfig, "messages"> & {
+    messages?: Message[];
+};
 export type ModelLike = ModelName | Model;
-export type ModelParam = ModelName | Strategy | StrategyJSON;
 export type ThinkingBlock = {
     text: string;
     signature: string;

package/dist/types.js

@@ -4,7 +4,7 @@ export * from "./types/costEstimate.js";
 export * from "./types/tokenUsage.js";
 export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, }) {
     return {
-        output: output || null,
+        output: (output ?? null),
         toolCalls: toolCalls || [],
         thinkingBlocks: thinkingBlocks,
         usage,