@prismshadow/mmsp 0.5.0

package/dist/anthropic_official/client.d.ts

@@ -0,0 +1,63 @@
+import { BetaMessageParam, BetaRawMessageStreamEvent } from "@anthropic-ai/sdk/resources/beta/messages";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * Claude 5-specific LLM client implementation (also serves Claude 4.6 through 4.8).
+ */
+export declare class AnthropicOfficialClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    private _use_bedrock;
+    /**
+     * Initialize Claude 5 client with model and API key.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Convert image URL to image source.
+     *
+     * Bedrock does not support image url sources, so we need to fetch the image bytes and encode them.
+     */
+    private _convertImageUrlToSource;
+    /**
+     * Convert ThinkingLevel enum to Claude's adaptive thinking config.
+     */
+    private _generation;
+    private _convertThinkingLevelToThinkingConfig;
+    /**
+     * Convert ToolChoice to Claude's tool_choice format.
+     */
+    private _convertToolChoice;
+    /**
+     * Transform universal configuration to Claude-specific configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to Claude's MessageParam format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], signal?: AbortSignal): Promise<BetaMessageParam[]>;
+    /**
+     * Transform one Claude stream event into a universal event, identifying items by content
+     * block index.
+     */
+    transformModelOutputToUniEvent(modelOutput: BetaRawMessageStreamEvent): UniEvent;
+    /**
+     * Stream generate using Claude 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/anthropic_official/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/anthropic_official/client.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK1C,OAAO,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAEX,MAAM,UAAU,CAAC;AAelB;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IACpD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,YAAY,CAAU;IAE9B;;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;IAuCD;;;;OAIG;YACW,wBAAwB;IA8CtC;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,qCAAqC;IA6C7C;;OAEG;IAEH,OAAO,CAAC,kBAAkB;IA6B1B;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IAoGvD;;OAEG;IACG,+BAA+B,CACnC,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAqE9B;;;OAGG;IACH,8BAA8B,CAC5B,WAAW,EAAE,yBAAyB,GACrC,QAAQ;IAwHX;;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;IAmD5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAgBtC"}

package/dist/anthropic_official/client.js

@@ -0,0 +1,540 @@
+"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.AnthropicOfficialClient = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const bedrock_sdk_1 = __importDefault(require("@anthropic-ai/bedrock-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";
+// Generations told apart by explicit version, matched anywhere in the id so Bedrock's
+// anthropic.claude-opus-5-5 counts too. Opus 5.5 and Fable 5.1 always think: "disabled" and
+// "between_tools" return 400. Sonnet 5.5 drops only up-front thinking, with "between_tools".
+const ALWAYS_THINKING = ["opus-5-5", "fable-5-1"];
+const BETWEEN_TOOLS = ["sonnet-5-5"];
+// The 2026-09 generation returns 400 for tool_choice "any" and "tool".
+const NO_FORCED_TOOL_CHOICE = ["opus-5-5", "sonnet-5-5", "fable-5-1"];
+// These reject the speed parameter ("does not support the `speed` parameter").
+const NO_FAST_MODE = ["4-6", "sonnet-5-5", "fable-5-1"];
+/**
+ * Claude 5-specific LLM client implementation (also serves Claude 4.6 through 4.8).
+ */
+class AnthropicOfficialClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize Claude 5 client with model and API key.
+     */
+    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" });
+        if (url && url.startsWith("bedrock://")) {
+            // example: bedrock://us-east-1
+            const region = url.replace("bedrock://", "");
+            const [accessKey, secretKey] = (key || "").split(",");
+            const bedrock = new bedrock_sdk_1.default({
+                awsSecretKey: secretKey,
+                awsAccessKey: accessKey,
+                awsRegion: region,
+                defaultHeaders: options.defaultHeaders,
+            });
+            // AnthropicBedrock's options type leaves out apiKey and authToken, yet the Anthropic client
+            // it extends still fills both from ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN and sends them
+            // to AWS beside the SigV4 signature, so clear them: the AWS credentials sign alone.
+            bedrock.apiKey = null;
+            bedrock.authToken = null;
+            this._client = bedrock;
+            this._use_bedrock = true;
+        }
+        else {
+            this._client = new sdk_1.default({
+                apiKey: key,
+                // null, not undefined: the SDK fills an undefined authToken from ANTHROPIC_AUTH_TOKEN and
+                // sends it as Authorization: Bearer beside the key, to whatever base URL this client uses
+                authToken: null,
+                baseURL: url,
+                defaultHeaders: options.defaultHeaders,
+            });
+            this._use_bedrock = false;
+        }
+    }
+    /**
+     * Convert image URL to image source.
+     *
+     * Bedrock does not support image url sources, so we need to fetch the image bytes and encode them.
+     */
+    async _convertImageUrlToSource(url, signal) {
+        if (url.startsWith("data:")) {
+            const match = url.match(/data:([^;]+);base64,(.+)/);
+            if (match) {
+                const mediaType = match[1];
+                const base64Data = match[2];
+                return {
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: mediaType,
+                        data: base64Data,
+                    },
+                };
+            }
+            else {
+                throw new Error(`Invalid base64 image: ${url}`);
+            }
+        }
+        else if (this._use_bedrock) {
+            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 mime_type = response.headers.get("content-type") || "image/jpeg";
+            return {
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: mime_type,
+                    data: buffer.toString("base64"),
+                },
+            };
+        }
+        else {
+            return { type: "image", source: { type: "url", url } };
+        }
+    }
+    /**
+     * Convert ThinkingLevel enum to Claude's adaptive thinking config.
+     */
+    _generation(versions) {
+        return versions.some((version) => this._model.includes(version));
+    }
+    _convertThinkingLevelToThinkingConfig(thinkingLevel) {
+        // nothing turns thinking off on ALWAYS_THINKING, so NONE takes the least of it
+        const none = this._generation(ALWAYS_THINKING)
+            ? { thinking: { type: "adaptive" }, output_config: { effort: "low" } }
+            : this._generation(BETWEEN_TOOLS)
+                ? { thinking: { type: "between_tools" } }
+                : {}; // omit thinking config
+        const mapping = {
+            [types_1.ThinkingLevel.NONE]: none,
+            [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" },
+            },
+            // Claude 4.6 has no xhigh effort, so XHIGH degrades to the closest supported level
+            [types_1.ThinkingLevel.XHIGH]: {
+                thinking: { type: "adaptive" },
+                output_config: {
+                    effort: this._model.includes("4-6") ? "high" : "xhigh",
+                },
+            },
+            // every model this client serves is 4.6 or later, and max spans that whole range
+            [types_1.ThinkingLevel.MAX]: {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "max" },
+            },
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to Claude's tool_choice format.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertToolChoice(toolChoice) {
+        if ((toolChoice === "required" || Array.isArray(toolChoice)) &&
+            this._generation(NO_FORCED_TOOL_CHOICE)) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "tool_choice",
+                message: `${this._model} does not support forcing a tool call; use auto and name the tool in the prompt.`,
+            });
+        }
+        if (Array.isArray(toolChoice)) {
+            if (toolChoice.length > 1) {
+                throw new errors_1.UnsupportedParameterError({
+                    client: this.constructor.name,
+                    parameter: "tool_choice",
+                    message: "Claude supports only one tool choice.",
+                });
+            }
+            return { type: "any", 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 Claude-specific configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const claudeConfig = {
+            model: this._model,
+            stream: true,
+        };
+        if (config.system_prompt !== undefined) {
+            claudeConfig.system = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            claudeConfig.max_tokens = config.max_tokens;
+        }
+        else {
+            claudeConfig.max_tokens = 64000;
+        }
+        if (config.temperature !== undefined && config.temperature !== 1.0) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "temperature",
+                message: "Claude models do not support setting temperature; the API dropped it " +
+                    "starting with the 4.7 generation and the unified client rejects it for the whole family.",
+            });
+        }
+        if (config.thinking_level !== undefined) {
+            Object.assign(claudeConfig, 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, which is what this family runs by default anyway; a block
+            // carrying display but no output_config is accepted on 4.6 through 5 (verified
+            // live 2026-09-03). NONE omits the block, so the request lands on that default.
+            claudeConfig.thinking = claudeConfig.thinking ?? { type: "adaptive" };
+            // between_tools takes no display: its updates between tool calls always carry their text
+            if (claudeConfig.thinking.type !== "between_tools") {
+                claudeConfig.thinking.display = config.thinking_summary
+                    ? "summarized"
+                    : "omitted";
+            }
+        }
+        if (config.tools !== undefined) {
+            const claudeTools = [];
+            for (const tool of config.tools) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const claudeTool = {};
+                for (const [key, value] of Object.entries(tool)) {
+                    claudeTool[key.replace("parameters", "input_schema")] = value;
+                }
+                claudeTools.push(claudeTool);
+            }
+            claudeConfig.tools = claudeTools;
+        }
+        if (config.tool_choice !== undefined) {
+            claudeConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            if (this._use_bedrock) {
+                throw new errors_1.UnsupportedParameterError({
+                    client: this.constructor.name,
+                    parameter: "fast_mode",
+                    message: "Bedrock does not support fast mode.",
+                });
+            }
+            if (this._generation(NO_FAST_MODE)) {
+                throw new errors_1.UnsupportedParameterError({
+                    client: this.constructor.name,
+                    parameter: "fast_mode",
+                    message: `${this._model} does not support fast mode.`,
+                });
+            }
+            claudeConfig.speed = "fast";
+            claudeConfig.betas = ["fast-mode-2026-02-01"];
+        }
+        // Add cache_control if prompt caching is enabled
+        // TODO: wait for bedrock to support cache_control in config
+        if (!this._use_bedrock) {
+            const promptCaching = config.prompt_caching || types_1.PromptCaching.ENABLE;
+            if (promptCaching === types_1.PromptCaching.ENABLE) {
+                claudeConfig.cache_control = { type: "ephemeral" };
+            }
+            else if (promptCaching === types_1.PromptCaching.ENHANCE) {
+                claudeConfig.cache_control = { type: "ephemeral", ttl: "1h" };
+            }
+        }
+        return claudeConfig;
+    }
+    /**
+     * Transform universal message format to Claude's MessageParam format.
+     */
+    async transformUniMessageToModelInput(messages, signal) {
+        const claudeMessages = [];
+        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") {
+                    const imageUrl = item.image_url;
+                    contentBlocks.push(await this._convertImageUrlToSource(imageUrl, signal));
+                }
+                else if (item.type === "thinking.done") {
+                    if (item.thinking === REDACTED_THINKING) {
+                        contentBlocks.push({
+                            type: "redacted_thinking",
+                            data: item.fidelity?.signature,
+                        });
+                    }
+                    else {
+                        contentBlocks.push({
+                            type: "thinking",
+                            thinking: item.thinking,
+                            signature: item.fidelity?.signature,
+                        });
+                    }
+                }
+                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(await this._convertImageUrlToSource(imageUrl, signal));
+                        }
+                    }
+                    contentBlocks.push({
+                        type: "tool_result",
+                        content: toolResult,
+                        tool_use_id: item.tool_call_id,
+                    });
+                }
+                else {
+                    throw new Error(`Unknown item: ${JSON.stringify(item)}`);
+                }
+            }
+            claudeMessages.push({
+                role: msg.role,
+                content: contentBlocks,
+            });
+        }
+        return claudeMessages;
+    }
+    /**
+     * Transform one Claude 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 claudeEventType = modelOutput.type;
+        if (claudeEventType === "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 (claudeEventType === "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 (claudeEventType === "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 || null,
+                    prompt_tokens: usage.input_tokens + cacheCreationTokens,
+                    thoughts_tokens: null,
+                    response_tokens: null,
+                };
+            }
+        }
+        else if (claudeEventType === "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";
+            }
+            if (modelOutput.usage) {
+                // message_delta reports the output tokens; the input side came with message_start
+                usageMetadata = {
+                    cached_tokens: null,
+                    prompt_tokens: null,
+                    thoughts_tokens: null,
+                    response_tokens: modelOutput.usage.output_tokens,
+                };
+            }
+        }
+        else if ([
+            "content_block_stop",
+            "message_stop",
+            "text",
+            "thinking",
+            "signature",
+            "input_json",
+            "ping",
+        ].includes(claudeEventType)) {
+            // 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 Claude SDK with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const claudeConfig = this.transformUniConfigToModelConfig(options.config);
+        const claudeMessages = await this.transformUniMessageToModelInput(options.messages, options.signal);
+        // Add cache_control to last user message's last item if enabled
+        // TODO: remove after bedrock supports cache_control in config
+        if (this._use_bedrock) {
+            const promptCaching = options.config.prompt_caching || types_1.PromptCaching.ENABLE;
+            if (promptCaching !== types_1.PromptCaching.DISABLE &&
+                claudeMessages.length > 0) {
+                try {
+                    const reversedMessages = [...claudeMessages].reverse();
+                    const lastUserMessage = reversedMessages.find((x) => x.role === "user");
+                    if (lastUserMessage && Array.isArray(lastUserMessage.content)) {
+                        const lastContentItem = lastUserMessage.content[lastUserMessage.content.length - 1];
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        lastContentItem.cache_control = {
+                            type: "ephemeral",
+                            ttl: promptCaching === types_1.PromptCaching.ENHANCE ? "1h" : "5m",
+                        };
+                    }
+                }
+                catch {
+                    // Ignore errors in cache_control setup
+                }
+            }
+        }
+        const stream = (await this._client.beta.messages.create({
+            ...claudeConfig,
+            messages: claudeMessages,
+        }, {
+            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() {
+        if (this._use_bedrock) {
+            throw new errors_1.UnsupportedOperationError({
+                client: this.constructor.name,
+                operation: "list_models",
+                message: "Bedrock does not support listing models.",
+            });
+        }
+        const models = [];
+        for await (const model of this._client.models.list()) {
+            models.push(model.id);
+        }
+        return models;
+    }
+}
+exports.AnthropicOfficialClient = AnthropicOfficialClient;

package/dist/anthropic_official/index.d.ts

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

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

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

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