@prismshadow/mmsp 0.5.0

package/dist/deepseek_official/client.js

@@ -0,0 +1,407 @@
+"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.DeepSeekOfficialClient = 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");
+/**
+ * The DeepSeek ids that read no image: the current V4 Flash and V4 Pro, bare or with a
+ * dated snapshot suffix (`deepseek-v4-flash-0731`). Every other id forwards its images.
+ * Matched against the bare id — the part after the last `/`, lowercased — so a gateway
+ * prefix (`deepseek/`, `deepseek-ai/`) and the spelling a platform uses do not change the
+ * verdict.
+ */
+const TEXT_ONLY_MODELS = /^deepseek-v4-(flash|pro)(-\d{4})?$/;
+/**
+ * DeepSeek V4-specific LLM client implementation using the OpenAI-compatible Responses API.
+ */
+class DeepSeekOfficialClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize DeepSeek client with model, API key, and base URL.
+     */
+    constructor(options) {
+        super();
+        this._model = options.model;
+        // The wrapped OpenAI SDK falls back to OPENAI_API_KEY when handed undefined, which would send
+        // an OpenAI credential to the DeepSeek host, so resolve the key here and fail loudly instead.
+        const key = options.apiKey || process.env.DEEPSEEK_API_KEY;
+        if (!key) {
+            throw new Error("DEEPSEEK_API_KEY is required for DeepSeekOfficialClient.");
+        }
+        const url = options.baseUrl ||
+            process.env.DEEPSEEK_BASE_URL ||
+            "https://api.deepseek.com";
+        this._client = new openai_1.default({
+            apiKey: key,
+            baseURL: url,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    /**
+     * Convert ThinkingLevel enum to DeepSeek's reasoning effort.
+     *
+     * DeepSeek accepts low/high/max and maps medium and xhigh onto high server-side
+     * (llmsdk_docs/deepseek_v4/docs/thinking-mode.md), so this sends the value the server
+     * would settle on anyway. Effort "none" is what turns thinking off on this endpoint:
+     * the Chat Completions `thinking` toggle is ignored here (verified live 2026-08-21).
+     */
+    _convertThinkingLevelToEffort(thinkingLevel) {
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: "none",
+            [types_1.ThinkingLevel.LOW]: "low",
+            [types_1.ThinkingLevel.MEDIUM]: "high",
+            [types_1.ThinkingLevel.HIGH]: "high",
+            [types_1.ThinkingLevel.XHIGH]: "high",
+            [types_1.ThinkingLevel.MAX]: "max",
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to DeepSeek's Responses-compatible tool_choice format.
+     */
+    _convertToolChoice(toolChoice) {
+        if (toolChoice === "auto" || toolChoice === "none") {
+            return toolChoice;
+        }
+        throw new errors_1.UnsupportedParameterError({
+            client: this.constructor.name,
+            parameter: "tool_choice",
+            message: "DeepSeek V4 only supports 'auto' and 'none' for tool_choice.",
+        });
+    }
+    /**
+     * Transform universal configuration to DeepSeek-specific configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const deepseekConfig = {
+            model: this._model,
+            store: false,
+        };
+        if (config.system_prompt !== undefined) {
+            deepseekConfig.instructions = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            deepseekConfig.max_output_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined && config.temperature !== 1.0) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "temperature",
+                message: "DeepSeek V4 does not support setting temperature.",
+            });
+        }
+        if (config.thinking_level !== undefined) {
+            deepseekConfig.reasoning = {
+                effort: this._convertThinkingLevelToEffort(config.thinking_level),
+            };
+        }
+        if (config.thinking_summary) {
+            // DeepSeek takes reasoning.summary with or without an effort and returns an empty
+            // summary list for now (verified live 2026-09-03 on api.deepseek.com and
+            // OpenRouter), so the request carries the preference instead of dropping it and
+            // picks up summaries as soon as the vendor generates them. False needs no key:
+            // the Responses API returns no summary unless one is asked for.
+            deepseekConfig.reasoning = deepseekConfig.reasoning ?? {};
+            deepseekConfig.reasoning.summary = "concise";
+        }
+        if (config.tools !== undefined) {
+            deepseekConfig.tools = config.tools.map((tool) => ({
+                type: "function",
+                ...tool,
+            }));
+        }
+        if (config.tool_choice !== undefined) {
+            deepseekConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "fast_mode",
+                message: "DeepSeek V4 does not support fast mode.",
+            });
+        }
+        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 DeepSeek.",
+            });
+        }
+        return deepseekConfig;
+    }
+    /**
+     * Transform universal message format to DeepSeek's Responses-compatible input format.
+     */
+    transformUniMessageToModelInput(messages, _signal) {
+        // a text-only model answers from a placeholder instead of failing
+        // (llmsdk_docs/deepseek_v4/docs/responses-api.md), so an image is refused here rather
+        // than silently dropped
+        const supportsImage = !TEXT_ONLY_MODELS.test(this._model.toLowerCase().replace(/^.*\//, ""));
+        // 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
+            const contentItems = [];
+            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: DeepSeek
+                // merges a function call into the adjacent assistant message and answers a call
+                // whose output does not follow it with "No tool output found for tool call"
+                // (verified live 2026-08-21)
+                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.
+                    inputList.push({
+                        type: "message",
+                        role: msg.role,
+                        content: [...contentItems],
+                    });
+                    contentItems.length = 0;
+                }
+                if (item.type === "text.done") {
+                    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") {
+                    if (!supportsImage) {
+                        throw new Error(`DeepSeek ${this._model} does not support image inputs.`);
+                    }
+                    contentItems.push({ type: "input_image", image_url: item.image_url });
+                }
+                else if (item.type === "thinking.done") {
+                    // DeepSeek carries the chain of thought as plain reasoning_text and ignores the
+                    // summary and encrypted_content channels, so the item is rebuilt from the text
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const reasoning = { type: "reasoning", summary: [] };
+                    if (item.thinking) {
+                        reasoning.content = [
+                            { type: "reasoning_text", text: item.thinking },
+                        ];
+                    }
+                    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) {
+                        if (!supportsImage) {
+                            throw new Error(`DeepSeek ${this._model} does not support images in tool results.`);
+                        }
+                        for (const imageUrl of item.images) {
+                            imageParts.push({ type: "input_image", image_url: imageUrl });
+                        }
+                    }
+                    // a plain string is the form the Responses API documents for a text
+                    // result and the one every endpoint fronting this model accepts; the
+                    // content-part list is reserved for results carrying images
+                    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) {
+                inputList.push({
+                    type: "message",
+                    role: msg.role,
+                    content: contentItems,
+                });
+            }
+        }
+        return inputList;
+    }
+    /**
+     * Transform one DeepSeek 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 deepseekEventType = modelOutput.type;
+        if (deepseekEventType === "response.output_text.delta") {
+            contentItems.push({
+                type: "text.delta",
+                text: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (deepseekEventType === "response.reasoning_text.delta") {
+            contentItems.push({
+                type: "thinking.delta",
+                thinking: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (deepseekEventType === "response.output_item.added") {
+            // an item begins: a delta under its id, empty unless it carries the call's name, ends
+            // the item before it
+            const item = modelOutput.item;
+            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 },
+                });
+            }
+            else if (item.type === "reasoning") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: "",
+                    fidelity: { item_id: item.id },
+                });
+            }
+        }
+        else if (deepseekEventType === "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 (deepseekEventType === "response.completed" ||
+            deepseekEventType === "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) {
+                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_item.done",
+            "response.output_text.done",
+            "response.reasoning_text.done",
+            "response.function_call_arguments.done",
+            "response.content_part.added",
+            "response.content_part.done",
+            // gateway heartbeat on long generations; carries no content
+            "keepalive",
+        ].includes(deepseekEventType)) {
+            // 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 DeepSeek's OpenAI-compatible Responses API.
+     */
+    async *_streamingResponseInternal(options) {
+        const deepseekConfig = this.transformUniConfigToModelConfig(options.config);
+        const inputList = this.transformUniMessageToModelInput(options.messages, options.signal);
+        const params = {
+            ...deepseekConfig,
+            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.DeepSeekOfficialClient = DeepSeekOfficialClient;

package/dist/deepseek_official/index.d.ts

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

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

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

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

package/dist/errors.d.ts

@@ -0,0 +1,84 @@
+import { UsageMetadata } from "./types";
+export declare class MMSPError extends Error {
+    constructor(message: string);
+}
+/**
+ * Raised when a UniConfig parameter value is not supported by the target model client.
+ *
+ * Thinking levels never raise this by design: every client maps each ThinkingLevel
+ * onto the closest level the model supports. Parameters such as temperature and
+ * tool_choice may reject unsupported values with this error.
+ */
+export declare class UnsupportedParameterError extends MMSPError {
+    readonly client: string;
+    readonly parameter: string;
+    constructor(args: {
+        client: string;
+        parameter: string;
+        message: string;
+    });
+}
+/**
+ * Raised when a completed response carries no non-thinking content and no tool calls.
+ *
+ * Models occasionally finish a turn with thinking output only (reasoning models in
+ * particular); replaying such an assistant message on the next turn fails with a 400
+ * error, so the response is rejected as soon as the stream completes.
+ */
+/**
+ * Raised when a client cannot perform an operation at all, whatever it is passed.
+ *
+ * Distinct from UnsupportedParameterError, which rejects a UniConfig parameter value:
+ * this one reports a capability the routed client does not have, such as listing models
+ * through an SDK client that carries no models endpoint.
+ */
+export declare class UnsupportedOperationError extends MMSPError {
+    readonly client: string;
+    readonly operation: string;
+    constructor(args: {
+        client: string;
+        operation: string;
+        message: string;
+    });
+}
+export declare class EmptyResponseError extends MMSPError {
+    readonly client: string;
+    readonly finishReason: string | null;
+    readonly usageMetadata: UsageMetadata | null;
+    constructor(args: {
+        client: string;
+        finishReason: string | null;
+        usageMetadata?: UsageMetadata | null;
+    });
+}
+/**
+ * Raised when a client produces a stream that breaks the streaming protocol: a content item
+ * that is not a delta, a second different fidelity within one item, a tool call whose first
+ * delta lacks its name or id, or a delta event carrying usage or a finish reason.
+ *
+ * It always reports a bug in the client rather than in the provider's output, so it is
+ * raised in every mode instead of being repaired into a stream that breaks the contract.
+ */
+export declare class StreamProtocolError extends MMSPError {
+    readonly client: string;
+    constructor(args: {
+        client: string;
+        message: string;
+    });
+}
+export declare class ToolCallArgumentParseError extends MMSPError {
+    readonly client: string;
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly rawArgumentsLength: number;
+    readonly rawArgumentsPreview: string;
+    constructor(args: {
+        client: string;
+        toolName: string;
+        toolCallId: string;
+        rawArguments: string;
+        reason: string;
+    });
+}
+export declare function parseToolCallArguments(rawArguments: string | undefined, client: string, toolName: string, toolCallId: string): Record<string, unknown>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAWxC,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAMzE;AAED;;;;;;GAMG;AACH;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAMzE;AAED,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC,QAAQ,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;gBAEjC,IAAI,EAAE;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;KACtC;CAUF;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAKtD;AAED,qBAAa,0BAA2B,SAAQ,SAAS;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;gBAEzB,IAAI,EAAE;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;KAChB;CAcF;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2BzB"}

package/dist/errors.js

@@ -0,0 +1,140 @@
+"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.ToolCallArgumentParseError = exports.StreamProtocolError = exports.EmptyResponseError = exports.UnsupportedOperationError = exports.UnsupportedParameterError = exports.MMSPError = void 0;
+exports.parseToolCallArguments = parseToolCallArguments;
+function previewToolCallArguments(raw) {
+    const maxLength = 160;
+    if (raw.length <= maxLength) {
+        return raw;
+    }
+    const edgeLength = 72;
+    return `${raw.slice(0, edgeLength)}...[truncated]...${raw.slice(-edgeLength)}`;
+}
+class MMSPError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MMSPError";
+    }
+}
+exports.MMSPError = MMSPError;
+/**
+ * Raised when a UniConfig parameter value is not supported by the target model client.
+ *
+ * Thinking levels never raise this by design: every client maps each ThinkingLevel
+ * onto the closest level the model supports. Parameters such as temperature and
+ * tool_choice may reject unsupported values with this error.
+ */
+class UnsupportedParameterError extends MMSPError {
+    constructor(args) {
+        super(args.message);
+        this.name = "UnsupportedParameterError";
+        this.client = args.client;
+        this.parameter = args.parameter;
+    }
+}
+exports.UnsupportedParameterError = UnsupportedParameterError;
+/**
+ * Raised when a completed response carries no non-thinking content and no tool calls.
+ *
+ * Models occasionally finish a turn with thinking output only (reasoning models in
+ * particular); replaying such an assistant message on the next turn fails with a 400
+ * error, so the response is rejected as soon as the stream completes.
+ */
+/**
+ * Raised when a client cannot perform an operation at all, whatever it is passed.
+ *
+ * Distinct from UnsupportedParameterError, which rejects a UniConfig parameter value:
+ * this one reports a capability the routed client does not have, such as listing models
+ * through an SDK client that carries no models endpoint.
+ */
+class UnsupportedOperationError extends MMSPError {
+    constructor(args) {
+        super(args.message);
+        this.name = "UnsupportedOperationError";
+        this.client = args.client;
+        this.operation = args.operation;
+    }
+}
+exports.UnsupportedOperationError = UnsupportedOperationError;
+class EmptyResponseError extends MMSPError {
+    constructor(args) {
+        super(`${args.client} returned no content other than thinking ` +
+            `(finish_reason=${JSON.stringify(args.finishReason)}).`);
+        this.name = "EmptyResponseError";
+        this.client = args.client;
+        this.finishReason = args.finishReason;
+        this.usageMetadata = args.usageMetadata ?? null;
+    }
+}
+exports.EmptyResponseError = EmptyResponseError;
+/**
+ * Raised when a client produces a stream that breaks the streaming protocol: a content item
+ * that is not a delta, a second different fidelity within one item, a tool call whose first
+ * delta lacks its name or id, or a delta event carrying usage or a finish reason.
+ *
+ * It always reports a bug in the client rather than in the provider's output, so it is
+ * raised in every mode instead of being repaired into a stream that breaks the contract.
+ */
+class StreamProtocolError extends MMSPError {
+    constructor(args) {
+        super(`${args.client} broke the streaming protocol: ${args.message}`);
+        this.name = "StreamProtocolError";
+        this.client = args.client;
+    }
+}
+exports.StreamProtocolError = StreamProtocolError;
+class ToolCallArgumentParseError extends MMSPError {
+    constructor(args) {
+        const preview = previewToolCallArguments(args.rawArguments);
+        super(`Invalid streamed tool call arguments from ${args.client} for tool "${args.toolName}" ` +
+            `(tool_call_id="${args.toolCallId}", length=${args.rawArguments.length}, ` +
+            `preview=${JSON.stringify(preview)}): ${args.reason}`);
+        this.name = "ToolCallArgumentParseError";
+        this.client = args.client;
+        this.toolName = args.toolName;
+        this.toolCallId = args.toolCallId;
+        this.rawArgumentsLength = args.rawArguments.length;
+        this.rawArgumentsPreview = preview;
+    }
+}
+exports.ToolCallArgumentParseError = ToolCallArgumentParseError;
+function parseToolCallArguments(rawArguments, client, toolName, toolCallId) {
+    const raw = rawArguments || "{}";
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new ToolCallArgumentParseError({
+            client,
+            toolName,
+            toolCallId,
+            rawArguments: raw,
+            reason,
+        });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ToolCallArgumentParseError({
+            client,
+            toolName,
+            toolCallId,
+            rawArguments: raw,
+            reason: "Expected a JSON object.",
+        });
+    }
+    return parsed;
+}