@prismshadow/mmsp 0.5.0

package/dist/legacy.d.ts

@@ -0,0 +1,13 @@
+import { UniMessage } from "./types";
+/**
+ * Convert messages recorded before 0.5.0 to the current content item types.
+ *
+ * A legacy item type such as `text` becomes `text.done`, and a stray `partial_tool_call`
+ * is dropped. Messages already in the current format are returned as they are; a message
+ * that needed converting is returned as a copy, so the caller's data is never modified.
+ *
+ * @param messages - Messages that may carry legacy content item types
+ * @returns The messages with current content item types only
+ */
+export declare function normalizeLegacyMessages(messages: UniMessage[]): UniMessage[];
+//# sourceMappingURL=legacy.d.ts.map

package/dist/legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.d.ts","sourceRoot":"","sources":["../src/legacy.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAerC;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAiC5E"}

package/dist/legacy.js

@@ -0,0 +1,59 @@
+"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.normalizeLegacyMessages = normalizeLegacyMessages;
+const LEGACY_ITEM_TYPES = new Set([
+    "text",
+    "image_url",
+    "inline_data",
+    "thinking",
+    "inline_thinking",
+    "tool_call",
+    "tool_result",
+    "embedding",
+]);
+let warned = false;
+/**
+ * Convert messages recorded before 0.5.0 to the current content item types.
+ *
+ * A legacy item type such as `text` becomes `text.done`, and a stray `partial_tool_call`
+ * is dropped. Messages already in the current format are returned as they are; a message
+ * that needed converting is returned as a copy, so the caller's data is never modified.
+ *
+ * @param messages - Messages that may carry legacy content item types
+ * @returns The messages with current content item types only
+ */
+function normalizeLegacyMessages(messages) {
+    return messages.map((message) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const items = message.content_items;
+        if (!items.some((item) => LEGACY_ITEM_TYPES.has(item.type) || item.type === "partial_tool_call")) {
+            return message;
+        }
+        if (!warned) {
+            warned = true;
+            process.emitWarning("Content item types without the .done suffix (text, tool_call, ...) are deprecated " +
+                "and will stop being accepted in MMSP 0.6.0; use text.done, tool_call.done, ...", "DeprecationWarning");
+        }
+        return {
+            ...message,
+            content_items: items
+                .filter((item) => item.type !== "partial_tool_call")
+                .map((item) => LEGACY_ITEM_TYPES.has(item.type)
+                ? { ...item, type: `${item.type}.done` }
+                : item),
+        };
+    });
+}

package/dist/minimax_official/client.d.ts

@@ -0,0 +1,43 @@
+import type { ResponseStreamEvent } from "openai/resources/responses/responses";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/** MiniMax M3 client using MiniMax's Responses API. */
+export declare class MiniMaxOfficialClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    private _convertThinkingLevelToEffort;
+    private _convertToolChoice;
+    /**
+     * Transform universal configuration to MiniMax's Responses API payload.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal messages to MiniMax Responses input items.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[]): any[];
+    /**
+     * Transform one MiniMax stream event into a universal event, identifying items by output item id.
+     */
+    transformModelOutputToUniEvent(modelOutput: ResponseStreamEvent): UniEvent;
+    /**
+     * Stream MiniMax Responses events 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/minimax_official/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/minimax_official/client.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAEX,MAAM,UAAU,CAAC;AAOlB,uDAAuD;AACvD,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,OAAO,CAAS;gBAEZ,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;IAiBD,OAAO,CAAC,6BAA6B;IAerC,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IA6DvD;;OAEG;IAEH,+BAA+B,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,GAAG,EAAE;IAuF9D;;OAEG;IACH,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAuG1E;;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;IAoB5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}

package/dist/minimax_official/client.js

@@ -0,0 +1,346 @@
+"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.MiniMaxOfficialClient = 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");
+const DEFAULT_BASE_URL = "https://api.minimax.io/v1";
+/** MiniMax M3 client using MiniMax's Responses API. */
+class MiniMaxOfficialClient extends baseClient_1.LLMClient {
+    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 MiniMax host, so resolve the key here and fail loudly instead.
+        const apiKey = options.apiKey || process.env.MINIMAX_API_KEY;
+        if (!apiKey) {
+            throw new Error("MINIMAX_API_KEY is required for MiniMaxOfficialClient.");
+        }
+        this._client = new openai_1.default({
+            apiKey,
+            baseURL: options.baseUrl || process.env.MINIMAX_BASE_URL || DEFAULT_BASE_URL,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    _convertThinkingLevelToEffort(thinkingLevel) {
+        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]: "high",
+            // MiniMax stops at "high"
+            [types_1.ThinkingLevel.MAX]: "high",
+        };
+        return mapping[thinkingLevel];
+    }
+    _convertToolChoice(toolChoice) {
+        if (toolChoice === "auto" || toolChoice === "none") {
+            return toolChoice;
+        }
+        throw new errors_1.UnsupportedParameterError({
+            client: this.constructor.name,
+            parameter: "tool_choice",
+            message: "MiniMax Responses API does not support required or named tool selection.",
+        });
+    }
+    /**
+     * Transform universal configuration to MiniMax's Responses API payload.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const minimaxConfig = { model: this._model, store: false };
+        if (config.system_prompt !== undefined) {
+            minimaxConfig.instructions = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            minimaxConfig.max_output_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined) {
+            // Written as a positive range test so NaN is rejected too: every `<`/`>` comparison against
+            // NaN is false, which would let it through to the provider as a null temperature.
+            if (!(config.temperature >= 0 && config.temperature <= 1)) {
+                throw new errors_1.UnsupportedParameterError({
+                    client: this.constructor.name,
+                    parameter: "temperature",
+                    message: "MiniMax Responses API does not support temperatures outside the range 0 to 1.",
+                });
+            }
+            minimaxConfig.temperature = config.temperature;
+        }
+        if (config.thinking_level !== undefined) {
+            minimaxConfig.reasoning = {
+                effort: this._convertThinkingLevelToEffort(config.thinking_level),
+            };
+        }
+        if (config.tools !== undefined) {
+            minimaxConfig.tools = config.tools.map((tool) => ({
+                type: "function",
+                ...tool,
+            }));
+        }
+        if (config.tool_choice !== undefined) {
+            minimaxConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            minimaxConfig.service_tier = "priority";
+        }
+        if (config.prompt_caching === types_1.PromptCaching.DISABLE) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "prompt_caching",
+                message: "MiniMax Responses API does not support disabling its automatic prompt cache.",
+            });
+        }
+        if (config.prompt_caching === types_1.PromptCaching.ENHANCE) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "prompt_caching",
+                message: "MiniMax Responses API does not support enhancing its automatic prompt cache.",
+            });
+        }
+        return minimaxConfig;
+    }
+    /**
+     * Transform universal messages to MiniMax Responses input items.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniMessageToModelInput(messages) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const inputList = [];
+        for (const message of messages) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let contentItems = [];
+            for (const item of message.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 order the model produced
+                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: message.role,
+                        content: contentItems,
+                    });
+                    contentItems = [];
+                }
+                if (item.type === "text.done") {
+                    contentItems.push({
+                        type: message.role === "user" ? "input_text" : "output_text",
+                        text: item.text,
+                    });
+                }
+                else if (item.type === "image_url.done") {
+                    contentItems.push({ type: "input_image", image_url: item.image_url });
+                }
+                else if (item.type === "thinking.done") {
+                    // MiniMax accepts a reasoning item rebuilt from the thinking text alone, so no fidelity
+                    // is recorded for it.
+                    inputList.push({
+                        type: "reasoning",
+                        content: item.thinking
+                            ? [{ type: "reasoning_text", text: item.thinking }]
+                            : [],
+                    });
+                }
+                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 === undefined) {
+                        throw new Error("tool_call_id is required for tool result.");
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    let output = item.text;
+                    if (item.images?.length) {
+                        output = [{ type: "input_text", text: item.text }];
+                        for (const imageUrl of item.images) {
+                            output.push({ type: "input_image", image_url: imageUrl });
+                        }
+                    }
+                    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: message.role,
+                    content: contentItems,
+                });
+            }
+        }
+        return inputList;
+    }
+    /**
+     * Transform one MiniMax stream event into a universal event, identifying items by output item id.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        let eventType = "delta";
+        const contentItems = [];
+        let usageMetadata = null;
+        let finishReason = null;
+        const minimaxEventType = modelOutput.type;
+        if (minimaxEventType === "response.output_text.delta") {
+            contentItems.push({
+                type: "text.delta",
+                text: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (minimaxEventType === "response.reasoning_text.delta") {
+            contentItems.push({
+                type: "thinking.delta",
+                thinking: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (minimaxEventType === "response.output_item.added") {
+            // a message or reasoning item begins: an empty delta under its id ends the item before it
+            if (modelOutput.item.type === "message") {
+                contentItems.push({
+                    type: "text.delta",
+                    text: "",
+                    fidelity: { item_id: modelOutput.item.id },
+                });
+            }
+            else if (modelOutput.item.type === "reasoning") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: "",
+                    fidelity: { item_id: modelOutput.item.id },
+                });
+            }
+        }
+        else if (minimaxEventType === "response.output_item.done") {
+            // MiniMax's tool calls are read from the completed item alone: the argument deltas are
+            // left unread rather than reconciled against this item, and the call streams as one
+            // delta carrying the whole arguments, so what a consumer streams and the call it is
+            // handed are one and the same.
+            const item = modelOutput.item;
+            if (item.type === "function_call") {
+                contentItems.push({
+                    type: "tool_call.delta",
+                    name: item.name,
+                    // a server may complete a call without its arguments field
+                    arguments: item.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 (minimaxEventType === "response.completed" ||
+            minimaxEventType === "response.incomplete") {
+            eventType = "stop";
+            const response = modelOutput.response;
+            const finishReasonMapping = {
+                completed: "stop",
+                incomplete: "length",
+            };
+            finishReason = finishReasonMapping[response.status ?? ""] ?? "unknown";
+            if (response.usage) {
+                // MiniMax drops the detail blocks on truncated responses, so default them 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.reasoning_text.done",
+            "response.function_call_arguments.delta",
+            "response.function_call_arguments.done",
+            "response.content_part.added",
+            "response.content_part.done",
+            // gateway heartbeat on long generations; carries no content
+            "keepalive",
+        ].includes(minimaxEventType) &&
+            (0, utils_1.isDebugEnabled)()) {
+            throw new Error(`Unknown output: ${JSON.stringify(modelOutput)}`);
+        }
+        return {
+            role: "assistant",
+            event_type: eventType,
+            content_items: contentItems,
+            usage_metadata: usageMetadata,
+            finish_reason: finishReason,
+        };
+    }
+    /**
+     * Stream MiniMax Responses events with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const minimaxConfig = this.transformUniConfigToModelConfig(options.config);
+        const inputList = this.transformUniMessageToModelInput(options.messages);
+        // MiniMax accepts output_text assistant inputs and function tools without OpenAI's required
+        // strict field, so narrow the compatibility cast to this boundary.
+        const params = {
+            ...minimaxConfig,
+            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.MiniMaxOfficialClient = MiniMaxOfficialClient;

package/dist/minimax_official/index.d.ts

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

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

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

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

package/dist/moonshot_official/client.d.ts

@@ -0,0 +1,73 @@
+import type { ChatCompletionChunk, ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * Kimi K3-specific LLM client implementation using OpenAI-compatible API (also serves K2.5 and K2.6).
+ */
+export declare class MoonshotOfficialClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize Kimi K3 client with model and API key.
+     */
+    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 ThinkingLevel enum to the K2-generation thinking configuration.
+     */
+    private _convertThinkingLevelToThinkingConfig;
+    /**
+     * Convert ThinkingLevel enum to Kimi K3's reasoning_effort.
+     *
+     * K3 cannot disable reasoning, so NONE degrades to the lowest effort
+     * instead of throwing.
+     */
+    private _convertThinkingLevelToReasoningEffort;
+    /**
+     * Convert ToolChoice to OpenAI's tool_choice format.
+     */
+    private _convertToolChoice;
+    /**
+     * Transform universal configuration to Kimi K3-specific configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to OpenAI's message format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], signal?: AbortSignal): Promise<ChatCompletionMessageParam[]>;
+    /**
+     * 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: ChatCompletionChunk): UniEvent;
+    /**
+     * Stream generate using Kimi SDK 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/moonshot_official/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/moonshot_official/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,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAEX,MAAM,UAAU,CAAC;AAGlB;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,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;IAsBD;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;YACW,wBAAwB;IAqBtC;;OAEG;IACH,OAAO,CAAC,qCAAqC;IAc7C;;;;;OAKG;IACH,OAAO,CAAC,sCAAsC;IAc9C;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsB1B;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IA2EvD;;OAEG;IACG,+BAA+B,CACnC,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,0BAA0B,EAAE,CAAC;IA+GxC;;;;;;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"}