@prismshadow/mmsp 0.5.0

package/dist/openai_chat/client.js

@@ -0,0 +1,419 @@
+"use strict";
+// Copyright 2025 Prism Shadow. and/or its affiliates
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiChatClient = void 0;
+const openai_1 = __importDefault(require("openai"));
+const path = __importStar(require("path"));
+const baseClient_1 = require("../baseClient");
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+/**
+ * OpenAI Chat Completions-compatible client implementation.
+ */
+class OpenaiChatClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize OpenAI-compatible chat client with model, API key, and base URL.
+     */
+    constructor(options) {
+        super();
+        this._model = options.model;
+        const { apiKey: key, baseUrl: url } = (0, utils_1.resolveCredentials)(this.constructor.name, options, { key: "OPENAI_API_KEY", baseUrl: "OPENAI_BASE_URL" });
+        this._client = new openai_1.default({
+            apiKey: key,
+            baseURL: url,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    /**
+     * Detect MIME type from URL extension for image.
+     */
+    _detectImageMimeType(url) {
+        const ext = path.extname(url).toLowerCase();
+        const mimeTypes = {
+            ".bmp": "image/bmp",
+            ".gif": "image/gif",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".svg": "image/svg+xml",
+            ".tiff": "image/tiff",
+            ".webp": "image/webp",
+        };
+        return mimeTypes[ext] || "image/jpeg";
+    }
+    /**
+     * Convert image URL to base64-encoded data URL.
+     */
+    async _convertImageUrlToBase64(url, signal) {
+        if (url.startsWith("data:")) {
+            return url;
+        }
+        const response = await fetch(url, { signal });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const mimeType = this._detectImageMimeType(url);
+        const base64String = buffer.toString("base64");
+        return `data:${mimeType};base64,${base64String}`;
+    }
+    /**
+     * Convert ToolChoice to OpenAI Chat Completions tool_choice format.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertToolChoice(toolChoice) {
+        if (Array.isArray(toolChoice)) {
+            return {
+                type: "allowed_tools",
+                allowed_tools: {
+                    mode: "auto",
+                    tools: toolChoice.map((name) => ({
+                        type: "function",
+                        function: { name },
+                    })),
+                },
+            };
+        }
+        return toolChoice;
+    }
+    /**
+     * Convert a fetched image to an image_url part, at the detail the API needs
+     * to read it.
+     */
+    _convertImageUrl(dataUrl) {
+        const detail = (0, utils_1.openaiImageDetail)(this._model, dataUrl);
+        return detail
+            ? { type: "image_url", image_url: { url: dataUrl, detail } }
+            : { type: "image_url", image_url: { url: dataUrl } };
+    }
+    /**
+     * Transform universal configuration to OpenAI Chat Completions configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const openaiConfig = {
+            model: this._model,
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (config.max_tokens !== undefined) {
+            openaiConfig.max_completion_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined) {
+            openaiConfig.temperature = config.temperature;
+        }
+        if (config.tools !== undefined) {
+            openaiConfig.tools = config.tools.map((tool) => ({
+                type: "function",
+                function: tool,
+            }));
+        }
+        if (config.tool_choice !== undefined) {
+            openaiConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            openaiConfig.service_tier = "priority";
+        }
+        if (config.prompt_caching !== undefined &&
+            config.prompt_caching !== types_1.PromptCaching.ENABLE) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "prompt_caching",
+                message: "prompt_caching must be ENABLE for OpenAI.",
+            });
+        }
+        return openaiConfig;
+    }
+    /**
+     * Transform universal message format to OpenAI Chat Completions message format.
+     */
+    async transformUniMessageToModelInput(messages, signal) {
+        const openaiMessages = [];
+        // The reasoning field this upstream has produced so far, if any. A turn the model answered
+        // without thinking still has to carry that field, empty, when it made tool calls: DeepSeek
+        // stops thinking part-way through a long tool chain, and then rejects the replay of that
+        // turn with "the reasoning_content in the thinking mode must be passed back to the API".
+        // It waives that only for tool_call ids it issued itself, which a relay that reissues ids
+        // takes away. A conversation that never produced a reasoning field never receives one.
+        const replayFields = new Set();
+        for (const msg of messages) {
+            const contentParts = [];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const toolCalls = [];
+            let thinking = "";
+            const thinkingFields = new Set();
+            for (const item of msg.content_items) {
+                if (item.type === "text.done") {
+                    contentParts.push({ type: "text", text: item.text });
+                }
+                else if (item.type === "image_url.done") {
+                    const base64Image = await this._convertImageUrlToBase64(item.image_url, signal);
+                    contentParts.push(this._convertImageUrl(base64Image));
+                }
+                else if (item.type === "thinking.done") {
+                    thinking += item.thinking;
+                    thinkingFields.add(item.fidelity?.reasoning_field);
+                    if (item.thinking)
+                        replayFields.add(item.fidelity?.reasoning_field);
+                }
+                else if (item.type === "tool_call.done") {
+                    toolCalls.push({
+                        id: item.tool_call_id,
+                        type: "function",
+                        function: {
+                            name: item.name,
+                            arguments: JSON.stringify(item.arguments, null, 0),
+                        },
+                    });
+                }
+                else if (item.type === "tool_result.done") {
+                    if (!item.tool_call_id) {
+                        throw new Error("tool_call_id is required for tool result.");
+                    }
+                    // Chat Completions lets a tool message carry text only, and a server that
+                    // validates the schema rejects the whole request over an image part in one.
+                    // The images ride in the user message that follows the turn's tool messages,
+                    // the one place every OpenAI-compatible server reads them.
+                    if (item.images && item.images.length > 0) {
+                        for (const imageUrl of item.images) {
+                            const base64Image = await this._convertImageUrlToBase64(imageUrl, signal);
+                            contentParts.push(this._convertImageUrl(base64Image));
+                        }
+                    }
+                    // the plain string is the form every OpenAI-compatible server accepts
+                    openaiMessages.push({
+                        role: "tool",
+                        tool_call_id: item.tool_call_id,
+                        content: item.text,
+                    });
+                }
+                else {
+                    throw new Error(`Unknown item type: ${item.type}`);
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const message = { role: msg.role };
+            if (contentParts.length > 0) {
+                message.content = contentParts;
+            }
+            if (toolCalls.length > 0) {
+                message.tool_calls = toolCalls;
+            }
+            // This turn's own fidelity when it thought; otherwise the field the upstream has
+            // produced, with `thinking` still "" — the empty value is what keeps the turn replayable.
+            const fields = thinking ? thinkingFields : replayFields;
+            if (thinking || (toolCalls.length > 0 && replayFields.size > 0)) {
+                // send thinking back through the exact field the upstream produced (recorded
+                // in the item fidelity); servers may reject the spelling they did not emit
+                if (fields.size === 1 && fields.has("reasoning_content")) {
+                    message.reasoning_content = thinking;
+                }
+                else if (fields.size === 1 && fields.has("reasoning")) {
+                    message.reasoning = thinking;
+                }
+                else {
+                    message.reasoning_content = thinking; // vLLM & siliconflow compatibility
+                    message.reasoning = thinking; // openrouter compatibility
+                }
+            }
+            if (Object.keys(message).length > 1) {
+                openaiMessages.push(message);
+            }
+        }
+        return openaiMessages;
+    }
+    /**
+     * Transform one OpenAI Chat Completions streaming chunk into a universal event.
+     *
+     * Chat Completions gives an item no identity, so each delta's item_id is the wire field
+     * that carried it: an item runs until a delta arrives from another field, or names the next
+     * tool call.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        let eventType = "delta";
+        const contentItems = [];
+        let usageMetadata = null;
+        let finishReason = null;
+        // gateways inject content-free heartbeat chunks on long generations, whose
+        // choices arrive as undefined rather than an empty list
+        if (modelOutput.choices?.length) {
+            const choice = modelOutput.choices[0];
+            const delta = choice?.delta;
+            // the thinking field name differs by server: vLLM & siliconflow use
+            // reasoning_content while openrouter uses reasoning; record the wire
+            // field that carried each delta so a replay can reproduce exactly the
+            // field the upstream produced. The reasoning goes before the content
+            // because a chunk may end the reasoning and begin the answer.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reasoningContent = delta?.reasoning_content;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reasoning = delta?.reasoning;
+            if (reasoningContent && reasoning) {
+                // ambiguous origin: record no reasoning_field so a replay sends both fields back
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: reasoningContent,
+                    fidelity: { item_id: "reasoning_content" },
+                });
+            }
+            else if (reasoningContent) {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: reasoningContent,
+                    fidelity: {
+                        item_id: "reasoning_content",
+                        reasoning_field: "reasoning_content",
+                    },
+                });
+            }
+            else if (reasoning) {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: reasoning,
+                    fidelity: { item_id: "reasoning", reasoning_field: "reasoning" },
+                });
+            }
+            if (delta?.content) {
+                contentItems.push({
+                    type: "text.delta",
+                    text: delta.content,
+                    fidelity: { item_id: "content" },
+                });
+            }
+            if (delta?.tool_calls) {
+                for (const toolCall of delta.tool_calls) {
+                    contentItems.push({
+                        type: "tool_call.delta",
+                        name: toolCall.function?.name || "",
+                        arguments: toolCall.function?.arguments || "",
+                        tool_call_id: toolCall.id || toolCall.function?.name || "",
+                        fidelity: { item_id: "tool_calls" },
+                    });
+                }
+            }
+            if (choice?.finish_reason) {
+                eventType = "stop";
+                const finishReasonMapping = {
+                    stop: "stop",
+                    length: "length",
+                    tool_calls: "tool_call",
+                    content_filter: "stop",
+                };
+                finishReason = finishReasonMapping[choice.finish_reason] || "unknown";
+            }
+        }
+        if (modelOutput.usage) {
+            eventType = "stop";
+            const cachedTokens = modelOutput.usage.prompt_tokens_details?.cached_tokens || null;
+            const reasoningTokens = modelOutput.usage.completion_tokens_details?.reasoning_tokens || null;
+            const promptTokens = cachedTokens !== null
+                ? modelOutput.usage.prompt_tokens - cachedTokens
+                : modelOutput.usage.prompt_tokens;
+            const responseTokens = reasoningTokens !== null
+                ? modelOutput.usage.completion_tokens - reasoningTokens
+                : modelOutput.usage.completion_tokens;
+            usageMetadata = {
+                cached_tokens: cachedTokens,
+                prompt_tokens: promptTokens,
+                thoughts_tokens: reasoningTokens,
+                response_tokens: responseTokens,
+            };
+            usageMetadata = (0, utils_1.fixOpenrouterUsageMetadata)(usageMetadata, this._client.baseURL);
+        }
+        return {
+            role: "assistant",
+            event_type: eventType,
+            content_items: contentItems,
+            usage_metadata: usageMetadata,
+            finish_reason: finishReason,
+        };
+    }
+    /**
+     * Stream generate using OpenAI Chat Completions-compatible API.
+     */
+    async *_streamingResponseInternal(options) {
+        const openaiConfig = this.transformUniConfigToModelConfig(options.config);
+        const openaiMessages = await this.transformUniMessageToModelInput(options.messages, options.signal);
+        if (options.config.system_prompt) {
+            openaiMessages.unshift({
+                role: "system",
+                content: options.config.system_prompt,
+            });
+        }
+        const params = {
+            ...openaiConfig,
+            messages: openaiMessages,
+            stream: true,
+        };
+        const stream = await this._client.chat.completions.create(params, {
+            signal: options.signal,
+        });
+        for await (const chunk of stream) {
+            yield this.transformModelOutputToUniEvent(chunk);
+        }
+    }
+    /**
+     * List the model ids the configured endpoint serves.
+     *
+     * @returns The model ids, in the order the endpoint returned them.
+     */
+    async listModels() {
+        const models = [];
+        for await (const model of this._client.models.list()) {
+            models.push(model.id);
+        }
+        return models;
+    }
+}
+exports.OpenaiChatClient = OpenaiChatClient;

package/dist/openai_chat/index.d.ts

@@ -0,0 +1,2 @@
+export { OpenaiChatClient } from "./client";
+//# sourceMappingURL=index.d.ts.map

package/dist/openai_chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/openai_chat/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC"}

package/dist/openai_chat/index.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copyright 2025 Prism Shadow. and/or its affiliates
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiChatClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenaiChatClient", { enumerable: true, get: function () { return client_1.OpenaiChatClient; } });

package/dist/openai_chat_vllm_adapter/client.d.ts

@@ -0,0 +1,15 @@
+import { OpenaiChatClient } from "../openai_chat";
+import { UniConfig } from "../types";
+/** Models served through vLLM's OpenAI-compatible Chat Completions API. */
+export declare class OpenaiChatVllmAdapterClient extends OpenaiChatClient {
+    /**
+     * Return the chat_template_kwargs this model's template reads for the level.
+     *
+     * A model outside the table falls back to Qwen3's enable_thinking, the most widespread
+     * of the conventions and inert on a template that ignores the key.
+     */
+    private _thinkingChatTemplateKwargs;
+    /** Map MMSP's level onto the thinking switch this model's chat template reads. */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/openai_chat_vllm_adapter/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/openai_chat_vllm_adapter/client.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAiB,SAAS,EAAE,MAAM,UAAU,CAAC;AAiFpD,2EAA2E;AAC3E,qBAAa,2BAA4B,SAAQ,gBAAgB;IAC/D;;;;;OAKG;IACH,OAAO,CAAC,2BAA2B;IAanC,kFAAkF;IAEzE,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;CAcjE"}

package/dist/openai_chat_vllm_adapter/client.js

@@ -0,0 +1,118 @@
+"use strict";
+// Copyright 2025 Prism Shadow. and/or its affiliates
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiChatVllmAdapterClient = void 0;
+const openai_chat_1 = require("../openai_chat");
+const types_1 = require("../types");
+// vLLM passes chat_template_kwargs straight to the served model's chat template, so the
+// switch that turns thinking on is whatever that template happens to read. Each profile
+// below maps an MMSP level onto one family's kwargs; an empty mapping means the
+// request carries no chat_template_kwargs at all.
+//
+// The upstream artifacts these profiles are read off, and the clamping those artifacts
+// force, are snapshotted in llmsdk_docs/openai_chat_vllm_adapter/. Update that snapshot
+// whenever a model is added here.
+// Qwen3 templates read a single enable_thinking boolean and no effort key at all.
+const QWEN3_THINKING = {
+    [types_1.ThinkingLevel.NONE]: { enable_thinking: false },
+    [types_1.ThinkingLevel.LOW]: { enable_thinking: true },
+    [types_1.ThinkingLevel.MEDIUM]: { enable_thinking: true },
+    [types_1.ThinkingLevel.HIGH]: { enable_thinking: true },
+    [types_1.ThinkingLevel.XHIGH]: { enable_thinking: true },
+    [types_1.ThinkingLevel.MAX]: { enable_thinking: true },
+};
+// Qwen3.8-27B and Qwen3.8-Flash-Next ship the same chat template, byte for byte, so they
+// share a profile. It keeps enable_thinking as the off switch and takes its adaptive modes
+// as reasoning_effort, validated against low/medium/xhigh, so high and max clamp to xhigh.
+// The template defaults the key to xhigh, so a model on this template that is not sent the
+// key runs every level at full effort.
+const QWEN3_8_THINKING = {
+    [types_1.ThinkingLevel.NONE]: { enable_thinking: false },
+    [types_1.ThinkingLevel.LOW]: { reasoning_effort: "low" },
+    [types_1.ThinkingLevel.MEDIUM]: { reasoning_effort: "medium" },
+    [types_1.ThinkingLevel.HIGH]: { reasoning_effort: "xhigh" },
+    [types_1.ThinkingLevel.XHIGH]: { reasoning_effort: "xhigh" },
+    [types_1.ThinkingLevel.MAX]: { reasoning_effort: "xhigh" },
+};
+// DeepSeek V4 publishes no chat template; vLLM reads a thinking flag paired with
+// reasoning_effort, and thinking is off whenever the flag is absent, which is what NONE
+// sends. DeepSeek-V4-Pro and DeepSeek-V4-Flash share an encoding module that asserts
+// reasoning_effort in ['max', None, 'high'], so low is a failed request rather than a
+// weaker answer and high is the lowest value they take. That module then branches on 'max'
+// alone, which means LOW through XHIGH all render the same prompt on these two models.
+const DEEPSEEK_V4_PRO_FLASH_THINKING = {
+    [types_1.ThinkingLevel.NONE]: {},
+    [types_1.ThinkingLevel.LOW]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.MEDIUM]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.HIGH]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.XHIGH]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.MAX]: { thinking: true, reasoning_effort: "max" },
+};
+// DeepSeek-V4-Flash-Vision-Exp ships a different copy of that encoding module, one that
+// validates reasoning_effort against a low/high/max table, so it keeps the finer scale;
+// medium and xhigh clamp to high.
+const DEEPSEEK_V4_VISION_EXP_THINKING = {
+    [types_1.ThinkingLevel.NONE]: {},
+    [types_1.ThinkingLevel.LOW]: { thinking: true, reasoning_effort: "low" },
+    [types_1.ThinkingLevel.MEDIUM]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.HIGH]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.XHIGH]: { thinking: true, reasoning_effort: "high" },
+    [types_1.ThinkingLevel.MAX]: { thinking: true, reasoning_effort: "max" },
+};
+// Keys are matched as substrings of the lowercased model id, so a served id keeps whatever
+// prefix the deployment gave it (Qwen/Qwen3.6-35B-A3B, deepseek-ai/DeepSeek-V4-Pro). The
+// first match wins, so a key that contains another must come first: deepseek-v4-flash is a
+// prefix of deepseek-v4-flash-vision-exp.
+const MODEL_THINKING_PROFILES = [
+    ["qwen3.8-flash-next", QWEN3_8_THINKING],
+    ["qwen3.8-27b", QWEN3_8_THINKING],
+    ["qwen3.6-35b-a3b", QWEN3_THINKING],
+    ["qwen3.5-0.8b", QWEN3_THINKING],
+    ["qwen3.5-9b", QWEN3_THINKING],
+    ["deepseek-v4-flash-vision-exp", DEEPSEEK_V4_VISION_EXP_THINKING],
+    ["deepseek-v4-pro", DEEPSEEK_V4_PRO_FLASH_THINKING],
+    ["deepseek-v4-flash", DEEPSEEK_V4_PRO_FLASH_THINKING],
+];
+/** Models served through vLLM's OpenAI-compatible Chat Completions API. */
+class OpenaiChatVllmAdapterClient extends openai_chat_1.OpenaiChatClient {
+    /**
+     * Return the chat_template_kwargs this model's template reads for the level.
+     *
+     * A model outside the table falls back to Qwen3's enable_thinking, the most widespread
+     * of the conventions and inert on a template that ignores the key.
+     */
+    _thinkingChatTemplateKwargs(thinkingLevel) {
+        const model = this._model.toLowerCase();
+        for (const [name, profile] of MODEL_THINKING_PROFILES) {
+            if (model.includes(name)) {
+                return { ...profile[thinkingLevel] };
+            }
+        }
+        return { ...QWEN3_THINKING[thinkingLevel] };
+    }
+    /** Map MMSP's level onto the thinking switch this model's chat template reads. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        const vllmConfig = super.transformUniConfigToModelConfig(config);
+        if (config.thinking_level !== undefined) {
+            const chatTemplateKwargs = this._thinkingChatTemplateKwargs(config.thinking_level);
+            if (Object.keys(chatTemplateKwargs).length > 0) {
+                vllmConfig.chat_template_kwargs = chatTemplateKwargs;
+            }
+        }
+        return vllmConfig;
+    }
+}
+exports.OpenaiChatVllmAdapterClient = OpenaiChatVllmAdapterClient;

package/dist/openai_chat_vllm_adapter/index.d.ts

@@ -0,0 +1,2 @@
+export { OpenaiChatVllmAdapterClient } from "./client";
+//# sourceMappingURL=index.d.ts.map

package/dist/openai_chat_vllm_adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/openai_chat_vllm_adapter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC"}

package/dist/openai_chat_vllm_adapter/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiChatVllmAdapterClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenaiChatVllmAdapterClient", { enumerable: true, get: function () { return client_1.OpenaiChatVllmAdapterClient; } });

package/dist/openai_embedding/client.d.ts

@@ -0,0 +1,46 @@
+import type { CreateEmbeddingResponse, EmbeddingCreateParams } from "openai/resources/embeddings";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * OpenAI Embeddings-compatible client implementation.
+ */
+export declare class OpenaiEmbeddingClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize OpenAI-compatible embedding client with model, API key, and base URL.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Transform universal configuration to OpenAI Embeddings configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): Omit<EmbeddingCreateParams, "input">;
+    /**
+     * Transform universal messages to OpenAI Embeddings input strings.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[]): string[];
+    /**
+     * Transform an OpenAI Embeddings response into a universal event, one complete item per vector.
+     */
+    transformModelOutputToUniEvent(modelOutput: CreateEmbeddingResponse): UniEvent;
+    /**
+     * Generate embeddings using OpenAI Embeddings-compatible API.
+     */
+    _streamingResponseInternal(options: {
+        messages: UniMessage[];
+        config: UniConfig;
+        signal?: AbortSignal;
+    }): AsyncGenerator<UniEvent>;
+    /**
+     * List the model ids the configured endpoint serves.
+     *
+     * @returns The model ids, in the order the endpoint returned them.
+     */
+    listModels(): Promise<string[]>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/openai_embedding/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/openai_embedding/client.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3D;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,OAAO,CAAS;IAExB;;OAEG;gBACS,OAAO,EAAE;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACzC;IAeD;;OAEG;IACH,+BAA+B,CAC7B,MAAM,EAAE,SAAS,GAChB,IAAI,CAAC,qBAAqB,EAAE,OAAO,CAAC;IAmBvC;;OAEG;IACH,+BAA+B,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE;IAejE;;OAEG;IACH,8BAA8B,CAC5B,WAAW,EAAE,uBAAuB,GACnC,QAAQ;IAkBX;;OAEG;IACI,0BAA0B,CAAC,OAAO,EAAE;QACzC,QAAQ,EAAE,UAAU,EAAE,CAAC;QACvB,MAAM,EAAE,SAAS,CAAC;QAClB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,cAAc,CAAC,QAAQ,CAAC;IAW5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}