universal-llm-client 4.5.0 → 4.5.2

package/dist/providers/openai.js

@@ -5,12 +5,206 @@
  * Works with: OpenAI, OpenRouter, LM Studio, LlamaCpp, vLLM, Groq, Together.
  */
 import { BaseLLMClient } from '../client.js';
-import { resolveThinking, isOpenAIReasoningModel } from '../thinking.js';
+import { resolveThinking, isOpenAIReasoningModel, supportsChatTemplateKwargs } from '../thinking.js';
 import { httpRequest, httpStream, parseSSE, buildHeaders } from '../http.js';
-import { StandardChatDecoder } from '../stream-decoder.js';
+import { createDecoder, StandardChatDecoder } from '../stream-decoder.js';
 import { normalizeJsonSchema, getJsonSchemaFromConfig, } from '../structured-output.js';
 import { isGemmaDiffusionModel, parseGemmaDiffusionOutput } from '../gemma-diffusion.js';
+const VLLM_AUTO_TOOL_CHOICE_HINT = 'vLLM rejected automatic tool choice. Retrying with text-level tool calling. To use native tool_calls, start vLLM with --enable-auto-tool-choice and --tool-call-parser <parser>.';
+function normalizeMessagesForOpenAICompat(messages) {
+    let sawNonSystem = false;
+    return messages.map(message => {
+        if (message.role !== 'system') {
+            sawNonSystem = true;
+            return {
+                ...message,
+                content: message.content ?? '',
+            };
+        }
+        if (!sawNonSystem) {
+            return {
+                ...message,
+                content: message.content ?? '',
+            };
+        }
+        return {
+            ...message,
+            role: 'user',
+            content: `[SYSTEM MESSAGE]\n${stringifyMessageContent(message.content)}`,
+        };
+    });
+}
+function stringifyMessageContent(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .map(part => {
+        if (part.type === 'text')
+            return part.text;
+        if (part.type === 'image_url')
+            return `[Image: ${part.image_url.url}]`;
+        if (part.type === 'audio')
+            return `[Audio: ${part.audio.mimeType}]`;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function hasToolDefinitions(body) {
+    const tools = body['tools'];
+    return Array.isArray(tools) && tools.length > 0;
+}
+function isVllmAutoToolChoiceError(value) {
+    const text = value instanceof Error
+        ? value.message
+        : typeof value === 'string'
+            ? value
+            : JSON.stringify(value ?? '');
+    const normalized = text.toLowerCase();
+    return (normalized.includes('auto')
+        && normalized.includes('tool choice requires --enable-auto-tool-choice')
+        && normalized.includes('--tool-call-parser'));
+}
+async function requestWithVllmToolFallback(url, request, tools, onFallback) {
+    try {
+        return await httpRequest(url, {
+            method: 'POST',
+            headers: request.headers,
+            body: request.body,
+            timeout: request.timeout,
+        });
+    }
+    catch (error) {
+        if (tools?.length
+            && hasToolDefinitions(request.body)
+            && isVllmAutoToolChoiceError(error)) {
+            onFallback();
+            return httpRequest(url, {
+                method: 'POST',
+                headers: request.headers,
+                body: withoutNativeTools(request.body, tools),
+                timeout: request.timeout,
+            });
+        }
+        throw error;
+    }
+}
+function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        /* not JSON */
+    }
+    return null;
+}
+function parseTextToolCallBody(content) {
+    const body = content.trim();
+    if (!body)
+        return [];
+    try {
+        const parsed = JSON.parse(body);
+        const rawCalls = Array.isArray(parsed) ? parsed : [parsed];
+        const calls = [];
+        for (const rawCall of rawCalls) {
+            if (!rawCall || typeof rawCall !== 'object')
+                continue;
+            const record = rawCall;
+            const name = record['name'];
+            if (typeof name !== 'string' || !name)
+                continue;
+            const args = record['arguments'] ?? record['parameters'] ?? record['args'] ?? {};
+            calls.push({
+                name,
+                arguments: typeof args === 'string' ? JSON.stringify(parseJsonObject(args) ?? {}) : JSON.stringify(args ?? {}),
+            });
+        }
+        if (calls.length > 0)
+            return calls;
+    }
+    catch {
+        /* not structured JSON */
+    }
+    const functionCallMatch = /^([@A-Za-z_][@A-Za-z0-9_.:-]*)\s*\(([\s\S]*)\)\s*$/u.exec(body);
+    if (functionCallMatch) {
+        const rawArgs = functionCallMatch[2].trim();
+        const args = rawArgs ? parseJsonObject(rawArgs) : {};
+        if (args) {
+            return [{ name: functionCallMatch[1], arguments: JSON.stringify(args) }];
+        }
+    }
+    const calls = [];
+    const funcPattern = /<function=([@A-Za-z_][@A-Za-z0-9_.:-]*)>([\s\S]*?)<\/function>/g;
+    let fMatch;
+    while ((fMatch = funcPattern.exec(body)) !== null) {
+        const args = {};
+        const paramPattern = /<parameter=([A-Za-z_][A-Za-z0-9_-]*)>([\s\S]*?)<\/parameter>/g;
+        let pMatch;
+        while ((pMatch = paramPattern.exec(fMatch[2] ?? '')) !== null) {
+            args[pMatch[1]] = pMatch[2].trim();
+        }
+        calls.push({ name: fMatch[1], arguments: JSON.stringify(args) });
+    }
+    return calls;
+}
+function recoverToolCallsFromText(content, knownToolNames, generateId) {
+    if (!content || content.length < 10)
+        return null;
+    const calls = [];
+    let cleanContent = content;
+    const isKnownTool = (name) => knownToolNames.has(name);
+    const toolCallPattern = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+    let tcMatch;
+    while ((tcMatch = toolCallPattern.exec(content)) !== null) {
+        const parsedCalls = parseTextToolCallBody(tcMatch[1]);
+        let matched = false;
+        for (const parsed of parsedCalls) {
+            if (!isKnownTool(parsed.name))
+                continue;
+            matched = true;
+            calls.push({
+                id: generateId(),
+                type: 'function',
+                function: { name: parsed.name, arguments: parsed.arguments },
+            });
+        }
+        if (matched)
+            cleanContent = cleanContent.replace(tcMatch[0], '');
+    }
+    if (calls.length === 0)
+        return null;
+    return { calls, cleanContent: cleanContent.trim() };
+}
+function toolFallbackInstruction(tools) {
+    const toolLines = tools.map(tool => {
+        const fn = tool.function;
+        return `- ${fn.name}: ${fn.description}\n  parameters JSON schema: ${JSON.stringify(fn.parameters)}`;
+    });
+    return {
+        role: 'system',
+        content: 'The server does not support native OpenAI tool parsing for this request. '
+            + 'Use this text tool protocol instead.\n\n'
+            + 'When you need a tool, respond with exactly one or more tool calls and no prose:\n'
+            + '<tool_call>tool_name({"argument":"value"})</tool_call>\n\n'
+            + 'After tool results are provided, answer the user normally. Available tools:\n'
+            + toolLines.join('\n'),
+    };
+}
+function withTextToolFallbackMessages(messages, tools) {
+    return [toolFallbackInstruction(tools), ...messages];
+}
+function withoutNativeTools(body, tools) {
+    const fallbackBody = { ...body };
+    delete fallbackBody['tools'];
+    delete fallbackBody['tool_choice'];
+    fallbackBody['messages'] = withTextToolFallbackMessages(body['messages'] ?? [], tools);
+    return fallbackBody;
+}
 export class OpenAICompatibleClient extends BaseLLMClient {
+    warnedVllmToolFallback = false;
     /**
      * DiffusionGemma on trimmed vLLM builds has no server-side reasoning or
      * tool-call parser — the native channel protocol is handled client-side
@@ -60,13 +254,19 @@ export class OpenAICompatibleClient extends BaseLLMClient {
         }
         super({ ...options, url: base }, auditor);
     }
+    warnVllmToolFallback() {
+        if (this.warnedVllmToolFallback)
+            return;
+        this.warnedVllmToolFallback = true;
+        console.warn(`[OpenAI] ${VLLM_AUTO_TOOL_CHOICE_HINT}`);
+    }
     // ========================================================================
     // Chat
     // ========================================================================
     async chat(messages, options) {
         // Structured output and tools can now be used together.\n        // The provider sends both response_format and tools in the request.\n        // The Router handles skipping validation when the response contains tool calls.
         const url = this.buildUrl('/chat/completions');
-        const tools = options?.tools ?? (Object.keys(this.toolRegistry).length > 0 ? this.getToolDefinitions() : undefined);
+        const tools = options?.tools;
         const body = {
             model: this.options.model,
             messages: this.convertMessages(messages),
@@ -100,12 +300,11 @@ export class OpenAICompatibleClient extends BaseLLMClient {
             provider: 'openai',
             model: this.options.model,
         });
-        const response = await httpRequest(url, {
-            method: 'POST',
+        const response = await requestWithVllmToolFallback(url, {
             headers: buildHeaders(this.options),
             body,
             timeout: this.options.timeout ?? 30000,
-        });
+        }, tools, () => this.warnVllmToolFallback());
         const data = response.data;
         const choice = data.choices[0];
         if (!choice) {
@@ -152,6 +351,14 @@ export class OpenAICompatibleClient extends BaseLLMClient {
                 }));
             }
         }
+        if (!toolCalls?.length && tools?.length && content) {
+            const knownToolNames = new Set(tools.map(tool => tool.function.name));
+            const recovered = recoverToolCallsFromText(content, knownToolNames, () => this.generateToolCallId());
+            if (recovered) {
+                toolCalls = recovered.calls;
+                content = recovered.cleanContent;
+            }
+        }
         const result = {
             message: {
                 role: 'assistant',
@@ -177,7 +384,7 @@ export class OpenAICompatibleClient extends BaseLLMClient {
     // ========================================================================
     async *chatStream(messages, options) {
         const url = this.buildUrl('/chat/completions');
-        const tools = options?.tools ?? (Object.keys(this.toolRegistry).length > 0 ? this.getToolDefinitions() : undefined);
+        const tools = options?.tools;
         const body = {
             model: this.options.model,
             messages: this.convertMessages(messages),
@@ -202,91 +409,118 @@ export class OpenAICompatibleClient extends BaseLLMClient {
             provider: 'openai',
             model: this.options.model,
         });
-        // In gemma-native mode the decoder classifies thought-channel content,
-        // so we yield ITS events (thinking vs text) instead of the raw deltas.
+        // In gemma-native mode, or when a caller selects an explicit decoder,
+        // the decoder classifies content into typed events instead of exposing
+        // raw deltas with protocol tags still attached.
         const decoderEvents = [];
-        const decoder = new StandardChatDecoder(this.gemmaNative ? e => decoderEvents.push(e) : () => { });
+        const decoderOption = options?.decoder;
+        const decoderInstanceProvided = Boolean(decoderOption && typeof decoderOption === 'object');
+        const yieldDecoderEvents = !decoderInstanceProvided && (this.gemmaNative || typeof decoderOption === 'string');
+        const decoder = typeof decoderOption === 'string'
+            ? createDecoder(decoderOption, e => decoderEvents.push(e))
+            : decoderInstanceProvided
+                ? decoderOption
+                : new StandardChatDecoder(this.gemmaNative ? e => decoderEvents.push(e) : () => { });
         // Track accumulated tool calls across chunks
         const toolCallAccum = new Map();
-        const stream = httpStream(url, {
-            method: 'POST',
-            headers: buildHeaders(this.options),
-            body,
-            timeout: this.options.timeout ?? 120000,
-        });
+        let activeBody = body;
+        let retriedWithTextTools = false;
         let usage;
         // Accumulates reasoning deltas from servers that stream a dedicated
         // `reasoning` / `reasoning_content` field (vLLM, DeepSeek-R1, etc.).
         let reasoningBuffer = '';
-        for await (const { data } of parseSSE(stream)) {
+        while (true) {
+            const stream = httpStream(url, {
+                method: 'POST',
+                headers: buildHeaders(this.options),
+                body: activeBody,
+                timeout: this.options.timeout ?? 120000,
+            });
             try {
-                const parsed = JSON.parse(data);
-                if (parsed.usage) {
-                    usage = {
-                        inputTokens: parsed.usage.prompt_tokens,
-                        outputTokens: parsed.usage.completion_tokens,
-                        totalTokens: parsed.usage.total_tokens,
-                        cachedTokens: parsed.usage.prompt_tokens_details?.cached_tokens,
-                    };
-                }
-                const delta = parsed.choices?.[0]?.delta;
-                if (!delta)
-                    continue;
-                // Surface server-side reasoning deltas as thinking events.
-                const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
-                if (reasoningDelta) {
-                    reasoningBuffer += reasoningDelta;
-                    yield { type: 'thinking', content: reasoningDelta };
-                }
-                if (delta.content) {
-                    decoder.push(delta.content);
-                    if (this.gemmaNative) {
-                        while (decoderEvents.length)
-                            yield decoderEvents.shift();
-                    }
-                    else {
-                        yield { type: 'text', content: delta.content };
-                    }
-                }
-                // Accumulate streamed tool calls
-                if (delta.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                        const existing = toolCallAccum.get(tc.index);
-                        if (!existing) {
-                            toolCallAccum.set(tc.index, {
-                                id: tc.id || this.generateToolCallId(),
-                                type: 'function',
-                                function: {
-                                    name: tc.function?.name || '',
-                                    arguments: tc.function?.arguments || '',
-                                },
-                            });
+                for await (const { data } of parseSSE(stream)) {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.usage) {
+                            usage = {
+                                inputTokens: parsed.usage.prompt_tokens,
+                                outputTokens: parsed.usage.completion_tokens,
+                                totalTokens: parsed.usage.total_tokens,
+                                cachedTokens: parsed.usage.prompt_tokens_details?.cached_tokens,
+                            };
                         }
-                        else {
-                            if (tc.function?.arguments) {
-                                existing.function.arguments += tc.function.arguments;
+                        const delta = parsed.choices?.[0]?.delta;
+                        if (!delta)
+                            continue;
+                        // Surface server-side reasoning deltas as thinking events.
+                        const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
+                        if (reasoningDelta) {
+                            reasoningBuffer += reasoningDelta;
+                            yield { type: 'thinking', content: reasoningDelta };
+                        }
+                        if (delta.content) {
+                            decoder.push(delta.content);
+                            if (yieldDecoderEvents) {
+                                while (decoderEvents.length)
+                                    yield decoderEvents.shift();
+                            }
+                            else {
+                                yield { type: 'text', content: delta.content };
                             }
-                            if (tc.function?.name) {
-                                existing.function.name += tc.function.name;
+                        }
+                        // Accumulate streamed tool calls
+                        if (delta.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const existing = toolCallAccum.get(tc.index);
+                                if (!existing) {
+                                    toolCallAccum.set(tc.index, {
+                                        id: tc.id || this.generateToolCallId(),
+                                        type: 'function',
+                                        function: {
+                                            name: tc.function?.name || '',
+                                            arguments: tc.function?.arguments || '',
+                                        },
+                                    });
+                                }
+                                else {
+                                    if (tc.function?.arguments) {
+                                        existing.function.arguments += tc.function.arguments;
+                                    }
+                                    if (tc.function?.name) {
+                                        existing.function.name += tc.function.name;
+                                    }
+                                }
+                            }
+                        }
+                        // Emit tool calls when stream finishes
+                        if (parsed.choices?.[0]?.finish_reason === 'tool_calls' || parsed.choices?.[0]?.finish_reason === 'stop') {
+                            if (toolCallAccum.size > 0) {
+                                const calls = Array.from(toolCallAccum.values())
+                                    .map(tc => this.normalizeToolCall(tc));
+                                yield { type: 'tool_call', calls };
                             }
                         }
                     }
-                }
-                // Emit tool calls when stream finishes
-                if (parsed.choices?.[0]?.finish_reason === 'tool_calls' || parsed.choices?.[0]?.finish_reason === 'stop') {
-                    if (toolCallAccum.size > 0) {
-                        const calls = Array.from(toolCallAccum.values())
-                            .map(tc => this.normalizeToolCall(tc));
-                        yield { type: 'tool_call', calls };
+                    catch {
+                        // Skip unparseable SSE data
                     }
                 }
+                break;
             }
-            catch {
-                // Skip unparseable SSE data
+            catch (error) {
+                if (!retriedWithTextTools
+                    && tools?.length
+                    && hasToolDefinitions(activeBody)
+                    && isVllmAutoToolChoiceError(error)) {
+                    this.warnVllmToolFallback();
+                    activeBody = withoutNativeTools(activeBody, tools);
+                    retriedWithTextTools = true;
+                    continue;
+                }
+                throw error;
             }
         }
         decoder.flush();
-        if (this.gemmaNative) {
+        if (yieldDecoderEvents) {
             while (decoderEvents.length)
                 yield decoderEvents.shift();
         }
@@ -332,6 +566,15 @@ export class OpenAICompatibleClient extends BaseLLMClient {
                 yield { type: 'tool_call', calls: finalToolCalls };
             }
         }
+        if (!finalToolCalls?.length && tools?.length && cleanContent) {
+            const knownToolNames = new Set(tools.map(tool => tool.function.name));
+            const recovered = recoverToolCallsFromText(cleanContent, knownToolNames, () => this.generateToolCallId());
+            if (recovered) {
+                finalToolCalls = recovered.calls;
+                cleanContent = recovered.cleanContent;
+                yield { type: 'tool_call', calls: finalToolCalls };
+            }
+        }
         return {
             message: {
                 role: 'assistant',
@@ -400,12 +643,7 @@ export class OpenAICompatibleClient extends BaseLLMClient {
     // Internals
     // ========================================================================
     convertMessages(messages) {
-        // OpenAI format is our canonical format, minimal conversion needed
-        return messages.map(msg => ({
-            ...msg,
-            // Ensure content is never null/undefined
-            content: msg.content ?? '',
-        }));
+        return normalizeMessagesForOpenAICompat(messages);
     }
     buildRequestParams(options) {
         const params = {
@@ -423,16 +661,16 @@ export class OpenAICompatibleClient extends BaseLLMClient {
         // A user-supplied value (via parameters) always wins.
         const thinking = resolveThinking(options?.thinking, this.options.thinking);
         if (thinking) {
-            const isOfficialOpenAI = (this.options.url ?? '').includes('api.openai.com');
             if (isOpenAIReasoningModel(this.options.model)) {
                 if (params['reasoning_effort'] === undefined) {
                     params['reasoning_effort'] = thinking.enabled ? (thinking.level ?? 'medium') : 'minimal';
                 }
             }
-            else if (!isOfficialOpenAI) {
-                // `chat_template_kwargs` is a vLLM/Qwen extension. Official OpenAI
-                // rejects unknown body fields (and gpt-4o has no thinking toggle),
-                // so only send it to self-hosted / compatible gateways.
+            else if (supportsChatTemplateKwargs(this.options.url)) {
+                // `chat_template_kwargs` is a self-hosted vLLM/Qwen extension.
+                // Official OpenAI and hosted OpenAI-compatible gateways (Cerebras,
+                // Groq, Fireworks, …) reject unknown body fields with HTTP 400,
+                // so only send it to endpoints not on the strict-host list.
                 const existing = params['chat_template_kwargs'] ?? {};
                 params['chat_template_kwargs'] = { enable_thinking: thinking.enabled, ...existing };
             }
@@ -478,4 +716,3 @@ export class OpenAICompatibleClient extends BaseLLMClient {
         };
     }
 }
-//# sourceMappingURL=openai.js.map

package/dist/router.d.ts

@@ -136,4 +136,3 @@ export declare class Router {
     private recordSuccess;
     private recordFailure;
 }
-//# sourceMappingURL=router.d.ts.map

package/dist/router.js

@@ -580,4 +580,3 @@ export class Router {
         }
     }
 }
-//# sourceMappingURL=router.js.map

package/dist/stream-decoder.d.ts

@@ -148,4 +148,3 @@ export declare function getRegisteredDecoders(): string[];
  * @throws Error if the decoder type is not registered
  */
 export declare function createDecoder(type: DecoderType | string, callback: DecoderCallback, options?: DecoderOptions): StreamDecoder;
-//# sourceMappingURL=stream-decoder.d.ts.map

package/dist/stream-decoder.js

@@ -440,4 +440,3 @@ export function createDecoder(type, callback, options) {
     }
     return factory(callback, options);
 }
-//# sourceMappingURL=stream-decoder.js.map

package/dist/structured-output.d.ts

@@ -390,4 +390,3 @@ export interface StreamingStructuredResult<T> {
     /** The validated partial or complete object */
     value: T;
 }
-//# sourceMappingURL=structured-output.d.ts.map

package/dist/structured-output.js

@@ -447,4 +447,3 @@ export class StreamingJsonParser {
         return undefined;
     }
 }
-//# sourceMappingURL=structured-output.js.map

package/dist/thinking.d.ts

@@ -23,6 +23,18 @@ export interface ResolvedThinking {
 export declare function resolveThinking(perCall: boolean | ThinkingLevel | undefined, config: boolean | ThinkingLevel | undefined): ResolvedThinking | undefined;
 /** Heuristic: OpenAI reasoning models use `reasoning_effort` (o-series, GPT-5). */
 export declare function isOpenAIReasoningModel(model: string): boolean;
+/**
+ * Whether an OpenAI-compatible endpoint accepts the vLLM/SGLang
+ * `chat_template_kwargs` extension (used to toggle `enable_thinking`).
+ *
+ * This is a self-hosted-server feature. Commercial hosted gateways that expose
+ * an OpenAI-compatible surface (OpenAI, Cerebras, Groq, Fireworks, Together,
+ * Mistral, DeepSeek, OpenRouter, …) reject unknown body fields, so we only send
+ * it to endpoints not on the strict list (assumed self-hosted vLLM/Qwen). When
+ * the URL is unknown/empty we default to permissive (self-hosted) behavior to
+ * preserve the prior contract for local servers.
+ */
+export declare function supportsChatTemplateKwargs(url: string | undefined): boolean;
 /**
  * Gemini 2.5 `thinkingBudget` for a level. 0 disables, -1 is dynamic, and the
  * Flash range is 0–24576. A bare `true` (no level) maps to dynamic (-1).
@@ -33,4 +45,3 @@ export declare function geminiThinkingBudget(level: ThinkingLevel | undefined):
  * API minimum) and < `maxTokens` (the API requires headroom for the answer).
  */
 export declare function anthropicThinkingBudget(level: ThinkingLevel | undefined, maxTokens: number): number;
-//# sourceMappingURL=thinking.d.ts.map

package/dist/thinking.js

@@ -24,6 +24,40 @@ export function resolveThinking(perCall, config) {
 export function isOpenAIReasoningModel(model) {
     return /^(o\d|gpt-5)/i.test(model);
 }
+/**
+ * Hosted, OpenAI-*compatible* gateways that validate the request body strictly
+ * and reject unknown fields with HTTP 400 — just like official OpenAI. The
+ * `chat_template_kwargs` knob (below) is a self-hosted vLLM/SGLang extension and
+ * must NOT be sent to these. Matched as case-insensitive host substrings.
+ */
+const STRICT_OPENAI_COMPAT_HOSTS = [
+    'api.openai.com',
+    'api.cerebras.ai',
+    'api.groq.com',
+    'api.fireworks.ai',
+    'api.together.xyz',
+    'api.together.ai',
+    'api.mistral.ai',
+    'api.deepseek.com',
+    'api.perplexity.ai',
+    'openrouter.ai',
+    'api.x.ai',
+];
+/**
+ * Whether an OpenAI-compatible endpoint accepts the vLLM/SGLang
+ * `chat_template_kwargs` extension (used to toggle `enable_thinking`).
+ *
+ * This is a self-hosted-server feature. Commercial hosted gateways that expose
+ * an OpenAI-compatible surface (OpenAI, Cerebras, Groq, Fireworks, Together,
+ * Mistral, DeepSeek, OpenRouter, …) reject unknown body fields, so we only send
+ * it to endpoints not on the strict list (assumed self-hosted vLLM/Qwen). When
+ * the URL is unknown/empty we default to permissive (self-hosted) behavior to
+ * preserve the prior contract for local servers.
+ */
+export function supportsChatTemplateKwargs(url) {
+    const u = (url ?? '').toLowerCase();
+    return !STRICT_OPENAI_COMPAT_HOSTS.some((host) => u.includes(host));
+}
 /**
  * Gemini 2.5 `thinkingBudget` for a level. 0 disables, -1 is dynamic, and the
  * Flash range is 0–24576. A bare `true` (no level) maps to dynamic (-1).
@@ -49,4 +83,3 @@ export function anthropicThinkingBudget(level, maxTokens) {
                     : 2048; // bare `true`
     return Math.max(1024, Math.min(base, maxTokens - 1024));
 }
-//# sourceMappingURL=thinking.js.map

package/dist/tools.d.ts

@@ -75,4 +75,3 @@ export declare function createRandomNumberTool(): {
     parameters: LLMFunction['parameters'];
     handler: ToolHandler;
 };
-//# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -204,4 +204,3 @@ export function createRandomNumberTool() {
         },
     };
 }
-//# sourceMappingURL=tools.js.map

package/dist/zod-adapter.d.ts

@@ -41,4 +41,3 @@ export declare function fromZod<T>(schema: z.ZodType<T>, options?: {
 }): SchemaConfig<T>;
 export { z } from 'zod';
 export type { SchemaConfig } from './structured-output.js';
-//# sourceMappingURL=zod-adapter.d.ts.map

package/dist/zod-adapter.js

@@ -58,4 +58,3 @@ export function fromZod(schema, options) {
 }
 // Re-export z for convenience (users importing from /zod likely want it)
 export { z } from 'zod';
-//# sourceMappingURL=zod-adapter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-llm-client",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "type": "module",
   "description": "A universal LLM client with transparent provider failover, streaming tool execution, pluggable reasoning, and native observability.",
   "main": "./dist/index.js",
@@ -41,7 +41,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"

package/dist/ai-model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-model.d.ts","sourceRoot":"","sources":["../src/ai-model.ts"],"names":[],"mappings":"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"}