smoltalk 0.5.0 → 0.5.1

package/dist/clients/baseClient.js

@@ -56,7 +56,7 @@ export class BaseClient {
         const messageLimitResult = this.checkMessageLimit(promptConfig);
         if (messageLimitResult)
             return messageLimitResult;
-        const hostedError = validateHostedTools(promptConfig.hostedTools, promptConfig.model, promptConfig.modelData);
+        const hostedError = validateHostedTools(promptConfig.hostedTools, promptConfig.model, promptConfig.provider, promptConfig.modelData);
         if (hostedError) {
             return failure(hostedError);
         }
@@ -269,7 +269,7 @@ export class BaseClient {
             };
             return;
         }
-        const hostedError = validateHostedTools(config.hostedTools, config.model, config.modelData);
+        const hostedError = validateHostedTools(config.hostedTools, config.model, config.provider, config.modelData);
         if (hostedError) {
             yield { type: "error", error: hostedError };
             return;

package/dist/models.js

@@ -1600,9 +1600,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) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [