@prismshadow/mmsp 0.5.0

package/dist/openai_official/index.d.ts

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

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

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

package/dist/openai_official/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.OpenAIOfficialClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenAIOfficialClient", { enumerable: true, get: function () { return client_1.OpenAIOfficialClient; } });

package/dist/openai_responses/client.d.ts

@@ -0,0 +1,61 @@
+import type { ResponseInputItem, ResponseStreamEvent } from "openai/resources/responses/responses";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * OpenAI Responses-compatible client implementation.
+ */
+export declare class OpenaiResponsesClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize OpenAI Responses-compatible client with model, API key, and base URL.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Convert ThinkingLevel enum to the Responses API reasoning effort.
+     */
+    private _convertThinkingLevelToEffort;
+    /**
+     * Convert ToolChoice to the Responses API tool_choice format with allowed tools support.
+     */
+    private _convertToolChoice;
+    /**
+     * Convert an image URL to an input_image item, at the detail the API needs
+     * to read it.
+     */
+    private _convertImageUrl;
+    /**
+     * Transform universal configuration to OpenAI Responses-compatible configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to OpenAI Responses-compatible input format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], _signal?: AbortSignal): ResponseInputItem[];
+    /**
+     * Transform one OpenAI Responses-compatible stream event into a universal event, identifying
+     * items by output item id. An item needs no done: it is done when the next one begins or the
+     * stream ends.
+     */
+    transformModelOutputToUniEvent(modelOutput: ResponseStreamEvent): UniEvent;
+    /**
+     * Stream generate using an OpenAI Responses-compatible API with unified conversion methods.
+     */
+    _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_responses/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/openai_responses/client.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAGX,MAAM,UAAU,CAAC;AAOlB;;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,OAAO,CAAC,6BAA6B;IAmBrC;;OAEG;IAEH,OAAO,CAAC,kBAAkB;IAW1B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IA8DvD;;OAEG;IACH,+BAA+B,CAC7B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE,WAAW,GACpB,iBAAiB,EAAE;IAkJtB;;;;OAIG;IACH,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IA0I1E;;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;IAqB5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}

package/dist/openai_responses/client.js

@@ -0,0 +1,449 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiResponsesClient = void 0;
+const openai_1 = __importDefault(require("openai"));
+const baseClient_1 = require("../baseClient");
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+/**
+ * OpenAI Responses-compatible client implementation.
+ */
+class OpenaiResponsesClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize OpenAI Responses-compatible 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,
+        });
+    }
+    /**
+     * Convert ThinkingLevel enum to the Responses API reasoning effort.
+     */
+    _convertThinkingLevelToEffort(thinkingLevel) {
+        if (thinkingLevel === types_1.ThinkingLevel.NONE && this._model.includes("gpt-6")) {
+            // a gateway serving GPT-6 forwards the effort to OpenAI, which rejects "none" and
+            // "minimal" with a 400 (verified live 2026-09-09 against api.openai.com), so NONE
+            // degrades to the lowest effort the generation accepts.
+            return "low";
+        }
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: "none",
+            [types_1.ThinkingLevel.LOW]: "low",
+            [types_1.ThinkingLevel.MEDIUM]: "medium",
+            [types_1.ThinkingLevel.HIGH]: "high",
+            [types_1.ThinkingLevel.XHIGH]: "xhigh",
+            [types_1.ThinkingLevel.MAX]: "max",
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to the Responses API tool_choice format with allowed tools support.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertToolChoice(toolChoice) {
+        if (Array.isArray(toolChoice)) {
+            return {
+                mode: "required",
+                tools: toolChoice.map((name) => ({ type: "function", name })),
+            };
+        }
+        return toolChoice;
+    }
+    /**
+     * Convert an image URL to an input_image item, at the detail the API needs
+     * to read it.
+     */
+    _convertImageUrl(imageUrl) {
+        const detail = (0, utils_1.openaiImageDetail)(this._model, imageUrl);
+        return detail
+            ? { type: "input_image", image_url: imageUrl, detail }
+            : { type: "input_image", image_url: imageUrl };
+    }
+    /**
+     * Transform universal configuration to OpenAI Responses-compatible 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,
+            store: false,
+        };
+        if (config.system_prompt !== undefined) {
+            openaiConfig.instructions = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            openaiConfig.max_output_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined) {
+            openaiConfig.temperature = config.temperature;
+        }
+        // Unlike the model-specific Responses clients, the summary stays inside this branch:
+        // OpenRouter reads a reasoning object carrying no effort as "reasoning disabled" and
+        // refuses it on a forced-thinking model -- "Reasoning is mandatory for this endpoint
+        // and cannot be disabled" (400, verified live 2026-09-03 with z-ai/glm-5.3) -- so a
+        // summary sent on its own would turn a dropped value into a failed request.
+        if (config.thinking_level !== undefined) {
+            openaiConfig.reasoning = {
+                effort: this._convertThinkingLevelToEffort(config.thinking_level),
+            };
+            if (config.thinking_summary) {
+                openaiConfig.reasoning.summary = "concise";
+            }
+        }
+        if (config.tools !== undefined) {
+            openaiConfig.tools = config.tools.map((tool) => ({
+                type: "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 the Responses API.",
+            });
+        }
+        return openaiConfig;
+    }
+    /**
+     * Transform universal message format to OpenAI Responses-compatible input format.
+     */
+    transformUniMessageToModelInput(messages, _signal) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const inputList = [];
+        for (const msg of messages) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let contentItems = [];
+            let lastPhase = null;
+            for (const item of msg.content_items) {
+                // anything that is not message content becomes an input item of its own, so the
+                // text collected so far is flushed first to keep the original order: a server that
+                // merges a function call into the adjacent assistant message rejects a call whose
+                // output does not follow it (DeepSeek answers "No tool output found for tool call")
+                if (item.type !== "text.done" &&
+                    item.type !== "image_url.done" &&
+                    contentItems.length > 0) {
+                    // Every turn goes back as a typed message item — the Responses API's EasyInputMessage
+                    // shape, where type "message" is valid for any role. A vLLM-style Responses server
+                    // answers a bare { role: "assistant", content: [...] } item with a 400 on the turn that
+                    // replays it and takes the typed form for every role; OpenAI, DeepSeek and MiniMax accept
+                    // either shape. Nothing beyond that minimal shape goes out: an id or a status the server
+                    // never sent would be an invention.
+                    const entry = {
+                        type: "message",
+                        role: msg.role,
+                        content: contentItems,
+                    };
+                    if (lastPhase !== null) {
+                        entry.phase = lastPhase;
+                    }
+                    inputList.push(entry);
+                    contentItems = [];
+                }
+                if (item.type === "text.done") {
+                    const phase = item.fidelity?.phase;
+                    if (msg.role === "assistant" && phase) {
+                        // split different phases
+                        if (lastPhase !== null &&
+                            lastPhase !== phase &&
+                            contentItems.length > 0) {
+                            inputList.push({
+                                type: "message",
+                                role: msg.role,
+                                content: contentItems,
+                                phase: lastPhase,
+                            });
+                            contentItems = [];
+                        }
+                        lastPhase = phase;
+                    }
+                    if (msg.role === "user") {
+                        contentItems.push({ type: "input_text", text: item.text });
+                    }
+                    else {
+                        contentItems.push({ type: "output_text", text: item.text });
+                    }
+                }
+                else if (item.type === "image_url.done") {
+                    contentItems.push(this._convertImageUrl(item.image_url));
+                }
+                else if (item.type === "thinking.done") {
+                    // the wire shape differs by server: OpenAI-style servers stream summaries and
+                    // demand the summary key back (with encrypted_content preserved), while
+                    // DeepSeek/Z.AI/MiniMax-style servers accept a reasoning item rebuilt from the
+                    // thinking text alone as reasoning_text content
+                    const fidelity = item.fidelity ?? {};
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const reasoning = { type: "reasoning", summary: [] };
+                    if (fidelity.channel === "summary") {
+                        if (item.thinking) {
+                            reasoning.summary = [
+                                { type: "summary_text", text: item.thinking },
+                            ];
+                        }
+                    }
+                    else if (item.thinking) {
+                        reasoning.content = [
+                            { type: "reasoning_text", text: item.thinking },
+                        ];
+                    }
+                    for (const key of ["encrypted_content", "signature", "format"]) {
+                        if (fidelity[key] != null) {
+                            reasoning[key] = fidelity[key];
+                        }
+                    }
+                    inputList.push(reasoning);
+                }
+                else if (item.type === "tool_call.done") {
+                    inputList.push({
+                        type: "function_call",
+                        call_id: item.tool_call_id,
+                        name: item.name,
+                        arguments: JSON.stringify(item.arguments),
+                    });
+                }
+                else if (item.type === "tool_result.done") {
+                    if (!item.tool_call_id) {
+                        throw new Error("tool_call_id is required for tool result.");
+                    }
+                    // NOTE: tool results are input items
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const imageParts = [];
+                    if (item.images) {
+                        for (const imageUrl of item.images) {
+                            imageParts.push(this._convertImageUrl(imageUrl));
+                        }
+                    }
+                    // a plain string is the form every OpenAI-compatible server accepts for a text
+                    // result; the content-part list is reserved for results carrying images, which
+                    // only servers with multimodal tool messages take
+                    const output = imageParts.length > 0
+                        ? [{ type: "input_text", text: item.text }, ...imageParts]
+                        : item.text;
+                    inputList.push({
+                        type: "function_call_output",
+                        call_id: item.tool_call_id,
+                        output,
+                    });
+                }
+                else {
+                    throw new Error(`Unknown item: ${JSON.stringify(item)}`);
+                }
+            }
+            if (contentItems.length > 0) {
+                const entry = {
+                    type: "message",
+                    role: msg.role,
+                    content: contentItems,
+                };
+                if (lastPhase !== null) {
+                    entry.phase = lastPhase;
+                }
+                inputList.push(entry);
+            }
+        }
+        return inputList;
+    }
+    /**
+     * Transform one OpenAI Responses-compatible stream event into a universal event, identifying
+     * items by output item id. An item needs no done: it is done when the next one begins or the
+     * stream ends.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        let eventType = "delta";
+        const contentItems = [];
+        let usageMetadata = null;
+        let finishReason = null;
+        const openaiEventType = modelOutput.type;
+        if (openaiEventType === "response.output_text.delta") {
+            contentItems.push({
+                type: "text.delta",
+                text: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.reasoning_text.delta" ||
+            openaiEventType === "response.reasoning_summary_text.delta") {
+            contentItems.push({
+                type: "thinking.delta",
+                thinking: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.output_item.added") {
+            // an item begins: a delta under its id, empty unless it carries the call's name or the
+            // message's phase, ends the item before it
+            const item = modelOutput.item;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const phase = item.phase;
+            if (item.type === "function_call") {
+                contentItems.push({
+                    type: "tool_call.delta",
+                    name: item.name,
+                    arguments: "",
+                    tool_call_id: item.call_id,
+                    // a server that sends no item id still sends the call id
+                    fidelity: { item_id: item.id || item.call_id },
+                });
+            }
+            else if (item.type === "message") {
+                contentItems.push({
+                    type: "text.delta",
+                    text: "",
+                    fidelity: { item_id: item.id, ...(phase ? { phase } : {}) },
+                });
+            }
+            else if (item.type === "reasoning") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: "",
+                    fidelity: { item_id: item.id },
+                });
+            }
+        }
+        else if (openaiEventType === "response.output_item.done") {
+            const item = modelOutput.item;
+            if (item.type === "reasoning") {
+                // the last delta of a reasoning item: the wire shape of the completed item, so a
+                // replay reproduces the channel that carried the thinking plus the fields the server
+                // demands back
+                const fidelity = { item_id: item.id };
+                if (item.summary && item.summary.length > 0) {
+                    fidelity.channel = "summary";
+                }
+                for (const key of ["encrypted_content", "signature", "format"]) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (item[key] != null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        fidelity[key] = item[key];
+                    }
+                }
+                contentItems.push({ type: "thinking.delta", thinking: "", fidelity });
+            }
+        }
+        else if (openaiEventType === "response.function_call_arguments.delta") {
+            contentItems.push({
+                type: "tool_call.delta",
+                name: "",
+                arguments: modelOutput.delta,
+                tool_call_id: "",
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.completed" ||
+            openaiEventType === "response.incomplete") {
+            eventType = "stop";
+            const response = modelOutput.response;
+            const finishReasonMapping = {
+                completed: "stop",
+                incomplete: "length",
+            };
+            if (response.status) {
+                finishReason = finishReasonMapping[response.status] || "unknown";
+            }
+            if (response.usage) {
+                // some servers drop the detail blocks (e.g. MiniMax on truncation), so default to zero
+                const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+                const reasoningTokens = response.usage.output_tokens_details?.reasoning_tokens || 0;
+                usageMetadata = {
+                    cached_tokens: cachedTokens,
+                    prompt_tokens: response.usage.input_tokens - cachedTokens,
+                    thoughts_tokens: reasoningTokens,
+                    response_tokens: response.usage.output_tokens - reasoningTokens,
+                };
+            }
+        }
+        else if ([
+            "response.created",
+            "response.in_progress",
+            "response.output_text.done",
+            "response.function_call_arguments.done",
+            "response.reasoning_text.done",
+            "response.reasoning_summary_part.added",
+            "response.reasoning_summary_part.done",
+            "response.reasoning_summary_text.done",
+            "response.content_part.added",
+            "response.content_part.done",
+            // gateway heartbeat on long generations; carries no content
+            "keepalive",
+        ].includes(openaiEventType)) {
+            // lifecycle events, and repeats of what the deltas carry
+        }
+        else if ((0, utils_1.isDebugEnabled)()) {
+            throw new Error(`Unknown output: ${JSON.stringify(modelOutput)}`);
+        }
+        else {
+            // a gateway injects its own events (heartbeats, cost tickers) into the stream, and
+            // killing a long generation over one costs more than dropping it
+        }
+        return {
+            role: "assistant",
+            event_type: eventType,
+            content_items: contentItems,
+            usage_metadata: usageMetadata,
+            finish_reason: finishReason,
+        };
+    }
+    /**
+     * Stream generate using an OpenAI Responses-compatible API with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const openaiConfig = this.transformUniConfigToModelConfig(options.config);
+        const inputList = this.transformUniMessageToModelInput(options.messages, options.signal);
+        const params = {
+            ...openaiConfig,
+            input: inputList,
+            stream: true,
+        };
+        const stream = await this._client.responses.create(params, {
+            signal: options.signal,
+        });
+        for await (const event of stream) {
+            yield this.transformModelOutputToUniEvent(event);
+        }
+    }
+    /**
+     * 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.OpenaiResponsesClient = OpenaiResponsesClient;

package/dist/openai_responses/index.d.ts

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

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

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

package/dist/openai_responses/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.OpenaiResponsesClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenaiResponsesClient", { enumerable: true, get: function () { return client_1.OpenaiResponsesClient; } });

package/dist/registry.d.ts

@@ -0,0 +1,49 @@
+export type Modality = "Text" | "Image" | "Video" | "Audio" | "Embed";
+export type Currency = "USD" | "CNY";
+/**
+ * List prices per million tokens for MMSP's usage buckets.
+ *
+ * Keys mirror `usage_metadata`: `cached_tokens` (cache-hit price, absent when
+ * the platform publishes none), `prompt_tokens` (non-cached input), and
+ * `thoughts_tokens`/`response_tokens`, which both carry the vendor's output
+ * price. Values are in the currency requested from listSupportedModels.
+ */
+export interface ModelPricing {
+    currency: Currency;
+    prompt_tokens: number;
+    thoughts_tokens: number;
+    response_tokens: number;
+    cached_tokens?: number;
+}
+/**
+ * One supported model entry.
+ *
+ * (model, base_url, client) maps directly onto the AutoLLMClient constructor:
+ * `new AutoLLMClient({ model, baseUrl: base_url, clientType: client })`.
+ * Modalities describe what is usable through that client; `context_window` and
+ * `pricing` are omitted where the platform publishes no authoritative value.
+ *
+ * `pricing` is always the LIST price. A running promotion is deliberately not recorded: the
+ * registry's job is the catalog price, and applying a promotion is the consumer's.
+ */
+export interface SupportedModel {
+    model: string;
+    base_url: string;
+    client: string;
+    input_modalities: Modality[];
+    output_modalities: Modality[];
+    context_window?: number;
+    pricing?: ModelPricing;
+}
+/**
+ * List supported models with base URL, client, modalities, context window, and
+ * pricing.
+ *
+ * Covers the official vendor endpoints plus the OpenRouter and SiliconFlow
+ * platforms; `client` is the `clientType` token that routes the model to its
+ * protocol client. Prices are per million tokens for MMSP's usage buckets
+ * (cached_tokens, prompt_tokens, thoughts_tokens, response_tokens), stored in
+ * USD and converted to `currency` at 7 CNY/USD on request.
+ */
+export declare function listSupportedModels(currency?: Currency): SupportedModel[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AACtE,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,QAAQ,EAAE,CAAC;IAC7B,iBAAiB,EAAE,QAAQ,EAAE,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AA0wBD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,GAAE,QAAgB,GACzB,cAAc,EAAE,CASlB"}