smoltalk 0.5.0 → 0.6.0

package/dist/clients/openaiCompat.js

@@ -0,0 +1,33 @@
+import { SmolOpenAi } from "./openai.js";
+import { resolveApiKey, resolveBaseUrl } from "../util/provider.js";
+/**
+ * Generic OpenAI-compatible client. Use when pointing smoltalk at any
+ * arbitrary OpenAI-shaped endpoint (vLLM, TGI, LM Studio, OpenLLM, etc.).
+ *
+ * Both `config.apiKey.openAiCompat` and `config.baseUrl.openAiCompat` are
+ * required (or their env-var fallbacks: `OPENAI_COMPAT_API_KEY`,
+ * `OPENAI_COMPAT_BASE_URL`).
+ *
+ * Cost: opportunistically reads `usage.cost`, `usage.estimated_cost`, or
+ * `usage.cost_usd` if the backend includes one of them. Otherwise falls back
+ * to the smoltalk model registry (which won't have these custom models, so
+ * cost stays undefined — that's expected for arbitrary backends).
+ */
+export class SmolOpenAiCompat extends SmolOpenAi {
+    resolveClientOptions(config) {
+        const apiKey = resolveApiKey("openai-compat", config);
+        const baseURL = resolveBaseUrl("openai-compat", config);
+        if (!apiKey) {
+            throw new Error("openai-compat: API key required (config.apiKey.openAiCompat or OPENAI_COMPAT_API_KEY).");
+        }
+        if (!baseURL) {
+            throw new Error("openai-compat: base URL required (config.baseUrl.openAiCompat or OPENAI_COMPAT_BASE_URL).");
+        }
+        return { apiKey, baseURL };
+    }
+    resolveCostUsd(usage) {
+        // Try the three common conventions across OpenAI-compatible providers.
+        const c = usage?.cost ?? usage?.estimated_cost ?? usage?.cost_usd;
+        return typeof c === "number" ? c : undefined;
+    }
+}

package/dist/clients/openaiResponses.js

@@ -53,10 +53,11 @@ export class SmolOpenAiResponses extends BaseClient {
     model;
     constructor(config) {
         super(config);
-        if (!config.openAiApiKey) {
+        const apiKey = config.apiKey?.openAi || process.env.OPENAI_API_KEY;
+        if (!apiKey) {
             throw new Error("OpenAI API key is required for SmolOpenAiResponses client.");
         }
-        this.client = new OpenAI({ apiKey: config.openAiApiKey });
+        this.client = new OpenAI({ apiKey });
         this.logger = getLogger();
         this.model = new Model(config.model, undefined, config.modelData);
     }

package/dist/clients/openrouter.d.ts

@@ -0,0 +1,23 @@
+import { SmolOpenAiCompat } from "./openaiCompat.js";
+import type { SmolConfig, HostedToolResult } from "../types.js";
+/**
+ * OpenRouter client (https://openrouter.ai). OpenAI-compatible chat completions.
+ *
+ * - Baked base URL `https://openrouter.ai/api/v1` (override via config.baseUrl.openRouter).
+ * - Key: config.apiKey.openRouter or env OPENROUTER_API_KEY.
+ * - Cost: reads `usage.cost` (USD). OpenRouter only returns this when
+ *   `usage: { include: true }` is set in the request body, which this client
+ *   injects automatically via buildRequestExtras.
+ * - Hosted web_search: when config.hostedTools includes "web_search",
+ *   injects `plugins: [{ id: "web", max_results: 5 }]` and parses
+ *   message.annotations into a HostedToolResult.
+ */
+export declare class SmolOpenRouter extends SmolOpenAiCompat {
+    protected resolveClientOptions(config: SmolConfig): {
+        apiKey: string;
+        baseURL: string;
+    };
+    protected resolveCostUsd(usage: any): number | undefined;
+    protected buildRequestExtras(config: SmolConfig): Record<string, unknown>;
+    protected parseHostedToolResults(completion: any, config: SmolConfig): HostedToolResult[];
+}

package/dist/clients/openrouter.js

@@ -0,0 +1,76 @@
+import { SmolOpenAiCompat } from "./openaiCompat.js";
+import { webSearchResult } from "../util/hostedTools.js";
+import { resolveApiKey, resolveBaseUrl } from "../util/provider.js";
+/**
+ * OpenRouter client (https://openrouter.ai). OpenAI-compatible chat completions.
+ *
+ * - Baked base URL `https://openrouter.ai/api/v1` (override via config.baseUrl.openRouter).
+ * - Key: config.apiKey.openRouter or env OPENROUTER_API_KEY.
+ * - Cost: reads `usage.cost` (USD). OpenRouter only returns this when
+ *   `usage: { include: true }` is set in the request body, which this client
+ *   injects automatically via buildRequestExtras.
+ * - Hosted web_search: when config.hostedTools includes "web_search",
+ *   injects `plugins: [{ id: "web", max_results: 5 }]` and parses
+ *   message.annotations into a HostedToolResult.
+ */
+export class SmolOpenRouter extends SmolOpenAiCompat {
+    resolveClientOptions(config) {
+        const apiKey = resolveApiKey("openrouter", config);
+        // resolveBaseUrl bakes in the openrouter default, so this is always defined.
+        const baseURL = resolveBaseUrl("openrouter", config);
+        if (!apiKey) {
+            throw new Error("openrouter: API key required (config.apiKey.openRouter or OPENROUTER_API_KEY).");
+        }
+        return { apiKey, baseURL };
+    }
+    resolveCostUsd(usage) {
+        return typeof usage?.cost === "number" ? usage.cost : undefined;
+    }
+    buildRequestExtras(config) {
+        // OpenRouter only returns usage.cost when this is set.
+        const extras = { usage: { include: true } };
+        if (config.hostedTools?.includes("web_search")) {
+            extras.plugins = [{ id: "web", max_results: 5 }];
+        }
+        return extras;
+    }
+    parseHostedToolResults(completion, config) {
+        if (!config.hostedTools?.includes("web_search"))
+            return [];
+        const annotations = completion?.choices?.[0]?.message?.annotations;
+        if (!Array.isArray(annotations) || annotations.length === 0)
+            return [];
+        const sources = [];
+        const citations = [];
+        for (const a of annotations) {
+            if (a?.type !== "url_citation" || !a.url_citation?.url)
+                continue;
+            const uc = a.url_citation;
+            const source = {
+                url: uc.url,
+            };
+            if (uc.title)
+                source.title = uc.title;
+            if (uc.content)
+                source.snippet = uc.content;
+            sources.push(source);
+            const citation = { url: uc.url };
+            if (uc.title)
+                citation.title = uc.title;
+            if (typeof uc.start_index === "number")
+                citation.startIndex = uc.start_index;
+            if (typeof uc.end_index === "number")
+                citation.endIndex = uc.end_index;
+            citations.push(citation);
+        }
+        if (sources.length === 0)
+            return [];
+        return [
+            webSearchResult("openrouter", {
+                sources,
+                citations,
+                callCount: 1,
+            }),
+        ];
+    }
+}

package/dist/embed/openai.d.ts

@@ -1,3 +1,9 @@
 import { EmbedConfig, EmbedResult } from "../embed.js";
 import { Result } from "../types/result.js";
-export declare function openaiEmbed(inputs: string[], config: EmbedConfig, apiKey: string): Promise<Result<EmbedResult>>;
+/**
+ * OpenAI-compatible embedding call. Used by openai directly and by other
+ * OpenAI-shape backends (deepinfra, litellm, openai-compat) which pass a
+ * custom `baseURL`. Cost comes from the smoltalk model registry; provider-
+ * returned cost fields aren't standardized on this endpoint.
+ */
+export declare function openaiEmbed(inputs: string[], config: EmbedConfig, apiKey: string, baseURL?: string): Promise<Result<EmbedResult>>;

package/dist/embed/openai.js

@@ -2,9 +2,15 @@ import OpenAI from "openai";
 import { success, failure } from "../types/result.js";
 import { getModel, isEmbeddingsModel } from "../models.js";
 import { round } from "../util/util.js";
-export async function openaiEmbed(inputs, config, apiKey) {
+/**
+ * OpenAI-compatible embedding call. Used by openai directly and by other
+ * OpenAI-shape backends (deepinfra, litellm, openai-compat) which pass a
+ * custom `baseURL`. Cost comes from the smoltalk model registry; provider-
+ * returned cost fields aren't standardized on this endpoint.
+ */
+export async function openaiEmbed(inputs, config, apiKey, baseURL) {
     try {
-        const client = new OpenAI({ apiKey });
+        const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
         const response = await client.embeddings.create({
             model: config.model,
             input: inputs,

package/dist/embed.d.ts

@@ -6,10 +6,24 @@ export type EmbedConfig = {
     model: string;
     provider?: string;
     dimensions?: number;
-    openAiApiKey?: string;
-    googleApiKey?: string;
-    ollamaApiKey?: string;
-    ollamaHost?: string;
+    /** API keys, nested by provider. Falls back to env vars
+     *  (OPENAI_API_KEY / GEMINI_API_KEY / DEEPINFRA_API_KEY /
+     *  LITELLM_API_KEY / OPENAI_COMPAT_API_KEY). */
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        ollama?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    /** Custom base URLs, nested by provider. */
+    baseUrl?: {
+        ollama?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
     metadata?: Record<string, unknown>;
     modelData?: ModelDataBlob;
 };

package/dist/embed.js

@@ -1,5 +1,5 @@
 import { failure } from "./types/result.js";
-import { resolveProvider, resolveApiKey } from "./util/provider.js";
+import { resolveProvider, resolveApiKey, resolveBaseUrl } from "./util/provider.js";
 import { openaiEmbed } from "./embed/openai.js";
 import { googleEmbed } from "./embed/google.js";
 import { ollamaEmbed } from "./embed/ollama.js";
@@ -23,18 +23,46 @@ export async function embed(input, config) {
         case "openai":
         case "openai-responses": {
             if (!apiKey) {
-                return failure("No OpenAI API key provided. Set openAiApiKey in config or the OPENAI_API_KEY environment variable.");
+                return failure("No OpenAI API key provided. Set config.apiKey.openAi or the OPENAI_API_KEY environment variable.");
             }
             return openaiEmbed(inputs, config, apiKey);
         }
         case "google": {
             if (!apiKey) {
-                return failure("No Google API key provided. Set googleApiKey in config or the GEMINI_API_KEY environment variable.");
+                return failure("No Google API key provided. Set config.apiKey.google or the GEMINI_API_KEY environment variable.");
             }
             return googleEmbed(inputs, config, apiKey);
         }
         case "ollama":
-            return ollamaEmbed(inputs, config, apiKey, config.ollamaHost);
+            return ollamaEmbed(inputs, config, apiKey, resolveBaseUrl("ollama", config));
+        case "openrouter":
+            return failure("openrouter does not expose an embeddings endpoint; use deepinfra, openai-compat, or litellm instead.");
+        case "deepinfra": {
+            if (!apiKey) {
+                return failure("No DeepInfra API key provided. Set config.apiKey.deepInfra or the DEEPINFRA_API_KEY environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, resolveBaseUrl("deepinfra", config));
+        }
+        case "litellm": {
+            if (!apiKey) {
+                return failure("No LiteLLM API key provided. Set config.apiKey.liteLlm or the LITELLM_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("litellm", config);
+            if (!baseURL) {
+                return failure("No LiteLLM base URL provided. Set config.baseUrl.liteLlm or the LITELLM_BASE_URL environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, baseURL);
+        }
+        case "openai-compat": {
+            if (!apiKey) {
+                return failure("No openai-compat API key provided. Set config.apiKey.openAiCompat or the OPENAI_COMPAT_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("openai-compat", config);
+            if (!baseURL) {
+                return failure("No openai-compat base URL provided. Set config.baseUrl.openAiCompat or the OPENAI_COMPAT_BASE_URL environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, baseURL);
+        }
         default: {
             const custom = registeredEmbedProviders[provider];
             if (custom) {

package/dist/image/openaiCompat.d.ts

@@ -0,0 +1,9 @@
+import { ImageInput, ImageConfig, ImageGenResult } from "../image.js";
+import { Result } from "../types/result.js";
+/**
+ * Generic OpenAI-compatible image generation. Used by litellm/openai-compat —
+ * any backend that speaks the OpenAI `/images/generations` shape. Image edits
+ * are not supported here (the multipart upload shape varies between backends);
+ * pass a plain prompt only.
+ */
+export declare function openaiCompatImage(input: ImageInput, config: ImageConfig, apiKey: string, baseURL: string): Promise<Result<ImageGenResult>>;

package/dist/image/openaiCompat.js

@@ -0,0 +1,60 @@
+import OpenAI from "openai";
+import { success, failure } from "../types/result.js";
+import { omitUndefined } from "../util/util.js";
+/**
+ * Generic OpenAI-compatible image generation. Used by litellm/openai-compat —
+ * any backend that speaks the OpenAI `/images/generations` shape. Image edits
+ * are not supported here (the multipart upload shape varies between backends);
+ * pass a plain prompt only.
+ */
+export async function openaiCompatImage(input, config, apiKey, baseURL) {
+    try {
+        const normalized = typeof input === "string" ? { prompt: input } : input;
+        const hasImages = !!(normalized.images && normalized.images.length > 0);
+        if (hasImages) {
+            return failure("openai-compat: image edits (passing `images`) are not supported on this generic adapter. Use the `openai` provider for OpenAI image edits.");
+        }
+        if (normalized.mask) {
+            return failure("openai-compat: image masks are not supported on this generic adapter.");
+        }
+        const client = new OpenAI({ apiKey, baseURL });
+        const params = omitUndefined({
+            model: config.model,
+            prompt: normalized.prompt,
+            n: config.n,
+            size: config.size,
+            quality: config.quality,
+            output_format: config.outputFormat,
+            background: config.background,
+            ...(config.metadata ?? {}),
+        });
+        const response = await client.images.generate(params);
+        const mimeType = mimeFromFormat(config.outputFormat) ?? "image/png";
+        const images = (response.data ?? []).map((d) => ({
+            data: new Uint8Array(Buffer.from(d.b64_json, "base64")),
+            mimeType,
+            revisedPrompt: d.revised_prompt,
+        }));
+        return success({
+            images,
+            model: config.model,
+        });
+    }
+    catch (err) {
+        return failure(err instanceof Error
+            ? err.message
+            : "OpenAI-compatible image request failed");
+    }
+}
+function mimeFromFormat(format) {
+    switch (format) {
+        case "png":
+            return "image/png";
+        case "jpeg":
+            return "image/jpeg";
+        case "webp":
+            return "image/webp";
+        default:
+            return undefined;
+    }
+}

package/dist/image.d.ts

@@ -17,8 +17,19 @@ export type ImageConfig = {
     quality?: "low" | "medium" | "high" | "auto";
     outputFormat?: "png" | "jpeg" | "webp";
     background?: "transparent" | "opaque" | "auto";
-    openAiApiKey?: string;
-    googleApiKey?: string;
+    /** API keys, nested by provider. Falls back to env vars
+     *  (OPENAI_API_KEY / GEMINI_API_KEY / LITELLM_API_KEY / OPENAI_COMPAT_API_KEY). */
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    /** Custom base URLs, nested by provider. */
+    baseUrl?: {
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
     metadata?: Record<string, unknown>;
     modelData?: ModelDataBlob;
 };

package/dist/image.js

@@ -1,7 +1,8 @@
 import { failure } from "./types/result.js";
-import { resolveProvider, resolveApiKey } from "./util/provider.js";
+import { resolveProvider, resolveApiKey, resolveBaseUrl } from "./util/provider.js";
 import { openaiImage } from "./image/openai.js";
 import { googleImage } from "./image/google.js";
+import { openaiCompatImage } from "./image/openaiCompat.js";
 // Null-prototype so provider names like "toString"/"__proto__" can't collide
 // with Object.prototype or pollute the registry.
 const registeredImageProviders = Object.create(null);
@@ -27,16 +28,40 @@ export async function image(input, config) {
         case "openai":
         case "openai-responses": {
             if (!apiKey) {
-                return failure("No OpenAI API key provided. Set openAiApiKey in config or the OPENAI_API_KEY environment variable.");
+                return failure("No OpenAI API key provided. Set config.apiKey.openAi or the OPENAI_API_KEY environment variable.");
             }
             return openaiImage(input, config, apiKey);
         }
         case "google": {
             if (!apiKey) {
-                return failure("No Google API key provided. Set googleApiKey in config or the GEMINI_API_KEY environment variable.");
+                return failure("No Google API key provided. Set config.apiKey.google or the GEMINI_API_KEY environment variable.");
             }
             return googleImage(input, config, apiKey);
         }
+        case "openrouter":
+            return failure("openrouter does not expose an OpenAI-compatible images endpoint; use openai-compat or litellm instead.");
+        case "deepinfra":
+            return failure("deepinfra exposes per-model image endpoints rather than the OpenAI `/images/generations` shape; use openai-compat with a specific backend or litellm instead.");
+        case "litellm": {
+            if (!apiKey) {
+                return failure("No LiteLLM API key provided. Set config.apiKey.liteLlm or the LITELLM_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("litellm", config);
+            if (!baseURL) {
+                return failure("No LiteLLM base URL provided. Set config.baseUrl.liteLlm or the LITELLM_BASE_URL environment variable.");
+            }
+            return openaiCompatImage(input, config, apiKey, baseURL);
+        }
+        case "openai-compat": {
+            if (!apiKey) {
+                return failure("No openai-compat API key provided. Set config.apiKey.openAiCompat or the OPENAI_COMPAT_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("openai-compat", config);
+            if (!baseURL) {
+                return failure("No openai-compat base URL provided. Set config.baseUrl.openAiCompat or the OPENAI_COMPAT_BASE_URL environment variable.");
+            }
+            return openaiCompatImage(input, config, apiKey, baseURL);
+        }
         default: {
             const custom = registeredImageProviders[provider];
             if (custom) {

package/dist/models.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { type ModelDataBlob, type HostedTool, type HostedToolPrice } from "./modelData.js";
-export declare const providers: readonly ["ollama", "openai", "openai-responses", "anthropic", "google", "replicate", "modal"];
+export declare const providers: readonly ["ollama", "openai", "openai-responses", "anthropic", "google", "replicate", "modal", "openrouter", "deepinfra", "litellm", "openai-compat"];
 export declare const ProviderSchema: z.ZodEnum<{
     ollama: "ollama";
     openai: "openai";
@@ -9,6 +9,10 @@ export declare const ProviderSchema: z.ZodEnum<{
     google: "google";
     replicate: "replicate";
     modal: "modal";
+    openrouter: "openrouter";
+    deepinfra: "deepinfra";
+    litellm: "litellm";
+    "openai-compat": "openai-compat";
 }>;
 export type Provider = z.infer<typeof ProviderSchema>;
 export type BaseModel = {

package/dist/models.js

@@ -8,6 +8,10 @@ export const providers = [
     "google",
     "replicate",
     "modal",
+    "openrouter",
+    "deepinfra",
+    "litellm",
+    "openai-compat",
 ];
 export const ProviderSchema = z.enum(providers);
 export const speechToTextModels = [
@@ -1557,6 +1561,18 @@ export const hostedTools = [
         models: ["gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3-flash-preview", "gemini-3.5-flash", "gemini-3.1-flash-lite"],
         pricing: { unit: "per_call", note: "Gemini 3 family only; see Google pricing." },
     },
+    {
+        name: "web_search",
+        provider: "openrouter",
+        category: "web_search",
+        description: "Web search via OpenRouter's web plugin (Exa-backed). Adds citations as annotations.",
+        providerToolId: "web",
+        pricing: {
+            unit: "per_call",
+            amount: 0.02,
+            note: "$4 per 1,000 results returned by the web plugin × default 5 results/call = $0.02/call. Plus token cost for inserted context. If you override max_results, scale this accordingly.",
+        },
+    },
 ];
 export const registeredTextModels = [];
 export function registerTextModel(model) {
@@ -1600,9 +1616,16 @@ export function getHostedTools(opts = {}) {
     if (opts.modelData) {
         tools = mergeHostedTools(tools, opts.modelData.hostedTools);
     }
+    // A provider override is authoritative: it decides which API the model routes
+    // through, and therefore which hosted tools are available for it.
     let modelProvider;
     if (opts.model) {
-        modelProvider = getModel(opts.model, opts.modelData)?.provider;
+        if (opts.provider) {
+            modelProvider = opts.provider;
+        }
+        else {
+            modelProvider = getModel(opts.model, opts.modelData)?.provider;
+        }
     }
     return tools.filter((tool) => {
         if (tool.disabled && !opts.includeDisabled) {
@@ -1651,4 +1674,4 @@ export function isEmbeddingsModel(model) {
 }
 export const ModelNameSchema = z
     .string()
-    .regex(/^[a-zA-Z0-9._:-]+$/, "Model name must only contain letters, numbers, dots, underscores, hyphens, and colons");
+    .regex(/^[a-zA-Z0-9._:@/-]+$/, "Model name must only contain letters, numbers, dots, underscores, hyphens, colons, slashes, and @");

package/dist/types.d.ts

@@ -16,16 +16,28 @@ export type SmolConfig = {
     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;
+    /** API keys, nested by provider. Each key falls back to its conventional env var
+     *  if unset (e.g. apiKey.openAi → OPENAI_API_KEY). */
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        anthropic?: string;
+        ollama?: string;
+        openRouter?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    /** Custom base URLs, nested by provider. Defaults are baked in where applicable
+     *  (e.g. openrouter, deepinfra); litellm and openai-compat require an explicit URL. */
+    baseUrl?: {
+        /** Host URL for the Ollama server. Defaults to http://localhost:11434 (or $OLLAMA_HOST). */
+        ollama?: string;
+        openRouter?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
     /** Log level for internal debug logging. */
     logLevel?: LogLevel;
     /** Configuration for Statelog observability/tracing integration. */

package/dist/util/hostedTools.d.ts

@@ -3,7 +3,7 @@ import type { CostEstimate } from "../types/costEstimate.js";
 import type { HostedToolResult, WebSearchSource, WebSearchCitation } from "../types.js";
 export declare const WEB_SEARCH = "web_search";
 export declare const IMPLEMENTED_HOSTED_TOOLS: Set<string>;
-export declare function validateHostedTools(requested: string[] | undefined, model: string, modelData?: ModelDataBlob): string | null;
+export declare function validateHostedTools(requested: string[] | undefined, model: string, provider?: string, modelData?: ModelDataBlob): string | null;
 export declare function estimateHostedToolCost(result: HostedToolResult, model: string, modelData?: ModelDataBlob): number | undefined;
 export declare function foldHostedToolCost(cost: CostEstimate | undefined, results: HostedToolResult[]): CostEstimate | undefined;
 export declare function webSearchResult(provider: string, parts: {

package/dist/util/hostedTools.js

@@ -6,12 +6,15 @@ export const WEB_SEARCH = "web_search";
 export const IMPLEMENTED_HOSTED_TOOLS = new Set([WEB_SEARCH]);
 // Returns an error message if any requested capability is unusable for this
 // model, else null. Capabilities are matched against the catalog `category`.
-export function validateHostedTools(requested, model, modelData) {
+// A `provider` override is authoritative: the same model can route through a
+// different API (e.g. gpt-4o-mini via "openai-responses"), which changes which
+// hosted tools are available.
+export function validateHostedTools(requested, model, provider, modelData) {
     if (!requested || requested.length === 0) {
         return null;
     }
     const allCategories = new Set(getHostedTools({ includeDisabled: true, modelData }).map((t) => t.category));
-    const availableCategories = new Set(getHostedTools({ model, modelData }).map((t) => t.category));
+    const availableCategories = new Set(getHostedTools({ model, provider, modelData }).map((t) => t.category));
     for (const name of requested) {
         if (!IMPLEMENTED_HOSTED_TOOLS.has(name)) {
             if (allCategories.has(name)) {
@@ -20,8 +23,11 @@ export function validateHostedTools(requested, model, modelData) {
             return `Unknown hosted tool "${name}".`;
         }
         if (!availableCategories.has(name)) {
-            const provider = getModel(model, modelData)?.provider ?? "unknown";
-            return `${name} is a hosted capability; ${model} (${provider}) doesn't offer it — pass a search function as a tool instead.`;
+            let effectiveProvider = provider;
+            if (!effectiveProvider) {
+                effectiveProvider = getModel(model, modelData)?.provider ?? "unknown";
+            }
+            return `${name} is a hosted capability; ${model} (${effectiveProvider}) doesn't offer it — pass a search function as a tool instead.`;
         }
     }
     return null;
@@ -32,7 +38,15 @@ export function estimateHostedToolCost(result, model, modelData) {
     if (!result.callCount) {
         return undefined;
     }
-    const tools = getHostedTools({ model, includeDisabled: true, modelData });
+    // The result names the provider that produced it, which may differ from the
+    // model's registered provider (e.g. a base model routed through Responses).
+    // Use it so the catalog lookup isn't filtered out by the wrong provider.
+    const tools = getHostedTools({
+        model,
+        provider: result.provider,
+        includeDisabled: true,
+        modelData,
+    });
     const tool = tools.find((t) => t.category === result.tool && t.provider === result.provider);
     if (!tool) {
         return undefined;

package/dist/util/provider.d.ts

@@ -5,14 +5,40 @@ import type { ModelDataBlob } from "../modelData.js";
  * Otherwise looks up the model in the registry.
  */
 export declare function resolveProvider(modelName: string, explicitProvider?: string, modelData?: ModelDataBlob): string;
-type ApiKeyConfig = {
-    openAiApiKey?: string;
-    googleApiKey?: string;
-    anthropicApiKey?: string;
-    ollamaApiKey?: string;
+/**
+ * Minimal shape needed to read API keys / base URLs. Kept local to avoid
+ * importing SmolConfig (which would create a circular import).
+ */
+type NestedKeyConfig = {
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        anthropic?: string;
+        ollama?: string;
+        openRouter?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    baseUrl?: {
+        ollama?: string;
+        openRouter?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
 };
 /**
  * Resolve the API key for a provider, checking config then env vars.
  */
-export declare function resolveApiKey(provider: string, config: ApiKeyConfig): string | undefined;
+export declare function resolveApiKey(provider: string, config: NestedKeyConfig): string | undefined;
+/**
+ * Resolve the base URL for a provider, checking config then env vars then a
+ * baked-in default. Returns `undefined` when a provider requires the caller to
+ * supply one (litellm, openai-compat) and nothing was given.
+ *
+ * Centralized here so we don't duplicate the env-fallback table across
+ * embed.ts, image.ts, and each client constructor.
+ */
+export declare function resolveBaseUrl(provider: string, config: NestedKeyConfig): string | undefined;
 export {};