smoltalk 0.4.2 → 0.5.1

package/README.md

@@ -194,6 +194,145 @@ Detects when the model is stuck in a repetitive tool-call loop.
 | `intervention` | `string` | Action to take: `"remove-tool"`, `"remove-all-tools"`, `"throw-error"`, or `"halt-execution"`. |
 | `excludeTools` | `string[]` | Tool names to ignore when counting calls. |
 
+## Refreshing model data
+
+Smoltalk ships a baked-in model registry (pricing, context limits, capabilities).
+Because that data goes stale between releases, you can pull a fresh copy at
+runtime and layer it over the built-ins. **You decide where to store it** —
+smoltalk never writes to disk.
+
+```ts
+import { refreshModels, registerModelData } from "smoltalk";
+
+// Fetch the latest data (from a URL smoltalk controls by default).
+const result = await refreshModels();
+if (result.success) {
+  // Persist result.value however you like (file, KV store, etc.),
+  // then register it once at startup:
+  registerModelData(result.value);
+}
+```
+
+Precedence is **per-call `config.modelData` > `registerModelData` (global) >
+baked-in baseline**, merged field-by-field (a refreshed field wins; missing
+fields never erase built-in values). Per-call override:
+
+```ts
+import { textSync, type Message, type ModelDataBlob } from "smoltalk";
+
+declare const messages: Message[];
+declare const modelData: ModelDataBlob;
+
+await textSync({ model: "claude-opus-4-8", messages, modelData });
+```
+
+Override the source URL with the `SMOLTALK_MODEL_DATA_URL` env var or
+`refreshModels({ url })`. The URL may be remote (`https://`, e.g. your own
+self-hosted catalog) or local (`file://…/model-data.json`). The blob also carries
+a `hostedTools` catalog (`getHostedTools()`); the published file is kept current
+by a daily CI job that translates [models.dev](https://models.dev) into
+smoltalk's shape.
+
+## Hosted tools catalog
+
+Each cloud provider offers server-side "hosted" tools (web search, code
+execution, file search, image generation). Smoltalk ships a catalog of what's
+available and what it costs — query it with `getHostedTools()`:
+
+```ts
+import { getHostedTools, hostedToolPricingFor } from "smoltalk";
+
+// Hosted tools usable with a given model (respects provider + model allowlists):
+console.log(getHostedTools({ model: "claude-opus-4-8" }));
+
+// All web-search tools across providers:
+const search = getHostedTools({ category: "web_search" });
+
+// Effective pricing for a tool on a specific model (applies per-model overrides):
+const first = search[0];
+if (first) {
+  console.log(hostedToolPricingFor(first, "gemini-2.5-pro"));
+}
+```
+
+The catalog rides in the same refresh blob as model data, so `refreshModels()`
+keeps it current. Local models (Ollama) have none.
+
+### Using a hosted tool (web search)
+
+Enable a provider's hosted web search on a call with `hostedTools` (a list of
+capability names). It's separate from `tools` because hosted tools run
+server-side — you can't intercept or gate them like your own functions.
+
+```ts
+import { textSync, type Message } from "smoltalk";
+
+declare const messages: Message[];
+
+const result = await textSync({
+  model: "claude-opus-4-8",
+  messages,
+  hostedTools: ["web_search"],
+});
+
+// Normalized across providers, regardless of who ran the search:
+if (result.success) {
+  console.log(result.value.hostedToolResults);
+  // [{ tool: "web_search", provider: "anthropic", queries: [...], sources: [...],
+  //    citations: [...], callCount: 1, estimatedCost: 0.01 }]
+}
+```
+
+Supported on Anthropic, Google, and OpenAI **Responses-API** models. Note that
+smoltalk routes base GPT-5 / GPT-4o to Chat Completions, so on OpenAI hosted web
+search is available only on the `openai-responses` models (the `*-pro` variants,
+e.g. `gpt-5-pro`). Chat-only OpenAI models (`gpt-4o`, `gpt-5`) and local models
+return a clear error — use a search *function* (e.g. the Brave/Tavily-backed
+stdlib tools) as a regular `tool` instead.
+
+`estimatedCost` is an upper-bound estimate (providers report usage counts, not
+charges; free-tier allowances are ignored). Results are populated on `textSync`;
+streaming text is unaffected but the streamed result does not include them yet.
+On Google, web search can't be combined with structured output in one call.
+
+## Registering custom providers
+
+Smoltalk has three registration entry points — one per capability:
+
+```ts
+// example: skip-typecheck
+import {
+  success,                    // Result helper
+  registerProvider,           // text generation (a class extending BaseClient)
+  registerEmbeddingProvider,  // embeddings (a function)
+  registerImageProvider,      // images (a function)
+} from "smoltalk";
+
+// Text: a class extending BaseClient (implements _textSync / _textStream)
+registerProvider("my-llm", MyTextClient);
+
+// Embeddings: a function
+registerEmbeddingProvider("my-embed", async (inputs, config) => {
+  // read credentials from config (e.g. config.metadata), call your service
+  return success({ embeddings: [...], model: config.model });
+});
+
+// Images: a function
+registerImageProvider("my-image", async (input, config) => {
+  return success({ images: [...], model: config.model });
+});
+```
+
+Select a custom provider by passing `provider` in the call config
+(`embed(input, { provider: "my-embed", model })`,
+`image(input, { provider: "my-image", model })`). Built-in providers always take
+precedence; a registered name that collides with a built-in is ignored. Custom
+providers receive the full `config` and read their own credentials from it
+(e.g. `config.metadata`).
+
+Text is a class (it needs retries, tool-loop detection, streaming); embeddings
+and images are one-shot functions.
+
 ## Limitations
 Smoltalk has support for a limited number of providers right now, and is mostly focused on the stateless APIs for text completion, though I plan to add support for more providers as well as image and speech models later. Smoltalk is also a personal project, and there are alternatives backed by companies:
 

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

@@ -37,6 +37,7 @@ export declare const AssistantMessageJSONSchema: z.ZodObject<{
         outputCost: z.ZodNumber;
         cachedInputCost: z.ZodOptional<z.ZodNumber>;
         cacheCreationInputCost: z.ZodOptional<z.ZodNumber>;
+        hostedToolsCost: z.ZodOptional<z.ZodNumber>;
         totalCost: z.ZodNumber;
         currency: z.ZodString;
     }, z.core.$strip>>;

package/dist/client.js

@@ -12,7 +12,9 @@ import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
 import { getModel, isTextModel } from "./models.js";
 import { SmolError } from "./smolError.js";
 import { resolveApiKey, resolveProvider } from "./util/provider.js";
-const registeredProviders = {};
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registeredProviders = Object.create(null);
 export function registerProvider(providerName, clientClass) {
     registeredProviders[providerName] = clientClass;
 }
@@ -25,11 +27,11 @@ export function unregisterProvider(providerName) {
 }
 export function getClient(config) {
     const modelName = config.model;
-    const provider = resolveProvider(modelName, config.provider);
+    const provider = resolveProvider(modelName, config.provider, config.modelData);
     // For getClient, validate that the model is a text model when no explicit
     // provider is given (since this factory only returns text-generation clients).
     if (!config.provider) {
-        const model = getModel(modelName);
+        const model = getModel(modelName, config.modelData);
         if (model && !isTextModel(model)) {
             throw new SmolError(`Only text models are supported currently. ${modelName} is a ${model?.type} model.`);
         }

package/dist/clients/anthropic.d.ts

@@ -1,6 +1,8 @@
-import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
+import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk, HostedToolResult } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
+export declare function anthropicWebSearchEntries(hostedTools?: string[]): any[];
+export declare function parseAnthropicHostedTools(response: any, provider: string): HostedToolResult[];
 export type SmolAnthropicConfig = SmolConfig & {
     anthropicApiKey: string;
 };

package/dist/clients/anthropic.js

@@ -3,6 +3,7 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { SystemMessage, DeveloperMessage } from "../classes/message/index.js";
 import { getLogger } from "../util/logger.js";
 import { success, } from "../types.js";
+import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hostedTools.js";
 import { zodToAnthropicTool } from "../util/tool.js";
 import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
@@ -10,14 +11,57 @@ import { BaseClient } from "./baseClient.js";
 import { getModel, isTextModel } from "../models.js";
 import { Model } from "../model.js";
 const DEFAULT_MAX_TOKENS = 4096;
+export function anthropicWebSearchEntries(hostedTools) {
+    if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
+        return [{ type: "web_search_20250305", name: "web_search" }];
+    }
+    return [];
+}
+export function parseAnthropicHostedTools(response, provider) {
+    const queries = [];
+    const sources = [];
+    const citations = [];
+    const raw = [];
+    for (const block of response.content || []) {
+        if (block.type === "server_tool_use" && block.name === "web_search") {
+            raw.push(block);
+            // input.query is always the search string; guard only against a malformed block.
+            if (block.input?.query) {
+                queries.push(block.input.query);
+            }
+        }
+        else if (block.type === "web_search_tool_result") {
+            raw.push(block);
+            // content items are web_search_result entries; an error variant has no url.
+            for (const r of block.content || []) {
+                if (r && typeof r.url === "string") {
+                    sources.push({ url: r.url, title: r.title });
+                }
+            }
+        }
+        else if (block.type === "text" && Array.isArray(block.citations)) {
+            for (const c of block.citations) {
+                if (c && typeof c.url === "string") {
+                    citations.push({ url: c.url, title: c.title });
+                }
+            }
+        }
+    }
+    const callCount = response.usage?.server_tool_use?.web_search_requests;
+    const used = queries.length > 0 || sources.length > 0 || (callCount ?? 0) > 0;
+    if (!used) {
+        return [];
+    }
+    return [webSearchResult(provider, { queries, sources, citations, callCount, raw })];
+}
 /**
  * Which thinking API a model speaks. New flagship Anthropic models (Opus 4.7+)
  * reject the legacy `{type: "enabled", budget_tokens}` form with a 400, so we
  * default unknown/unregistered models to "adaptive" (the forward-looking shape)
  * rather than the form that's being phased out.
  */
-function thinkingStyleFor(modelName) {
-    const model = getModel(modelName);
+function thinkingStyleFor(modelName, modelData) {
+    const model = getModel(modelName, modelData);
     if (model && isTextModel(model) && model.reasoning?.thinkingStyle) {
         return model.reasoning.thinkingStyle;
     }
@@ -107,7 +151,7 @@ export class SmolAnthropic extends BaseClient {
         super(config);
         this.client = new Anthropic({ apiKey: config.anthropicApiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model);
+        this.model = new Model(config.model, undefined, config.modelData);
     }
     getModel() {
         return this.model.getModel();
@@ -162,11 +206,14 @@ export class SmolAnthropic extends BaseClient {
             }
             anthropicMessages.push(converted);
         }
-        const tools = config.tools && config.tools.length > 0
+        const functionTools = config.tools && config.tools.length > 0
             ? config.tools.map((tool) => zodToAnthropicTool(tool.name, tool.schema, {
                 description: tool.description,
             }))
-            : undefined;
+            : [];
+        const hostedEntries = anthropicWebSearchEntries(config.hostedTools);
+        const allTools = [...functionTools, ...hostedEntries];
+        const tools = allTools.length > 0 ? allTools : undefined;
         // Normalize the user's provider-agnostic thinking/effort config into the
         // shape this specific model accepts. Both `thinking.enabled` and
         // `reasoningEffort` are treated as a request to think.
@@ -190,7 +237,7 @@ export class SmolAnthropic extends BaseClient {
         if (!wantsThinking && !effort) {
             return { thinking: undefined, outputConfig: undefined };
         }
-        if (thinkingStyleFor(this.getModel()) === "adaptive") {
+        if (thinkingStyleFor(this.getModel(), this.config.modelData) === "adaptive") {
             // `output_config.effort` controls depth; the budget is irrelevant here.
             return {
                 thinking: { type: "adaptive" },
@@ -283,14 +330,22 @@ export class SmolAnthropic extends BaseClient {
             }
         }
         const { usage, cost } = this.calculateUsageAndCost(response.usage);
-        return success({
+        const parsed = parseAnthropicHostedTools(response, "anthropic");
+        const { results: hostedToolResults, cost: finalCost } = applyHostedToolCost(parsed, cost, this.getModel(), this.config.modelData);
+        const result = {
             output,
             toolCalls,
-            ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
             usage,
-            cost,
+            cost: finalCost,
             model: this.getModel(),
-        });
+        };
+        if (thinkingBlocks.length > 0) {
+            result.thinkingBlocks = thinkingBlocks;
+        }
+        if (hostedToolResults.length > 0) {
+            result.hostedToolResults = hostedToolResults;
+        }
+        return success(result);
     }
     async *_textStream(config) {
         const { system, messages, tools, thinking, outputConfig } = this.buildRequest(config);

package/dist/clients/baseClient.js

@@ -3,7 +3,8 @@ import { getLogger } from "../util/logger.js";
 import { SmolStructuredOutputError } from "../smolError.js";
 import { getStatelogClient } from "../statelogClient.js";
 import { stripCodeFence } from "../util/util.js";
-import { success, } from "../types.js";
+import { success, failure, } from "../types.js";
+import { validateHostedTools } from "../util/hostedTools.js";
 import { z } from "zod";
 const DEFAULT_NUM_RETRIES = 2;
 export class BaseClient {
@@ -55,6 +56,10 @@ export class BaseClient {
         const messageLimitResult = this.checkMessageLimit(promptConfig);
         if (messageLimitResult)
             return messageLimitResult;
+        const hostedError = validateHostedTools(promptConfig.hostedTools, promptConfig.model, promptConfig.provider, promptConfig.modelData);
+        if (hostedError) {
+            return failure(hostedError);
+        }
         const { continue: shouldContinue, newSmolConfig } = this.checkForToolLoops(promptConfig);
         if (!shouldContinue) {
             return {
@@ -264,6 +269,11 @@ export class BaseClient {
             };
             return;
         }
+        const hostedError = validateHostedTools(config.hostedTools, config.model, config.provider, config.modelData);
+        if (hostedError) {
+            yield { type: "error", error: hostedError };
+            return;
+        }
         const { continue: shouldContinue, newSmolConfig } = this.checkForToolLoops(config);
         if (!shouldContinue) {
             yield {

package/dist/clients/google.d.ts

@@ -2,7 +2,10 @@ import { Content, GenerateContentConfig, GoogleGenAI } from "@google/genai";
 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 SmolGoogleConfig = SmolConfig;
+export declare function googleWebSearchEntries(hostedTools?: string[]): any[];
+export declare function parseGoogleHostedTools(result: any, provider: string, model: string): HostedToolResult[];
 type GeneratedRequest = {
     contents: Content[];
     model: ModelName;

package/dist/clients/google.js

@@ -7,8 +7,61 @@ import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForSta
 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;
@@ -20,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;
@@ -69,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";
@@ -232,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);

package/dist/clients/ollama.js

@@ -16,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",

package/dist/clients/openai.js

@@ -19,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;

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,9 +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, 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;
@@ -19,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;
@@ -62,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;
         }
@@ -144,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>>;