@prismshadow/mmsp 0.5.0

package/README.md

@@ -0,0 +1,121 @@
+# MMSP TypeScript Implementation
+
+This directory contains the TypeScript implementation of MMSP, mirroring the Python implementation in `src_py/`.
+
+## Building
+
+```bash
+make install  # Install dependencies
+make build    # Build TypeScript to JavaScript
+make lint     # Run ESLint
+make test     # Run tests
+```
+
+## Usage
+
+### Basic Client Usage
+
+```typescript
+import { AutoLLMClient } from "@prismshadow/mmsp";
+
+process.env.OPENAI_API_KEY = "your-openai-api-key";
+
+async function main() {
+  // The official OpenAI client, named by the model id's family
+  const client = new AutoLLMClient({ model: "gpt-5.5" });
+  // The same, spelled out, with the key given in code:
+  // const client = new AutoLLMClient({ model: "gpt-5.5", clientType: "openai-official", apiKey: "your-openai-api-key" });
+  // A compatible client, for any endpoint that serves OpenAI Chat Completions:
+  // const client = new AutoLLMClient({ model: "custom-model", clientType: "openai-chat", baseUrl: "http://127.0.0.1:8000/v1/", apiKey: "none" });
+  // For Gemini on Google Vertex AI, the service-account JSON key is the API key:
+  // const client = new AutoLLMClient({ model: "gemini-3.8-flash", apiKey: fs.readFileSync("service-account.json", "utf8") });
+
+  for await (const event of client.streamingResponseStateful({
+    message: {
+      role: "user",
+      content_items: [{ type: "text.done", text: "Hello!" }],
+    },
+    config: {},
+  })) {
+    console.log(event);
+  }
+}
+
+main().catch(console.error);
+```
+
+`clientType` names one of the official clients (`openai-official`, `anthropic-official`, `gemini-official`, `zai-official`, `moonshot-official`, `deepseek-official`, `minimax-official`) or one of the compatible clients (`openai-responses`, `openai-chat`, `openai-chat-vllm-adapter`, `openai-embedding`, `ant-messages`, `gemini-generate-content`). It may be omitted for a model id that begins with a known family (`gpt-`, `text-embedding-`, `claude-`, `gemini-`, `glm-`, `kimi-`, `deepseek-`, `minimax-`), which names its official client; any other id throws and asks for one.
+
+A Vertex AI service-account key is served through generateContent, because Vertex AI's Interactions endpoint serves none of the Gemini models; any other Gemini key uses the Interactions API. `clientType: "gemini-generate-content"` names generateContent explicitly, for gateways that proxy it.
+
+Both streaming methods yield `delta` events, each carrying exactly one content item, then exactly one `stop` event, always last, carrying `usage_metadata` and `finish_reason`. Each item streams as one or more `.delta` fragments (`text.delta`, `tool_call.delta`, …) followed by its complete `.done` item (`text.done`, `tool_call.done`, …); items never interleave.
+
+### History Management
+
+```typescript
+// Get current history
+const history = client.getHistory();
+
+// Clear all history
+client.clearHistory();
+
+// Replace history with a saved copy
+client.setHistory(history);
+```
+
+Messages hold complete items only, typed with a `.done` suffix. Item types without the suffix, saved before 0.5.0, are still accepted with a deprecation warning until 0.6.0; `normalizeLegacyMessages(messages)` converts stored messages.
+
+### Tracer Usage
+
+Save and browse conversation history with a web interface:
+
+```typescript
+import { Tracer } from "@prismshadow/mmsp/integration/tracer";
+
+// Create a tracer instance
+const tracer = new Tracer("./cache");
+
+// Save conversation history
+const model = "gpt-5.5";
+const history = [
+  { role: "user", content_items: [{ type: "text.done", text: "Hello!" }] },
+  {
+    role: "assistant",
+    content_items: [{ type: "text.done", text: "Hi there!" }],
+  },
+];
+const config = {};
+tracer.saveHistory(model, history, "session/conv_001", config);
+
+// Start web server to view saved conversations
+tracer.startWebServer("127.0.0.1", 25750);
+// Open http://127.0.0.1:25750 in your browser
+```
+
+### Playground Usage
+
+Interactive web interface for chatting with LLMs:
+
+```typescript
+import { startPlaygroundServer } from "@prismshadow/mmsp/integration/playground";
+
+// Start the playground server
+startPlaygroundServer("127.0.0.1", 25751);
+// Open http://127.0.0.1:25751 in your browser
+// Open http://127.0.0.1:25751/tracer/ to browse traces
+```
+
+## Examples
+
+Run the examples:
+
+```bash
+# Build the project
+npm run build
+
+# Run tracer example
+npm run tracer
+
+# Run playground example
+npm run playground
+```

package/dist/ant_messages/client.d.ts

@@ -0,0 +1,59 @@
+import { BetaMessageParam, BetaRawMessageStreamEvent } from "@anthropic-ai/sdk/resources/beta/messages";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * Anthropic Messages-compatible client implementation.
+ */
+export declare class AntMessagesClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize Anthropic Messages-compatible client with model, API key, and base URL.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Convert image URL to an Anthropic image source block.
+     */
+    private _convertImageUrlToSource;
+    /**
+     * Convert ThinkingLevel enum to the Messages API thinking config.
+     */
+    private _convertThinkingLevelToThinkingConfig;
+    /**
+     * Convert ToolChoice to the Messages API tool_choice format.
+     */
+    private _convertToolChoice;
+    /**
+     * Transform universal configuration to Anthropic Messages-compatible configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to the Messages API BetaMessageParam format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], _signal?: AbortSignal): BetaMessageParam[];
+    /**
+     * Transform one Messages API stream event into a universal event, identifying items by
+     * content block index.
+     */
+    transformModelOutputToUniEvent(modelOutput: BetaRawMessageStreamEvent): UniEvent;
+    /**
+     * Stream generate using an Anthropic Messages-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/ant_messages/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/ant_messages/client.ts"],"names":[],"mappings":"AAeA,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAEX,MAAM,UAAU,CAAC;AASlB;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,OAAO,CAAY;IAE3B;;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;IAoBD;;OAEG;IAEH,OAAO,CAAC,wBAAwB;IAgBhC;;OAEG;IACH,OAAO,CAAC,qCAAqC;IAgC7C;;OAEG;IAEH,OAAO,CAAC,kBAAkB;IAoB1B;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IA2EvD;;OAEG;IACH,+BAA+B,CAC7B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE,WAAW,GACpB,gBAAgB,EAAE;IAmErB;;;OAGG;IACH,8BAA8B,CAC5B,WAAW,EAAE,yBAAyB,GACrC,QAAQ;IAoIX;;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;IAsB5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}

package/dist/ant_messages/client.js

@@ -0,0 +1,419 @@
+"use strict";
+// Copyright 2025 Prism Shadow. and/or its affiliates
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntMessagesClient = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const baseClient_1 = require("../baseClient");
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const REDACTED_THINKING = "_REDACTED_THINKING";
+/**
+ * Anthropic Messages-compatible client implementation.
+ */
+class AntMessagesClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize Anthropic Messages-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: "ANTHROPIC_API_KEY", baseUrl: "ANTHROPIC_BASE_URL" });
+        // send the credential through both header conventions: Anthropic and DeepSeek read
+        // x-api-key while gateways such as OpenRouter and Z.AI read Authorization: Bearer. With no
+        // credential the token has to be null, not undefined, or the SDK fills it from
+        // ANTHROPIC_AUTH_TOKEN.
+        this._client = new sdk_1.default({
+            apiKey: key,
+            authToken: key ?? null,
+            baseURL: url,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    /**
+     * Convert image URL to an Anthropic image source block.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertImageUrlToSource(url) {
+        if (url.startsWith("data:")) {
+            const match = url.match(/^data:([^;]+);base64,(.+)$/);
+            if (!match) {
+                throw new Error(`Invalid base64 image: ${url}`);
+            }
+            return {
+                type: "image",
+                source: { type: "base64", media_type: match[1], data: match[2] },
+            };
+        }
+        return { type: "image", source: { type: "url", url } };
+    }
+    /**
+     * Convert ThinkingLevel enum to the Messages API thinking config.
+     */
+    _convertThinkingLevelToThinkingConfig(thinkingLevel) {
+        // NONE is explicit rather than omitted because some servers (e.g. Z.AI) think by default
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: { thinking: { type: "disabled" } },
+            [types_1.ThinkingLevel.LOW]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "low" },
+            },
+            [types_1.ThinkingLevel.MEDIUM]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "medium" },
+            },
+            [types_1.ThinkingLevel.HIGH]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "high" },
+            },
+            [types_1.ThinkingLevel.XHIGH]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "xhigh" },
+            },
+            [types_1.ThinkingLevel.MAX]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "max" },
+            },
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to the Messages API tool_choice format.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertToolChoice(toolChoice) {
+        if (Array.isArray(toolChoice)) {
+            if (toolChoice.length > 1) {
+                throw new errors_1.UnsupportedParameterError({
+                    client: this.constructor.name,
+                    parameter: "tool_choice",
+                    message: "The Messages API does not support multiple tool choices.",
+                });
+            }
+            return { type: "tool", name: toolChoice[0] };
+        }
+        else if (toolChoice === "none") {
+            return { type: "none" };
+        }
+        else if (toolChoice === "auto") {
+            return { type: "auto" };
+        }
+        else if (toolChoice === "required") {
+            return { type: "any" };
+        }
+    }
+    /**
+     * Transform universal configuration to Anthropic Messages-compatible configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const antConfig = { model: this._model, stream: true };
+        if (config.system_prompt !== undefined) {
+            antConfig.system = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            antConfig.max_tokens = config.max_tokens;
+        }
+        else {
+            // the Messages API requires max_tokens to be specified
+            antConfig.max_tokens = 64000;
+        }
+        if (config.temperature !== undefined) {
+            antConfig.temperature = config.temperature;
+        }
+        if (config.thinking_level !== undefined) {
+            Object.assign(antConfig, this._convertThinkingLevelToThinkingConfig(config.thinking_level));
+        }
+        if (config.thinking_summary !== undefined) {
+            // display lives on the thinking block, so a summary asked for on its own selects
+            // adaptive thinking. A disabled block is the one place it cannot ride along --
+            // "thinking.disabled.display: Extra inputs are not permitted" (400, verified live
+            // 2026-09-03) -- and thinking_level NONE disables thinking, leaving nothing to show.
+            antConfig.thinking = antConfig.thinking ?? { type: "adaptive" };
+            if (antConfig.thinking.type !== "disabled") {
+                antConfig.thinking.display = config.thinking_summary
+                    ? "summarized"
+                    : "omitted";
+            }
+        }
+        // Convert tools to the Messages API tool schema
+        if (config.tools !== undefined) {
+            antConfig.tools = config.tools.map((tool) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const antTool = {};
+                for (const [key, value] of Object.entries(tool)) {
+                    antTool[key.replace("parameters", "input_schema")] = value;
+                }
+                return antTool;
+            });
+        }
+        // Convert tool_choice
+        if (config.tool_choice !== undefined) {
+            antConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            antConfig.speed = "fast";
+            antConfig.betas = ["fast-mode-2026-02-01"];
+        }
+        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 Messages API.",
+            });
+        }
+        return antConfig;
+    }
+    /**
+     * Transform universal message format to the Messages API BetaMessageParam format.
+     */
+    transformUniMessageToModelInput(messages, _signal) {
+        const antMessages = [];
+        for (const msg of messages) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contentBlocks = [];
+            for (const item of msg.content_items) {
+                if (item.type === "text.done") {
+                    contentBlocks.push({ type: "text", text: item.text });
+                }
+                else if (item.type === "image_url.done") {
+                    contentBlocks.push(this._convertImageUrlToSource(item.image_url));
+                }
+                else if (item.type === "thinking.done") {
+                    if (item.thinking === REDACTED_THINKING) {
+                        contentBlocks.push({
+                            type: "redacted_thinking",
+                            data: item.fidelity?.signature,
+                        });
+                    }
+                    else {
+                        // third-party servers accept thinking without a signature, but the
+                        // official API requires the one it emitted
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const thinkingBlock = {
+                            type: "thinking",
+                            thinking: item.thinking,
+                        };
+                        if (item.fidelity?.signature != null) {
+                            thinkingBlock.signature = item.fidelity.signature;
+                        }
+                        contentBlocks.push(thinkingBlock);
+                    }
+                }
+                else if (item.type === "tool_call.done") {
+                    contentBlocks.push({
+                        type: "tool_use",
+                        id: item.tool_call_id,
+                        name: item.name,
+                        input: 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.");
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const toolResult = [{ type: "text", text: item.text }];
+                    if (item.images) {
+                        for (const imageUrl of item.images) {
+                            toolResult.push(this._convertImageUrlToSource(imageUrl));
+                        }
+                    }
+                    contentBlocks.push({
+                        type: "tool_result",
+                        content: toolResult,
+                        tool_use_id: item.tool_call_id,
+                    });
+                }
+                else {
+                    throw new Error(`Unknown item: ${JSON.stringify(item)}`);
+                }
+            }
+            antMessages.push({ role: msg.role, content: contentBlocks });
+        }
+        return antMessages;
+    }
+    /**
+     * Transform one Messages API stream event into a universal event, identifying items by
+     * content block index.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        let eventType = "delta";
+        const contentItems = [];
+        let usageMetadata = null;
+        let finishReason = null;
+        const antEventType = modelOutput.type;
+        if (antEventType === "content_block_start") {
+            const itemId = String(modelOutput.index);
+            const block = modelOutput.content_block;
+            if (block.type === "tool_use") {
+                contentItems.push({
+                    type: "tool_call.delta",
+                    name: block.name,
+                    arguments: "",
+                    tool_call_id: block.id,
+                    fidelity: { item_id: itemId },
+                });
+            }
+            else if (block.type === "redacted_thinking") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: REDACTED_THINKING,
+                    fidelity: { item_id: itemId, signature: block.data },
+                });
+            }
+        }
+        else if (antEventType === "content_block_delta") {
+            const itemId = String(modelOutput.index);
+            const delta = modelOutput.delta;
+            if (delta.type === "thinking_delta") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: delta.thinking,
+                    fidelity: { item_id: itemId },
+                });
+            }
+            else if (delta.type === "text_delta") {
+                contentItems.push({
+                    type: "text.delta",
+                    text: delta.text,
+                    fidelity: { item_id: itemId },
+                });
+            }
+            else if (delta.type === "input_json_delta") {
+                contentItems.push({
+                    type: "tool_call.delta",
+                    name: "",
+                    arguments: delta.partial_json,
+                    tool_call_id: "",
+                    fidelity: { item_id: itemId },
+                });
+            }
+            else if (delta.type === "signature_delta") {
+                // the last delta of a thinking block: its signature
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: "",
+                    fidelity: { item_id: itemId, signature: delta.signature },
+                });
+            }
+        }
+        else if (antEventType === "message_start") {
+            eventType = "stop";
+            const usage = modelOutput.message.usage;
+            if (usage) {
+                const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+                usageMetadata = {
+                    cached_tokens: usage.cache_read_input_tokens,
+                    prompt_tokens: usage.input_tokens + cacheCreationTokens,
+                    thoughts_tokens: null,
+                    response_tokens: null,
+                };
+            }
+        }
+        else if (antEventType === "message_delta") {
+            eventType = "stop";
+            const stopReasonMapping = {
+                end_turn: "stop",
+                max_tokens: "length",
+                stop_sequence: "stop",
+                tool_use: "tool_call",
+            };
+            const stopReason = modelOutput.delta.stop_reason;
+            if (stopReason) {
+                finishReason = stopReasonMapping[stopReason] || "unknown";
+            }
+            const usage = modelOutput.usage;
+            if (usage) {
+                // gateways report zero usage in message_start and the full counts here, so the
+                // delta also carries the input-side fields (null on servers that omit them)
+                const promptTokens = usage.input_tokens != null
+                    ? usage.input_tokens + (usage.cache_creation_input_tokens || 0)
+                    : null;
+                const thinkingTokens = 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                usage.output_tokens_details?.thinking_tokens ?? null;
+                usageMetadata = (0, utils_1.fixOpenrouterUsageMetadata)({
+                    cached_tokens: usage.cache_read_input_tokens ?? null,
+                    prompt_tokens: promptTokens,
+                    thoughts_tokens: thinkingTokens,
+                    response_tokens: usage.output_tokens - (thinkingTokens || 0),
+                }, this._client.baseURL);
+            }
+        }
+        else if ([
+            "content_block_stop",
+            "message_stop",
+            "text",
+            "thinking",
+            "signature",
+            "input_json",
+            "ping",
+        ].includes(antEventType)) {
+            // a block needs no stop: it is done when the next one begins or the stream ends. The SDK
+            // drops the "ping" heartbeat at the SSE layer; it reaches here only from gateways that
+            // relabel it onto another event
+        }
+        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 Anthropic Messages-compatible API with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const antConfig = this.transformUniConfigToModelConfig(options.config);
+        const antMessages = this.transformUniMessageToModelInput(options.messages, options.signal);
+        const stream = (await this._client.beta.messages.create({
+            ...antConfig,
+            messages: antMessages,
+        }, {
+            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.AntMessagesClient = AntMessagesClient;

package/dist/ant_messages/index.d.ts

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

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

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

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