smoltalk 0.4.1 → 0.5.0

package/dist/clients/google.js

@@ -3,11 +3,65 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../util/logger.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { BaseClient } from "./baseClient.js";
+import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hostedTools.js";
 import { Model } from "../model.js";
 import { userMessage } from "../classes/message/index.js";
+export function googleWebSearchEntries(hostedTools) {
+    if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
+        return [{ googleSearch: {} }];
+    }
+    return [];
+}
+export function parseGoogleHostedTools(result, provider, model) {
+    const queries = [];
+    const sources = [];
+    const citations = [];
+    const raw = [];
+    for (const candidate of result.candidates || []) {
+        const gm = candidate.groundingMetadata;
+        // A candidate without groundingMetadata simply didn't ground — nothing to
+        // extract. If no candidate grounded, this returns [] overall.
+        if (!gm) {
+            continue;
+        }
+        raw.push(gm);
+        for (const q of gm.webSearchQueries || []) {
+            queries.push(q);
+        }
+        const chunks = gm.groundingChunks || [];
+        for (const c of chunks) {
+            if (c.web && typeof c.web.uri === "string") {
+                sources.push({ url: c.web.uri, title: c.web.title });
+            }
+        }
+        for (const s of gm.groundingSupports || []) {
+            for (const idx of s.groundingChunkIndices || []) {
+                const chunk = chunks[idx];
+                if (chunk && chunk.web && typeof chunk.web.uri === "string") {
+                    citations.push({
+                        url: chunk.web.uri,
+                        title: chunk.web.title,
+                        startIndex: s.segment?.startIndex,
+                        endIndex: s.segment?.endIndex,
+                    });
+                }
+            }
+        }
+    }
+    if (queries.length === 0 && sources.length === 0) {
+        return [];
+    }
+    // Gemini 2.5 bills per prompt (1), Gemini 3+ per query.
+    let callCount = queries.length;
+    if (model.startsWith("gemini-2.5")) {
+        callCount = 1;
+    }
+    return [webSearchResult(provider, { queries, sources, citations, callCount, raw })];
+}
 export class SmolGoogle extends BaseClient {
     client;
     logger;
@@ -19,7 +73,7 @@ export class SmolGoogle extends BaseClient {
         }
         this.client = new GoogleGenAI({ apiKey: config.googleApiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model);
+        this.model = new Model(config.model, undefined, config.modelData);
     }
     getClient() {
         return this.client;
@@ -68,8 +122,16 @@ export class SmolGoogle extends BaseClient {
         if (systemParts.length > 0) {
             genConfig.systemInstruction = systemParts.join("\n");
         }
-        if (tools.length > 0) {
-            genConfig.tools = [{ functionDeclarations: tools }];
+        const hostedEntries = googleWebSearchEntries(config.hostedTools);
+        if (tools.length > 0 || hostedEntries.length > 0) {
+            const toolGroups = [];
+            if (tools.length > 0) {
+                toolGroups.push({ functionDeclarations: tools });
+            }
+            for (const entry of hostedEntries) {
+                toolGroups.push(entry);
+            }
+            genConfig.tools = toolGroups;
         }
         if (config.responseFormat) {
             genConfig.responseMimeType = "application/json";
@@ -88,6 +150,18 @@ export class SmolGoogle extends BaseClient {
             ...sanitizeAttributes(config.rawAttributes),
         };
     }
+    rethrowAsSmolError(error) {
+        const http = { ...extractHttpErrorFields(error), cause: error };
+        const msg = (error.message || "").toLowerCase();
+        if (msg.includes("token") &&
+            (msg.includes("exceed") || msg.includes("too long") || msg.includes("limit"))) {
+            throw new SmolContextWindowExceededError(error.message, http);
+        }
+        if (http.status !== undefined) {
+            throw smolErrorForStatus(error.message, http);
+        }
+        throw error;
+    }
     async _textSync(config) {
         const signal = this.getAbortSignal(config);
         const request = {
@@ -180,14 +254,7 @@ export class SmolGoogle extends BaseClient {
             result = await this.client.models.generateContent(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("token") &&
-                (msg.includes("exceed") ||
-                    msg.includes("too long") ||
-                    msg.includes("limit"))) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         this.logger.debug("Response from Google Gemini:", JSON.stringify(result, null, 2));
         this.statelogClient?.promptResponse(result);
@@ -226,15 +293,23 @@ export class SmolGoogle extends BaseClient {
         const output = textContent || null;
         // Extract usage and calculate cost
         const { usage, cost } = this.calculateUsageAndCost(result.usageMetadata);
+        const parsed = parseGoogleHostedTools(result, "google", request.model);
+        const { results: hostedToolResults, cost: finalCost } = applyHostedToolCost(parsed, cost, request.model, this.config.modelData);
         // Return the response, updating the chat history
-        return success({
+        const promptResult = {
             output,
             toolCalls,
-            ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
             usage,
-            cost,
+            cost: finalCost,
             model: request.model,
-        });
+        };
+        if (thinkingBlocks.length > 0) {
+            promptResult.thinkingBlocks = thinkingBlocks;
+        }
+        if (hostedToolResults.length > 0) {
+            promptResult.hostedToolResults = hostedToolResults;
+        }
+        return success(promptResult);
     }
     async *_textStream(config) {
         const signal = this.getAbortSignal(config);
@@ -257,14 +332,7 @@ export class SmolGoogle extends BaseClient {
             stream = await this.client.models.generateContentStream(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("token") &&
-                (msg.includes("exceed") ||
-                    msg.includes("too long") ||
-                    msg.includes("limit"))) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         let content = "";
         const toolCallsMap = new Map();

package/dist/clients/ollama.d.ts

@@ -12,6 +12,7 @@ export declare class SmolOllama extends BaseClient implements SmolClient {
     getClient(): Ollama;
     getModel(): ModelName;
     private calculateUsageAndCost;
+    private rethrowAsSmolError;
     _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
     _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }

package/dist/clients/ollama.js

@@ -5,7 +5,8 @@ import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { BaseClient } from "./baseClient.js";
-import { SmolContextWindowExceededError } from "../smolError.js";
+import { SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { Model } from "../model.js";
 export const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
 export class SmolOllama extends BaseClient {
@@ -15,7 +16,7 @@ export class SmolOllama extends BaseClient {
     constructor(config) {
         super(config);
         this.logger = getLogger();
-        this.model = new Model(config.model);
+        this.model = new Model(config.model, undefined, config.modelData);
         if (config.ollamaApiKey) {
             this.client = new Ollama({
                 host: "https://cloud.ollama.com",
@@ -51,6 +52,17 @@ export class SmolOllama extends BaseClient {
         }
         return { usage, cost };
     }
+    rethrowAsSmolError(error) {
+        const http = { ...extractHttpErrorFields(error), cause: error };
+        const msg = (error.message || "").toLowerCase();
+        if (msg.includes("context length") || msg.includes("context window")) {
+            throw new SmolContextWindowExceededError(error.message, http);
+        }
+        if (http.status !== undefined) {
+            throw smolErrorForStatus(error.message, http);
+        }
+        throw error;
+    }
     async _textSync(config) {
         const messages = config.messages.map((msg) => msg.toOpenAIMessage());
         const tools = (config.tools || []).map((tool) => {
@@ -82,11 +94,7 @@ export class SmolOllama extends BaseClient {
             result = await this.client.chat(request);
         }
         catch (error) {
-            const msg = (error.message || "").toLowerCase();
-            if (msg.includes("context length") || msg.includes("context window")) {
-                throw new SmolContextWindowExceededError(error.message);
-            }
-            throw error;
+            this.rethrowAsSmolError(error);
         }
         finally {
             if (signal && abortHandler) {
@@ -201,6 +209,9 @@ export class SmolOllama extends BaseClient {
                 },
             };
         }
+        catch (error) {
+            this.rethrowAsSmolError(error);
+        }
         finally {
             if (signal && abortHandler) {
                 signal.removeEventListener("abort", abortHandler);

package/dist/clients/openai.js

@@ -4,7 +4,8 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { isFunctionToolCall, sanitizeAttributes } from "../util/util.js";
 import { getLogger } from "../util/logger.js";
 import { BaseClient } from "./baseClient.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
 import { zodToOpenAITool } from "../util/tool.js";
 import { Model } from "../model.js";
 export class SmolOpenAi extends BaseClient {
@@ -18,7 +19,7 @@ export class SmolOpenAi extends BaseClient {
         }
         this.client = new OpenAI({ apiKey: config.openAiApiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model);
+        this.model = new Model(config.model, undefined, config.modelData);
     }
     getClient() {
         return this.client;
@@ -74,12 +75,14 @@ export class SmolOpenAi extends BaseClient {
     }
     rethrowAsSmolError(error) {
         if (error instanceof OpenAI.APIError) {
+            const http = { ...extractHttpErrorFields(error), cause: error };
             if (error.code === "context_length_exceeded") {
-                throw new SmolContextWindowExceededError(error.message);
+                throw new SmolContextWindowExceededError(error.message, http);
             }
             if (error.code === "content_policy_violation") {
-                throw new SmolContentPolicyError(error.message);
+                throw new SmolContentPolicyError(error.message, http);
             }
+            throw smolErrorForStatus(error.message, http);
         }
         throw error;
     }

package/dist/clients/openaiResponses.d.ts

@@ -2,7 +2,10 @@ import OpenAI from "openai";
 import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
+import { HostedToolResult } from "../types.js";
 export type SmolOpenAiResponsesConfig = SmolConfig;
+export declare function openaiResponsesWebSearchEntries(hostedTools?: string[]): any[];
+export declare function parseOpenAIResponsesHostedTools(response: any, provider: string): HostedToolResult[];
 export declare class SmolOpenAiResponses extends BaseClient implements SmolClient {
     private client;
     private logger;

package/dist/clients/openaiResponses.js

@@ -5,8 +5,48 @@ import { getLogger } from "../util/logger.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
+import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hostedTools.js";
 import { Model } from "../model.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, } from "../smolError.js";
+import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { extractHttpErrorFields } from "../util/httpError.js";
+export function openaiResponsesWebSearchEntries(hostedTools) {
+    if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
+        return [{ type: "web_search" }];
+    }
+    return [];
+}
+export function parseOpenAIResponsesHostedTools(response, provider) {
+    const queries = [];
+    const sources = [];
+    const citations = [];
+    const raw = [];
+    let callCount = 0;
+    for (const item of response.output || []) {
+        if (item.type === "web_search_call") {
+            raw.push(item);
+            callCount += 1;
+            // action.query is present for `search` actions but not always (e.g. open_page).
+            const query = item.action?.query;
+            if (typeof query === "string") {
+                queries.push(query);
+            }
+        }
+        else if (item.type === "message") {
+            for (const part of item.content || []) {
+                for (const ann of part.annotations || []) {
+                    if (ann.type === "url_citation" && typeof ann.url === "string") {
+                        citations.push({ url: ann.url, title: ann.title, startIndex: ann.start_index, endIndex: ann.end_index });
+                        sources.push({ url: ann.url, title: ann.title });
+                    }
+                }
+            }
+        }
+    }
+    if (callCount === 0 && citations.length === 0) {
+        return [];
+    }
+    return [webSearchResult(provider, { queries, sources, citations, callCount, raw })];
+}
 export class SmolOpenAiResponses extends BaseClient {
     client;
     logger;
@@ -18,7 +58,7 @@ export class SmolOpenAiResponses extends BaseClient {
         }
         this.client = new OpenAI({ apiKey: config.openAiApiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model);
+        this.model = new Model(config.model, undefined, config.modelData);
     }
     getClient() {
         return this.client;
@@ -61,6 +101,11 @@ export class SmolOpenAiResponses extends BaseClient {
                 description: tool.description,
             }));
         }
+        const hostedEntries = openaiResponsesWebSearchEntries(config.hostedTools);
+        if (hostedEntries.length > 0) {
+            const existing = Array.isArray(request.tools) ? request.tools : [];
+            request.tools = [...existing, ...hostedEntries];
+        }
         if (config.temperature !== undefined) {
             request.temperature = config.temperature;
         }
@@ -107,12 +152,14 @@ export class SmolOpenAiResponses extends BaseClient {
     }
     rethrowAsSmolError(error) {
         if (error instanceof OpenAI.APIError) {
+            const http = { ...extractHttpErrorFields(error), cause: error };
             if (error.code === "context_length_exceeded") {
-                throw new SmolContextWindowExceededError(error.message);
+                throw new SmolContextWindowExceededError(error.message, http);
             }
             if (error.code === "content_policy_violation") {
-                throw new SmolContentPolicyError(error.message);
+                throw new SmolContentPolicyError(error.message, http);
             }
+            throw smolErrorForStatus(error.message, http);
         }
         throw error;
     }
@@ -141,13 +188,19 @@ export class SmolOpenAiResponses extends BaseClient {
             }
         }
         const { usage, cost } = this.calculateUsageAndCost(response.usage);
-        return success({
+        const parsed = parseOpenAIResponsesHostedTools(response, "openai-responses");
+        const { results: hostedToolResults, cost: finalCost } = applyHostedToolCost(parsed, cost, this.getModel(), this.config.modelData);
+        const result = {
             output,
             toolCalls,
             usage,
-            cost,
+            cost: finalCost,
             model: this.getModel(),
-        });
+        };
+        if (hostedToolResults.length > 0) {
+            result.hostedToolResults = hostedToolResults;
+        }
+        return success(result);
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);

package/dist/embed/openai.js

@@ -16,7 +16,7 @@ export async function openaiEmbed(inputs, config, apiKey) {
             .sort((a, b) => a.index - b.index)
             .map((d) => d.embedding);
         const inputTokens = response.usage.prompt_tokens;
-        const costEstimate = calculateEmbeddingCost(config.model, inputTokens);
+        const costEstimate = calculateEmbeddingCost(config.model, inputTokens, config.modelData);
         return success({
             embeddings,
             model: response.model,
@@ -28,8 +28,8 @@ export async function openaiEmbed(inputs, config, apiKey) {
         return failure(err instanceof Error ? err.message : "OpenAI embedding request failed");
     }
 }
-function calculateEmbeddingCost(modelName, inputTokens) {
-    const model = getModel(modelName);
+function calculateEmbeddingCost(modelName, inputTokens, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isEmbeddingsModel(model) || !model.tokenCost)
         return undefined;
     const inputCost = round((inputTokens * model.tokenCost) / 1_000_000, 6);

package/dist/embed.d.ts

@@ -1,16 +1,17 @@
-import { Provider } from "./models.js";
+import type { ModelDataBlob } from "./modelData.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
 export type EmbedConfig = {
     model: string;
-    provider?: Provider;
+    provider?: string;
     dimensions?: number;
     openAiApiKey?: string;
     googleApiKey?: string;
     ollamaApiKey?: string;
     ollamaHost?: string;
     metadata?: Record<string, unknown>;
+    modelData?: ModelDataBlob;
 };
 export type EmbedResult = {
     embeddings: number[][];
@@ -18,4 +19,6 @@ export type EmbedResult = {
     tokenUsage?: TokenUsage;
     costEstimate?: CostEstimate;
 };
+export type EmbedProvider = (inputs: string[], config: EmbedConfig) => Promise<Result<EmbedResult>>;
+export declare function registerEmbeddingProvider(name: string, fn: EmbedProvider): void;
 export declare function embed(input: string | string[], config: EmbedConfig): Promise<Result<EmbedResult>>;

package/dist/embed.js

@@ -3,11 +3,17 @@ import { resolveProvider, resolveApiKey } from "./util/provider.js";
 import { openaiEmbed } from "./embed/openai.js";
 import { googleEmbed } from "./embed/google.js";
 import { ollamaEmbed } from "./embed/ollama.js";
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registeredEmbedProviders = Object.create(null);
+export function registerEmbeddingProvider(name, fn) {
+    registeredEmbedProviders[name] = fn;
+}
 export async function embed(input, config) {
     const inputs = Array.isArray(input) ? input : [input];
     let provider;
     try {
-        provider = resolveProvider(config.model, config.provider);
+        provider = resolveProvider(config.model, config.provider, config.modelData);
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Failed to resolve provider");
@@ -29,7 +35,12 @@ export async function embed(input, config) {
         }
         case "ollama":
             return ollamaEmbed(inputs, config, apiKey, config.ollamaHost);
-        default:
-            return failure(`Provider "${provider}" does not support embeddings`);
+        default: {
+            const custom = registeredEmbedProviders[provider];
+            if (custom) {
+                return custom(inputs, config);
+            }
+            return failure(`Provider "${provider}" does not support embeddings. Register one with registerEmbeddingProvider(name, fn).`);
+        }
     }
 }

package/dist/image/google.js

@@ -41,15 +41,15 @@ export async function googleImage(input, config, apiKey) {
         return success({
             images,
             model: config.model,
-            costEstimate: calculateGoogleImageCost(config.model, images.length),
+            costEstimate: calculateGoogleImageCost(config.model, images.length, config.modelData),
         });
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Google image request failed");
     }
 }
-function calculateGoogleImageCost(modelName, imageCount) {
-    const model = getModel(modelName);
+function calculateGoogleImageCost(modelName, imageCount, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model) || !model.costPerImage)
         return undefined;
     const totalCost = round(model.costPerImage * imageCount, COST_DECIMAL_PLACES);

package/dist/image/openai.js

@@ -24,8 +24,8 @@ export async function openaiImage(input, config, apiKey) {
         }));
         const tokenUsage = extractUsage(response);
         const costEstimate = tokenUsage
-            ? calculateImageCost(config.model, tokenUsage)
-            : calculatePerImageCost(config.model, images.length);
+            ? calculateImageCost(config.model, tokenUsage, config.modelData)
+            : calculatePerImageCost(config.model, images.length, config.modelData);
         return success({
             images,
             model: config.model,
@@ -97,8 +97,8 @@ function extractUsage(response) {
         totalTokens: u.total_tokens,
     };
 }
-function calculateImageCost(modelName, usage) {
-    const model = getModel(modelName);
+function calculateImageCost(modelName, usage, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model))
         return undefined;
     const totalIn = usage.inputTokens ?? 0;
@@ -131,8 +131,8 @@ function calculateImageCost(modelName, usage) {
         currency: "USD",
     };
 }
-function calculatePerImageCost(modelName, imageCount) {
-    const model = getModel(modelName);
+function calculatePerImageCost(modelName, imageCount, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model) || !model.costPerImage)
         return undefined;
     const totalCost = round(model.costPerImage * imageCount, COST_DECIMAL_PLACES);

package/dist/image.d.ts

@@ -1,4 +1,4 @@
-import { Provider } from "./models.js";
+import type { ModelDataBlob } from "./modelData.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
@@ -11,7 +11,7 @@ export type ImageInput = string | {
 };
 export type ImageConfig = {
     model: string;
-    provider?: Provider;
+    provider?: string;
     n?: number;
     size?: string;
     quality?: "low" | "medium" | "high" | "auto";
@@ -20,6 +20,7 @@ export type ImageConfig = {
     openAiApiKey?: string;
     googleApiKey?: string;
     metadata?: Record<string, unknown>;
+    modelData?: ModelDataBlob;
 };
 export type GeneratedImage = {
     data: Uint8Array;
@@ -32,4 +33,6 @@ export type ImageGenResult = {
     tokenUsage?: TokenUsage;
     costEstimate?: CostEstimate;
 };
+export type ImageProvider = (input: ImageInput, config: ImageConfig) => Promise<Result<ImageGenResult>>;
+export declare function registerImageProvider(name: string, fn: ImageProvider): void;
 export declare function image(input: ImageInput, config: ImageConfig): Promise<Result<ImageGenResult>>;

package/dist/image.js

@@ -2,10 +2,16 @@ import { failure } from "./types/result.js";
 import { resolveProvider, resolveApiKey } from "./util/provider.js";
 import { openaiImage } from "./image/openai.js";
 import { googleImage } from "./image/google.js";
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registeredImageProviders = Object.create(null);
+export function registerImageProvider(name, fn) {
+    registeredImageProviders[name] = fn;
+}
 export async function image(input, config) {
     let provider;
     try {
-        provider = resolveProvider(config.model, config.provider);
+        provider = resolveProvider(config.model, config.provider, config.modelData);
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Failed to resolve provider");
@@ -31,7 +37,12 @@ export async function image(input, config) {
             }
             return googleImage(input, config, apiKey);
         }
-        default:
-            return failure(`Provider "${provider}" does not support image generation`);
+        default: {
+            const custom = registeredImageProviders[provider];
+            if (custom) {
+                return custom(input, config);
+            }
+            return failure(`Provider "${provider}" does not support image generation. Register one with registerImageProvider(name, fn).`);
+        }
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./modelData.js";
 export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util/util.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./modelData.js";
 export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util/util.js";

package/dist/model.d.ts

@@ -1,9 +1,11 @@
 import { ModelName, Provider } from "./models.js";
 import { ModelLike } from "./types.js";
+import type { ModelDataBlob } from "./modelData.js";
 export declare class Model {
     private model;
     private provider?;
-    constructor(model: ModelName, provider?: Provider);
+    private modelData?;
+    constructor(model: ModelName, provider?: Provider, modelData?: ModelDataBlob);
     getModel(): ModelName;
     getProvider(): Provider | undefined;
     private lookupProvider;
@@ -22,5 +24,5 @@ export declare class Model {
     } | null;
     toString(): string;
     toJSON(): ModelName;
-    static create(model: ModelLike, provider?: Provider): Model;
+    static create(model: ModelLike, provider?: Provider, modelData?: ModelDataBlob): Model;
 }