@prismshadow/mmsp 0.5.0

package/dist/moonshot_official/client.js

@@ -0,0 +1,477 @@
+"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.MoonshotOfficialClient = void 0;
+const path = __importStar(require("path"));
+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");
+/**
+ * Kimi K3-specific LLM client implementation using OpenAI-compatible API (also serves K2.5 and K2.6).
+ */
+class MoonshotOfficialClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize Kimi K3 client with model and API key.
+     */
+    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 Moonshot host, so resolve the key here and fail loudly instead.
+        const key = options.apiKey || process.env.MOONSHOT_API_KEY;
+        if (!key) {
+            throw new Error("MOONSHOT_API_KEY is required for MoonshotOfficialClient.");
+        }
+        const url = options.baseUrl ||
+            process.env.MOONSHOT_BASE_URL ||
+            "https://api.moonshot.cn/v1";
+        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 ThinkingLevel enum to the K2-generation thinking configuration.
+     */
+    _convertThinkingLevelToThinkingConfig(thinkingLevel) {
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: { type: "disabled" },
+            [types_1.ThinkingLevel.LOW]: { type: "enabled", keep: "all" },
+            [types_1.ThinkingLevel.MEDIUM]: { type: "enabled", keep: "all" },
+            [types_1.ThinkingLevel.HIGH]: { type: "enabled", keep: "all" },
+            [types_1.ThinkingLevel.XHIGH]: { type: "enabled", keep: "all" },
+            [types_1.ThinkingLevel.MAX]: { type: "enabled", keep: "all" },
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ThinkingLevel enum to Kimi K3's reasoning_effort.
+     *
+     * K3 cannot disable reasoning, so NONE degrades to the lowest effort
+     * instead of throwing.
+     */
+    _convertThinkingLevelToReasoningEffort(thinkingLevel) {
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: "low",
+            [types_1.ThinkingLevel.LOW]: "low",
+            [types_1.ThinkingLevel.MEDIUM]: "high",
+            [types_1.ThinkingLevel.HIGH]: "high",
+            [types_1.ThinkingLevel.XHIGH]: "max",
+            [types_1.ThinkingLevel.MAX]: "max",
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to OpenAI's tool_choice format.
+     */
+    _convertToolChoice(toolChoice) {
+        if (toolChoice === "auto") {
+            return "auto";
+        }
+        else if (toolChoice === "none") {
+            return "none";
+        }
+        else if (toolChoice === "required" &&
+            !this._model.toLowerCase().includes("k2.")) {
+            return "required";
+        }
+        else {
+            // the K2 generation rejects "required"; forcing a specific tool is
+            // unsupported family-wide
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "tool_choice",
+                message: "Kimi does not support this tool_choice ('required' needs Kimi K3).",
+            });
+        }
+    }
+    /**
+     * Transform universal configuration to Kimi K3-specific configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const kimiConfig = {
+            model: this._model,
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (config.max_tokens !== undefined) {
+            kimiConfig.max_completion_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined && config.temperature !== 1.0) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "temperature",
+                message: "Kimi does not support setting temperature.",
+            });
+        }
+        if (config.thinking_level !== undefined) {
+            // the K2 generation configures thinking through extra_body and can disable
+            // it; K3 uses reasoning_effort and cannot
+            if (this._model.toLowerCase().includes("k2.")) {
+                kimiConfig.extra_body = kimiConfig.extra_body || {};
+                kimiConfig.extra_body.thinking =
+                    this._convertThinkingLevelToThinkingConfig(config.thinking_level);
+            }
+            else {
+                kimiConfig.reasoning_effort =
+                    this._convertThinkingLevelToReasoningEffort(config.thinking_level);
+            }
+        }
+        if (config.tools !== undefined) {
+            kimiConfig.tools = config.tools.map((tool) => ({
+                type: "function",
+                function: tool,
+            }));
+        }
+        if (config.tool_choice !== undefined) {
+            kimiConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "fast_mode",
+                message: "Kimi 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 Kimi.",
+            });
+        }
+        // K3 context caching is automatic; the K2 generation keys its prompt
+        // cache on trace_id
+        if (config.trace_id !== undefined &&
+            this._model.toLowerCase().includes("k2.")) {
+            kimiConfig.prompt_cache_key = config.trace_id;
+        }
+        return kimiConfig;
+    }
+    /**
+     * Transform universal message format to OpenAI's message format.
+     */
+    async transformUniMessageToModelInput(messages, signal) {
+        const openaiMessages = [];
+        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({
+                        type: "image_url",
+                        image_url: { url: base64Image },
+                    });
+                }
+                else if (item.type === "thinking.done") {
+                    thinking += item.thinking;
+                    thinkingFields.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({
+                                type: "image_url",
+                                image_url: { url: base64Image },
+                            });
+                        }
+                    }
+                    // the plain string is the form Moonshot's own tool-call examples send and 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;
+            }
+            if (thinking) {
+                // 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 (thinkingFields.size === 1 &&
+                    thinkingFields.has("reasoning_content")) {
+                    message.reasoning_content = thinking;
+                }
+                else if (thinkingFields.size === 1 &&
+                    thinkingFields.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 Kimi K3 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 || "",
+                        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 Kimi SDK with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const kimiConfig = this.transformUniConfigToModelConfig(options.config);
+        const kimiMessages = await this.transformUniMessageToModelInput(options.messages, options.signal);
+        if (options.config.system_prompt) {
+            kimiMessages.unshift({
+                role: "system",
+                content: options.config.system_prompt,
+            });
+        }
+        const params = {
+            ...kimiConfig,
+            messages: kimiMessages,
+            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.MoonshotOfficialClient = MoonshotOfficialClient;

package/dist/moonshot_official/index.d.ts

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

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

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

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

package/dist/openai_chat/client.d.ts

@@ -0,0 +1,67 @@
+import type { ChatCompletionChunk, ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * OpenAI Chat Completions-compatible client implementation.
+ */
+export declare class OpenaiChatClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize OpenAI-compatible chat client with model, API key, and base URL.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Detect MIME type from URL extension for image.
+     */
+    private _detectImageMimeType;
+    /**
+     * Convert image URL to base64-encoded data URL.
+     */
+    private _convertImageUrlToBase64;
+    /**
+     * Convert ToolChoice to OpenAI Chat Completions tool_choice format.
+     */
+    private _convertToolChoice;
+    /**
+     * Convert a fetched image to an image_url part, at the detail the API needs
+     * to read it.
+     */
+    private _convertImageUrl;
+    /**
+     * Transform universal configuration to OpenAI Chat Completions configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to OpenAI Chat Completions message format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], signal?: AbortSignal): Promise<ChatCompletionMessageParam[]>;
+    /**
+     * 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: ChatCompletionChunk): UniEvent;
+    /**
+     * Stream generate using OpenAI Chat Completions-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_chat/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/openai_chat/client.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,mBAAmB,EACnB,0BAA0B,EAE3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAML,SAAS,EACT,QAAQ,EACR,UAAU,EAEX,MAAM,UAAU,CAAC;AAOlB;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,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,oBAAoB;IAe5B;;OAEG;YACW,wBAAwB;IAqBtC;;OAEG;IAEH,OAAO,CAAC,kBAAkB;IAiB1B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IA6CvD;;OAEG;IACG,+BAA+B,CACnC,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,0BAA0B,EAAE,CAAC;IA6GxC;;;;;;OAMG;IACH,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAmH1E;;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;IA6B5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}