smoltalk 0.0.37 → 0.0.39

package/dist/classes/message/AssistantMessage.d.ts

@@ -1,5 +1,5 @@
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
-import { TextPart, ThinkingBlock } from "../../types.js";
+import { CostEstimate, TextPart, ThinkingBlock, TokenUsage } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { ToolCall, ToolCallJSON } from "../ToolCall.js";
@@ -13,6 +13,8 @@ export type AssistantMessageJSON = {
     refusal: string | null | undefined;
     toolCalls: ToolCallJSON[] | undefined;
     thinkingBlocks: ThinkingBlock[] | undefined;
+    usage: TokenUsage | undefined;
+    cost: CostEstimate | undefined;
 };
 export declare class AssistantMessage extends BaseMessage implements MessageClass {
     _role: "assistant";
@@ -23,6 +25,8 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     _toolCalls?: ToolCall[];
     _thinkingBlocks?: ThinkingBlock[];
     _rawData?: any;
+    _usage?: TokenUsage;
+    _cost?: CostEstimate;
     constructor(content: string | Array<TextPart> | null, options?: {
         name?: string;
         audio?: any | null;
@@ -30,6 +34,8 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
         toolCalls?: ToolCall[];
         thinkingBlocks?: ThinkingBlock[];
         rawData?: any;
+        usage?: TokenUsage;
+        cost?: CostEstimate;
     });
     get content(): string;
     set content(value: string);
@@ -40,6 +46,8 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     get toolCalls(): ToolCall[] | undefined;
     get rawData(): any;
     get thinkingBlocks(): ThinkingBlock[] | undefined;
+    get usage(): TokenUsage | undefined;
+    get cost(): CostEstimate | undefined;
     toJSON(): AssistantMessageJSON;
     static fromJSON(json: any): AssistantMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;

package/dist/classes/message/AssistantMessage.js

@@ -9,6 +9,8 @@ export class AssistantMessage extends BaseMessage {
     _toolCalls;
     _thinkingBlocks;
     _rawData;
+    _usage;
+    _cost;
     constructor(content, options = {}) {
         super();
         this._content = content;
@@ -18,6 +20,8 @@ export class AssistantMessage extends BaseMessage {
         this._toolCalls = options.toolCalls;
         this._thinkingBlocks = options.thinkingBlocks;
         this._rawData = options.rawData;
+        this._usage = options.usage;
+        this._cost = options.cost;
     }
     get content() {
         if (this._content === null || this._content === undefined) {
@@ -51,6 +55,12 @@ export class AssistantMessage extends BaseMessage {
     get thinkingBlocks() {
         return this._thinkingBlocks;
     }
+    get usage() {
+        return this._usage;
+    }
+    get cost() {
+        return this._cost;
+    }
     toJSON() {
         return {
             role: this.role,
@@ -60,6 +70,8 @@ export class AssistantMessage extends BaseMessage {
             refusal: this.refusal,
             toolCalls: this.toolCalls?.map((tc) => tc.toJSON()),
             thinkingBlocks: this._thinkingBlocks,
+            usage: this._usage,
+            cost: this._cost,
         };
     }
     static fromJSON(json) {
@@ -72,6 +84,8 @@ export class AssistantMessage extends BaseMessage {
                 : undefined,
             thinkingBlocks: json.thinkingBlocks,
             rawData: json.rawData,
+            usage: json.usage,
+            cost: json.cost,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/index.d.ts

@@ -8,7 +8,7 @@ import type { AssistantMessageJSON } from "./AssistantMessage.js";
 import type { DeveloperMessageJSON } from "./DeveloperMessage.js";
 import type { SystemMessageJSON } from "./SystemMessage.js";
 import type { ToolMessageJSON } from "./ToolMessage.js";
-import { TextPart } from "../../types.js";
+import { CostEstimate, TextPart, TokenUsage } from "../../types.js";
 export * from "./AssistantMessage.js";
 export * from "./BaseMessage.js";
 export * from "./DeveloperMessage.js";
@@ -30,6 +30,8 @@ export declare function assistantMessage(content: string | Array<TextPart> | nul
         signature: string;
     }>;
     rawData?: any;
+    usage?: TokenUsage;
+    cost?: CostEstimate;
 }): AssistantMessage;
 export declare function developerMessage(content: string | Array<TextPart>, options?: {
     name?: string;

package/dist/client.js

@@ -6,17 +6,16 @@ import { SmolAnthropic } from "./clients/anthropic.js";
 import { SmolGoogle } from "./clients/google.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
-import { getModel, isModelConfig, isTextModel, pickModel, } from "./models.js";
+import { getModel, isTextModel } from "./models.js";
 import { SmolError } from "./smolError.js";
 import { getLogger } from "./logger.js";
 import { SmolOllama } from "./clients/ollama.js";
+import { Model } from "./model.js";
 export function getClient(config) {
     // Initialize logger singleton with desired log level
     const logger = getLogger(config.logLevel);
     // Resolve ModelConfig to a concrete model name
-    const modelName = isModelConfig(config.model)
-        ? pickModel(config.model)
-        : config.model;
+    const modelName = new Model(config.model).getResolvedModel();
     let provider = config.provider;
     if (!provider) {
         const model = getModel(modelName);

package/dist/clients/anthropic.d.ts

@@ -1,5 +1,6 @@
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ModelName } from "../models.js";
 export type SmolAnthropicConfig = BaseClientConfig & {
     anthropicApiKey: string;
 };
@@ -8,7 +9,7 @@ export declare class SmolAnthropic extends BaseClient implements SmolClient {
     private logger;
     private model;
     constructor(config: SmolAnthropicConfig);
-    getModel(): string;
+    getModel(): ModelName;
     private calculateUsageAndCost;
     private buildRequest;
     _textSync(config: PromptConfig): Promise<Result<PromptResult>>;

package/dist/clients/anthropic.js

@@ -1,11 +1,11 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { ToolCall } from "../classes/ToolCall.js";
-import { SystemMessage, DeveloperMessage, } from "../classes/message/index.js";
+import { SystemMessage, DeveloperMessage } from "../classes/message/index.js";
 import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
 import { zodToAnthropicTool } from "../util/tool.js";
 import { BaseClient } from "./baseClient.js";
-import { calculateCost } from "../models.js";
+import { Model } from "../model.js";
 const DEFAULT_MAX_TOKENS = 4096;
 export class SmolAnthropic extends BaseClient {
     client;
@@ -15,10 +15,10 @@ export class SmolAnthropic extends BaseClient {
         super(config);
         this.client = new Anthropic({ apiKey: config.anthropicApiKey });
         this.logger = getLogger();
-        this.model = config.model;
+        this.model = new Model(config.model);
     }
     getModel() {
-        return this.model;
+        return this.model.getResolvedModel();
     }
     calculateUsageAndCost(usageData) {
         const usage = {
@@ -26,7 +26,7 @@ export class SmolAnthropic extends BaseClient {
             outputTokens: usageData.output_tokens,
             totalTokens: usageData.input_tokens + usageData.output_tokens,
         };
-        const cost = calculateCost(this.model, usage) ?? undefined;
+        const cost = this.model.calculateCost(usage) ?? undefined;
         return { usage, cost };
     }
     buildRequest(config) {
@@ -64,23 +64,37 @@ export class SmolAnthropic extends BaseClient {
                 description: tool.description,
             }))
             : undefined;
+        const reasoningBudgetMap = {
+            low: 2048,
+            medium: 5000,
+            high: 10000,
+        };
         const thinking = config.thinking?.enabled
-            ? { type: "enabled", budget_tokens: config.thinking.budgetTokens ?? 5000 }
-            : undefined;
+            ? {
+                type: "enabled",
+                budget_tokens: config.thinking.budgetTokens ?? 5000,
+            }
+            : config.reasoningEffort
+                ? {
+                    type: "enabled",
+                    budget_tokens: reasoningBudgetMap[config.reasoningEffort],
+                }
+                : undefined;
         return { system, messages: anthropicMessages, tools, thinking };
     }
     async _textSync(config) {
         const { system, messages, tools, thinking } = this.buildRequest(config);
         this.logger.debug("Sending request to Anthropic:", {
-            model: this.model,
+            model: this.getModel(),
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
             messages,
             system,
             tools,
             thinking,
         });
+        const signal = this.getAbortSignal(config);
         const response = await this.client.messages.create({
-            model: this.model,
+            model: this.getModel(),
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
             messages,
             ...(system && { system }),
@@ -91,7 +105,7 @@ export class SmolAnthropic extends BaseClient {
             }),
             ...(config.rawAttributes || {}),
             stream: false,
-        });
+        }, { ...(signal && { signal }) });
         this.logger.debug("Response from Anthropic:", response);
         let output = null;
         const toolCalls = [];
@@ -115,7 +129,7 @@ export class SmolAnthropic extends BaseClient {
             ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
             usage,
             cost,
-            model: this.model,
+            model: this.getModel(),
         });
     }
     async *_textStream(config) {
@@ -128,6 +142,7 @@ export class SmolAnthropic extends BaseClient {
             tools,
             thinking,
         });
+        const signal = this.getAbortSignal(config);
         const stream = await this.client.messages.create({
             model: this.model,
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
@@ -140,7 +155,7 @@ export class SmolAnthropic extends BaseClient {
             }),
             ...(config.rawAttributes || {}),
             stream: true,
-        });
+        }, { ...(signal && { signal }) });
         let content = "";
         // Track tool blocks by index: index -> { id, name, arguments (partial JSON) }
         const toolBlocks = new Map();
@@ -192,7 +207,11 @@ export class SmolAnthropic extends BaseClient {
                 // Emit thinking chunk once the block is fully assembled
                 const thinkingBlock = thinkingBlockMap.get(event.index);
                 if (thinkingBlock) {
-                    yield { type: "thinking", text: thinkingBlock.text, signature: thinkingBlock.signature };
+                    yield {
+                        type: "thinking",
+                        text: thinkingBlock.text,
+                        signature: thinkingBlock.signature,
+                    };
                 }
             }
             else if (event.type === "message_delta") {
@@ -212,7 +231,7 @@ export class SmolAnthropic extends BaseClient {
             outputTokens,
             totalTokens: inputTokens + outputTokens,
         };
-        const cost = calculateCost(this.model, usage) ?? undefined;
+        const cost = this.model.calculateCost(usage) ?? undefined;
         yield {
             type: "done",
             result: {
@@ -221,7 +240,7 @@ export class SmolAnthropic extends BaseClient {
                 ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
                 usage,
                 cost,
-                model: this.model,
+                model: this.getModel(),
             },
         };
     }

package/dist/clients/baseClient.d.ts

@@ -4,6 +4,8 @@ export declare class BaseClient implements SmolClient {
     protected config: SmolConfig;
     protected statelogClient?: StatelogClient;
     constructor(config: SmolConfig);
+    protected getAbortSignal(promptConfig: PromptConfig): AbortSignal | undefined;
+    protected isAbortError(err: unknown): boolean;
     text(promptConfig: Omit<PromptConfig, "stream">): Promise<Result<PromptResult>>;
     text(promptConfig: Omit<PromptConfig, "stream"> & {
         stream: false;
@@ -13,6 +15,10 @@ export declare class BaseClient implements SmolClient {
     }): AsyncGenerator<StreamChunk>;
     text(promptConfig: PromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
     checkMessageLimit(promptConfig: PromptConfig): Result<PromptResult> | null;
+    applyBudget(promptConfig: PromptConfig): {
+        config: PromptConfig;
+        failure?: Result<PromptResult>;
+    };
     textSync(promptConfig: PromptConfig): Promise<Result<PromptResult>>;
     checkForToolLoops(promptConfig: PromptConfig): {
         continue: boolean;

package/dist/clients/baseClient.js

@@ -1,5 +1,7 @@
-import { userMessage, assistantMessage } from "../classes/message/index.js";
+import { AssistantMessage, userMessage, assistantMessage, } from "../classes/message/index.js";
 import { getLogger } from "../logger.js";
+import { getModel, isTextModel } from "../models.js";
+import { SmolStructuredOutputError } from "../smolError.js";
 import { getStatelogClient } from "../statelogClient.js";
 import { success, } from "../types.js";
 import { z } from "zod";
@@ -13,6 +15,27 @@ export class BaseClient {
             this.statelogClient = getStatelogClient(this.config.statelog);
         }
     }
+    getAbortSignal(promptConfig) {
+        const signals = [];
+        if (promptConfig.abortSignal) {
+            signals.push(promptConfig.abortSignal);
+        }
+        const timeBudgetMs = promptConfig.budget?.timeBudgetMs;
+        if (timeBudgetMs !== undefined) {
+            signals.push(AbortSignal.timeout(timeBudgetMs));
+        }
+        if (signals.length === 0)
+            return undefined;
+        if (signals.length === 1)
+            return signals[0];
+        return AbortSignal.any(signals);
+    }
+    isAbortError(err) {
+        return ((err instanceof DOMException && err.name === "AbortError") ||
+            (err instanceof DOMException && err.name === "TimeoutError") ||
+            (err instanceof Error && err.name === "AbortError") ||
+            (err instanceof Error && err.name === "TimeoutError"));
+    }
     text(promptConfig) {
         if (promptConfig.stream) {
             return this.textStream(promptConfig);
@@ -33,19 +56,92 @@ export class BaseClient {
         }
         return null;
     }
+    applyBudget(promptConfig) {
+        const budget = promptConfig.budget;
+        if (!budget)
+            return { config: promptConfig };
+        let config = { ...promptConfig };
+        // Auto-compute used values from message history when not explicitly provided
+        const assistantMessages = config.messages.filter((m) => m instanceof AssistantMessage);
+        const tokensUsed = budget.tokensUsed ??
+            assistantMessages.reduce((sum, m) => sum + (m.usage?.outputTokens ?? 0), 0);
+        const costUsed = budget.costUsed ??
+            assistantMessages.reduce((sum, m) => sum + (m.cost?.totalCost ?? 0), 0);
+        const requestsUsed = budget.requestsUsed ?? assistantMessages.length;
+        // Request budget check
+        if (budget.requestBudget !== undefined &&
+            requestsUsed >= budget.requestBudget) {
+            return {
+                config,
+                failure: {
+                    success: false,
+                    error: `Request budget exhausted: ${requestsUsed} requests used, budget is ${budget.requestBudget}`,
+                },
+            };
+        }
+        // Token budget check
+        if (budget.tokenBudget !== undefined) {
+            const remaining = budget.tokenBudget - tokensUsed;
+            if (remaining <= 0) {
+                return {
+                    config,
+                    failure: {
+                        success: false,
+                        error: `Token budget exhausted: ${tokensUsed} output tokens used, budget is ${budget.tokenBudget}`,
+                    },
+                };
+            }
+            config.maxTokens = Math.min(config.maxTokens ?? Infinity, remaining);
+        }
+        // Cost budget check
+        if (budget.costBudget !== undefined) {
+            const remainingUSD = budget.costBudget - costUsed;
+            if (remainingUSD <= 0) {
+                return {
+                    config,
+                    failure: {
+                        success: false,
+                        error: `Cost budget exhausted: $${costUsed.toFixed(4)} spent, budget is $${budget.costBudget.toFixed(4)}`,
+                    },
+                };
+            }
+            const model = getModel(this.config.model);
+            if (model && isTextModel(model) && model.outputTokenCost) {
+                const remainingTokens = Math.floor((remainingUSD / model.outputTokenCost) * 1_000_000);
+                config.maxTokens = Math.min(config.maxTokens ?? Infinity, remainingTokens);
+            }
+        }
+        return { config };
+    }
     async textSync(promptConfig) {
         const messageLimitResult = this.checkMessageLimit(promptConfig);
         if (messageLimitResult)
             return messageLimitResult;
-        const { continue: shouldContinue, newPromptConfig } = this.checkForToolLoops(promptConfig);
+        const { config: budgetedConfig, failure: budgetFailure } = this.applyBudget(promptConfig);
+        if (budgetFailure)
+            return budgetFailure;
+        const { continue: shouldContinue, newPromptConfig } = this.checkForToolLoops(budgetedConfig);
         if (!shouldContinue) {
             return {
                 success: true,
                 value: { output: null, toolCalls: [], model: this.config.model },
             };
         }
-        const result = await this.textWithRetry(newPromptConfig, newPromptConfig.responseFormatOptions?.numRetries || DEFAULT_NUM_RETRIES);
-        return result;
+        try {
+            const result = await this.textWithRetry(newPromptConfig, newPromptConfig.responseFormatOptions?.numRetries ||
+                DEFAULT_NUM_RETRIES);
+            return result;
+        }
+        catch (err) {
+            if (this.isAbortError(err)) {
+                const timeBudgetMs = promptConfig.budget?.timeBudgetMs;
+                const message = timeBudgetMs
+                    ? `Request timed out after ${timeBudgetMs}ms`
+                    : "Request was aborted";
+                return { success: false, error: message };
+            }
+            throw err;
+        }
     }
     checkForToolLoops(promptConfig) {
         if (!this.config.toolLoopDetection?.enabled) {
@@ -154,6 +250,10 @@ export class BaseClient {
     async textWithRetry(promptConfig, retries) {
         const result = await this._textSync(promptConfig);
         if (result.success) {
+            if (!promptConfig.responseFormat ||
+                !promptConfig.responseFormatOptions?.strict) {
+                return result;
+            }
             if (!("output" in result.value)) {
                 const retryMessages = [
                     ...promptConfig.messages,
@@ -196,7 +296,7 @@ export class BaseClient {
                 }
             }
         }
-        return result;
+        throw new SmolStructuredOutputError(`Failed to get valid response after ${DEFAULT_NUM_RETRIES} attempts: ${result.success ? "Output did not match expected format" : result.error}`);
     }
     async _textSync(promptConfig) {
         throw new Error("Method not implemented.");
@@ -222,7 +322,17 @@ export class BaseClient {
             };
             return;
         }
-        const { continue: shouldContinue, newPromptConfig } = this.checkForToolLoops(config);
+        const { config: budgetedConfig, failure: budgetFailure } = this.applyBudget(config);
+        if (budgetFailure) {
+            yield {
+                type: "error",
+                error: budgetFailure.success === false
+                    ? budgetFailure.error
+                    : "Budget exceeded",
+            };
+            return;
+        }
+        const { continue: shouldContinue, newPromptConfig } = this.checkForToolLoops(budgetedConfig);
         if (!shouldContinue) {
             yield {
                 type: "done",
@@ -234,7 +344,21 @@ export class BaseClient {
             };
             return;
         }
-        yield* this._textStream(newPromptConfig);
+        try {
+            yield* this._textStream(newPromptConfig);
+        }
+        catch (err) {
+            if (this.isAbortError(err)) {
+                const timeBudgetMs = config.budget?.timeBudgetMs;
+                const message = timeBudgetMs
+                    ? `Request timed out after ${timeBudgetMs}ms`
+                    : "Request was aborted";
+                yield { type: "timeout", error: message };
+            }
+            else {
+                throw err;
+            }
+        }
     }
     // default implementation of text stream just calls the non-streaming version and yields the result
     // clients that support streaming can override this to provide a streaming implementation

package/dist/clients/google.d.ts

@@ -1,6 +1,7 @@
 import { GoogleGenAI } from "@google/genai";
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ModelName } from "../models.js";
 export type SmolGoogleConfig = BaseClientConfig;
 export declare class SmolGoogle extends BaseClient implements SmolClient {
     private client;
@@ -8,7 +9,7 @@ export declare class SmolGoogle extends BaseClient implements SmolClient {
     private model;
     constructor(config: SmolGoogleConfig);
     getClient(): GoogleGenAI;
-    getModel(): string;
+    getModel(): ModelName;
     private calculateUsageAndCost;
     private buildRequest;
     _textSync(config: PromptConfig): Promise<Result<PromptResult>>;

package/dist/clients/google.js

@@ -4,7 +4,7 @@ import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { BaseClient } from "./baseClient.js";
-import { calculateCost } from "../models.js";
+import { Model } from "../model.js";
 export class SmolGoogle extends BaseClient {
     client;
     logger;
@@ -16,13 +16,13 @@ export class SmolGoogle extends BaseClient {
         }
         this.client = new GoogleGenAI({ apiKey: config.googleApiKey });
         this.logger = getLogger();
-        this.model = config.model;
+        this.model = new Model(config.model);
     }
     getClient() {
         return this.client;
     }
     getModel() {
-        return this.model;
+        return this.model.getResolvedModel();
     }
     calculateUsageAndCost(usageMetadata) {
         let usage;
@@ -34,7 +34,7 @@ export class SmolGoogle extends BaseClient {
                 cachedInputTokens: usageMetadata.cachedContentTokenCount,
                 totalTokens: usageMetadata.totalTokenCount,
             };
-            const calculatedCost = calculateCost(this.model, usage);
+            const calculatedCost = this.model.calculateCost(usage);
             if (calculatedCost) {
                 cost = calculatedCost;
             }
@@ -73,18 +73,28 @@ export class SmolGoogle extends BaseClient {
             genConfig.responseMimeType = "application/json";
             genConfig.responseJsonSchema = config.responseFormat.toJSONSchema();
         }
+        if (!config.thinking?.enabled && config.reasoningEffort) {
+            const budgetMap = { low: 2048, medium: 8192, high: 16384 };
+            genConfig.thinkingConfig = {
+                thinkingBudget: budgetMap[config.reasoningEffort],
+            };
+        }
         return {
             contents: messages,
-            model: this.model,
+            model: this.getModel(),
             config: genConfig,
             ...(config.rawAttributes || {}),
         };
     }
     async _textSync(config) {
+        const signal = this.getAbortSignal(config);
         const request = {
             ...this.buildRequest(config),
             stream: config.stream || false,
         };
+        if (signal) {
+            request.config = { ...request.config, abortSignal: signal };
+        }
         this.logger.debug("Sending request to Google Gemini:", JSON.stringify(request, null, 2));
         // Send the prompt as the latest message
         const result = await this.client.models.generateContent(request);
@@ -122,7 +132,11 @@ export class SmolGoogle extends BaseClient {
         });
     }
     async *_textStream(config) {
+        const signal = this.getAbortSignal(config);
         const request = this.buildRequest(config);
+        if (signal) {
+            request.config = { ...request.config, abortSignal: signal };
+        }
         this.logger.debug("Sending streaming request to Google Gemini:", JSON.stringify(request, null, 2));
         const stream = await this.client.models.generateContentStream(request);
         let content = "";
@@ -147,7 +161,11 @@ export class SmolGoogle extends BaseClient {
                             signature: p.thoughtSignature,
                         };
                         thinkingBlocks.push(block);
-                        yield { type: "thinking", text: block.text, signature: block.signature };
+                        yield {
+                            type: "thinking",
+                            text: block.text,
+                            signature: block.signature,
+                        };
                     }
                     else if (p.text) {
                         content += p.text;
@@ -157,7 +175,11 @@ export class SmolGoogle extends BaseClient {
                         const id = p.functionCall.id || p.functionCall.name || "";
                         const name = p.functionCall.name || "";
                         if (!toolCallsMap.has(id)) {
-                            toolCallsMap.set(id, { id, name, arguments: p.functionCall.args });
+                            toolCallsMap.set(id, {
+                                id,
+                                name,
+                                arguments: p.functionCall.args,
+                            });
                         }
                     }
                 }

package/dist/clients/ollama.d.ts

@@ -1,6 +1,7 @@
 import { Ollama } from "ollama";
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ModelName } from "../models.js";
 export declare const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
 export type SmolOllamaConfig = BaseClientConfig;
 export declare class SmolOllama extends BaseClient implements SmolClient {
@@ -9,7 +10,7 @@ export declare class SmolOllama extends BaseClient implements SmolClient {
     private client;
     constructor(config: SmolOllamaConfig);
     getClient(): Ollama;
-    getModel(): string;
+    getModel(): ModelName;
     private calculateUsageAndCost;
     _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
     _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;