@prismshadow/mmsp 0.5.0

package/dist/openai_embedding/client.js

@@ -0,0 +1,124 @@
+"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.OpenaiEmbeddingClient = void 0;
+const openai_1 = __importDefault(require("openai"));
+const baseClient_1 = require("../baseClient");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+/**
+ * OpenAI Embeddings-compatible client implementation.
+ */
+class OpenaiEmbeddingClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize OpenAI-compatible embedding 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: "OPENAI_API_KEY", baseUrl: "OPENAI_BASE_URL" });
+        this._client = new openai_1.default({
+            apiKey: key,
+            baseURL: url,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    /**
+     * Transform universal configuration to OpenAI Embeddings configuration.
+     */
+    transformUniConfigToModelConfig(config) {
+        if (config.fast_mode) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "fast_mode",
+                message: "OpenAI embeddings do not support fast mode.",
+            });
+        }
+        const params = {
+            model: this._model,
+        };
+        const dimensions = config.embedding_config?.dimensions;
+        if (dimensions !== undefined) {
+            params.dimensions = dimensions;
+        }
+        return params;
+    }
+    /**
+     * Transform universal messages to OpenAI Embeddings input strings.
+     */
+    transformUniMessageToModelInput(messages) {
+        const texts = [];
+        for (const msg of messages) {
+            let msgText = "";
+            for (const item of msg.content_items) {
+                if (item.type !== "text.done") {
+                    throw new Error("OpenAI embeddings only support text content items.");
+                }
+                msgText += item.text;
+            }
+            texts.push(msgText || " ");
+        }
+        return texts;
+    }
+    /**
+     * Transform an OpenAI Embeddings response into a universal event, one complete item per vector.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        return {
+            role: "assistant",
+            event_type: "stop",
+            content_items: modelOutput.data.map((item) => ({
+                type: "embedding.delta",
+                embedding: item.embedding,
+            })),
+            usage_metadata: {
+                cached_tokens: null,
+                prompt_tokens: modelOutput.usage?.prompt_tokens ?? null,
+                thoughts_tokens: null,
+                response_tokens: null,
+            },
+            finish_reason: "stop",
+        };
+    }
+    /**
+     * Generate embeddings using OpenAI Embeddings-compatible API.
+     */
+    async *_streamingResponseInternal(options) {
+        const params = {
+            ...this.transformUniConfigToModelConfig(options.config),
+            input: this.transformUniMessageToModelInput(options.messages),
+        };
+        const result = await this._client.embeddings.create(params, {
+            signal: options.signal,
+        });
+        yield this.transformModelOutputToUniEvent(result);
+    }
+    /**
+     * 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.OpenaiEmbeddingClient = OpenaiEmbeddingClient;

package/dist/openai_embedding/index.d.ts

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

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

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

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

package/dist/openai_official/client.d.ts

@@ -0,0 +1,61 @@
+import type { ResponseInputItem, ResponseStreamEvent } from "openai/resources/responses/responses";
+import { LLMClient } from "../baseClient";
+import { UniConfig, UniEvent, UniMessage } from "../types";
+/**
+ * GPT-6-specific LLM client implementation (also serves GPT-5.6, GPT-5.5 and GPT-5.4).
+ */
+export declare class OpenAIOfficialClient extends LLMClient {
+    protected _model: string;
+    private _client;
+    /**
+     * Initialize GPT-6 client with model and API key.
+     */
+    constructor(options: {
+        model: string;
+        apiKey?: string;
+        baseUrl?: string | null;
+        defaultHeaders?: Record<string, string>;
+    });
+    /**
+     * Convert ThinkingLevel enum to OpenAI's reasoning effort.
+     */
+    private _convertThinkingLevelToEffort;
+    /**
+     * Convert ToolChoice to OpenAI's tool_choice format with allowed tools support.
+     */
+    private _convertToolChoice;
+    /**
+     * Convert an image URL to an input_image item, at the detail the API needs
+     * to read it.
+     */
+    private _convertImageUrl;
+    /**
+     * Transform universal configuration to OpenAI Responses API configuration.
+     */
+    transformUniConfigToModelConfig(config: UniConfig): any;
+    /**
+     * Transform universal message format to OpenAI Responses API input format.
+     */
+    transformUniMessageToModelInput(messages: UniMessage[], _signal?: AbortSignal): ResponseInputItem[];
+    /**
+     * Transform one OpenAI Responses API stream event into a universal event, identifying items by
+     * output item id. An item needs no done: it is done when the next one begins or the stream
+     * ends.
+     */
+    transformModelOutputToUniEvent(modelOutput: ResponseStreamEvent): UniEvent;
+    /**
+     * Stream generate using OpenAI Responses 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/openai_official/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/openai_official/client.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAOL,SAAS,EACT,QAAQ,EACR,UAAU,EAGX,MAAM,UAAU,CAAC;AAOlB;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,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,6BAA6B;IAoBrC;;OAEG;IAEH,OAAO,CAAC,kBAAkB;IAW1B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;IAEH,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,GAAG;IAmEvD;;OAEG;IACH,+BAA+B,CAC7B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE,WAAW,GACpB,iBAAiB,EAAE;IAkJtB;;;;OAIG;IACH,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAmJ1E;;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;IAqB5B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAQtC"}

package/dist/openai_official/client.js

@@ -0,0 +1,464 @@
+"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.OpenAIOfficialClient = 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");
+/**
+ * GPT-6-specific LLM client implementation (also serves GPT-5.6, GPT-5.5 and GPT-5.4).
+ */
+class OpenAIOfficialClient extends baseClient_1.LLMClient {
+    /**
+     * Initialize GPT-6 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: "OPENAI_API_KEY", baseUrl: "OPENAI_BASE_URL" });
+        this._client = new openai_1.default({
+            apiKey: key,
+            baseURL: url,
+            defaultHeaders: options.defaultHeaders,
+        });
+    }
+    /**
+     * Convert ThinkingLevel enum to OpenAI's reasoning effort.
+     */
+    _convertThinkingLevelToEffort(thinkingLevel) {
+        if (thinkingLevel === types_1.ThinkingLevel.NONE && this._model.includes("gpt-6")) {
+            // GPT-6 rejects both "none" and "minimal" with a 400 (verified live 2026-09-09:
+            // "Unsupported value: 'none' is not supported with the 'gpt-6-astra' model.
+            // Supported values are: 'low', 'medium', 'high', 'xhigh', and 'max'."), so NONE
+            // degrades to the lowest effort the generation accepts.
+            return "low";
+        }
+        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]: "xhigh",
+            [types_1.ThinkingLevel.MAX]: "max",
+        };
+        return mapping[thinkingLevel];
+    }
+    /**
+     * Convert ToolChoice to OpenAI's tool_choice format with allowed tools support.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _convertToolChoice(toolChoice) {
+        if (Array.isArray(toolChoice)) {
+            return {
+                mode: "required",
+                tools: toolChoice.map((name) => ({ type: "function", name })),
+            };
+        }
+        return toolChoice;
+    }
+    /**
+     * Convert an image URL to an input_image item, at the detail the API needs
+     * to read it.
+     */
+    _convertImageUrl(imageUrl) {
+        const detail = (0, utils_1.openaiImageDetail)(this._model, imageUrl);
+        return detail
+            ? { type: "input_image", image_url: imageUrl, detail }
+            : { type: "input_image", image_url: imageUrl };
+    }
+    /**
+     * Transform universal configuration to OpenAI Responses API configuration.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformUniConfigToModelConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const openaiConfig = {
+            model: this._model,
+            store: false,
+            include: ["reasoning.encrypted_content"],
+        };
+        if (config.system_prompt !== undefined) {
+            openaiConfig.instructions = config.system_prompt;
+        }
+        if (config.max_tokens !== undefined) {
+            openaiConfig.max_output_tokens = config.max_tokens;
+        }
+        if (config.temperature !== undefined && config.temperature !== 1.0) {
+            throw new errors_1.UnsupportedParameterError({
+                client: this.constructor.name,
+                parameter: "temperature",
+                message: "GPT-6 does not support setting temperature.",
+            });
+        }
+        if (config.thinking_level !== undefined) {
+            openaiConfig.reasoning = {
+                effort: this._convertThinkingLevelToEffort(config.thinking_level),
+            };
+        }
+        if (config.thinking_summary) {
+            // reasoning.summary stands on its own, with or without an effort (verified live
+            // 2026-09-03 on the OpenAI and OpenRouter endpoints). False needs no key: the
+            // Responses API returns no summary unless one is asked for.
+            openaiConfig.reasoning = openaiConfig.reasoning ?? {};
+            openaiConfig.reasoning.summary = "concise";
+        }
+        if (config.tools !== undefined) {
+            openaiConfig.tools = config.tools.map((tool) => ({
+                type: "function",
+                ...tool,
+            }));
+        }
+        if (config.tool_choice !== undefined) {
+            openaiConfig.tool_choice = this._convertToolChoice(config.tool_choice);
+        }
+        if (config.fast_mode) {
+            openaiConfig.service_tier = "priority";
+        }
+        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 GPT-6.",
+            });
+        }
+        return openaiConfig;
+    }
+    /**
+     * Transform universal message format to OpenAI Responses API input format.
+     */
+    transformUniMessageToModelInput(messages, _signal) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const inputList = [];
+        for (const msg of messages) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let contentItems = [];
+            let lastPhase = null;
+            for (const item of msg.content_items) {
+                // anything that is not message content becomes an input item of its own, so the
+                // text collected so far is flushed first to keep the 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.
+                    const entry = {
+                        type: "message",
+                        role: msg.role,
+                        content: contentItems,
+                    };
+                    if (lastPhase !== null) {
+                        entry.phase = lastPhase;
+                    }
+                    inputList.push(entry);
+                    contentItems = [];
+                }
+                if (item.type === "text.done") {
+                    const phase = item.fidelity?.phase;
+                    if (msg.role === "assistant" && phase) {
+                        // split different phases
+                        if (lastPhase !== null &&
+                            lastPhase !== phase &&
+                            contentItems.length > 0) {
+                            inputList.push({
+                                type: "message",
+                                role: msg.role,
+                                content: contentItems,
+                                phase: lastPhase,
+                            });
+                            contentItems = [];
+                        }
+                        lastPhase = phase;
+                    }
+                    if (msg.role === "user") {
+                        contentItems.push({ type: "input_text", text: item.text });
+                    }
+                    else {
+                        contentItems.push({ type: "output_text", text: item.text });
+                    }
+                }
+                else if (item.type === "image_url.done") {
+                    contentItems.push(this._convertImageUrl(item.image_url));
+                }
+                else if (item.type === "thinking.done") {
+                    // rebuild the reasoning item from the recorded wire fields: the thinking
+                    // text goes back through the channel that carried it (histories recorded
+                    // by the pre-channel client carry encrypted_content and stream summaries)
+                    const fidelity = item.fidelity ?? {};
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const reasoning = { type: "reasoning", summary: [] };
+                    const summaryChannel = fidelity.channel === "summary" ||
+                        (!("channel" in fidelity) && fidelity.encrypted_content != null);
+                    if (summaryChannel) {
+                        if (item.thinking) {
+                            reasoning.summary = [
+                                { type: "summary_text", text: item.thinking },
+                            ];
+                        }
+                    }
+                    else if (item.thinking) {
+                        reasoning.content = [
+                            { type: "reasoning_text", text: item.thinking },
+                        ];
+                    }
+                    for (const key of ["encrypted_content", "signature", "format"]) {
+                        if (fidelity[key] != null) {
+                            reasoning[key] = fidelity[key];
+                        }
+                    }
+                    inputList.push(reasoning);
+                }
+                else if (item.type === "tool_call.done") {
+                    inputList.push({
+                        type: "function_call",
+                        call_id: item.tool_call_id,
+                        name: item.name,
+                        arguments: JSON.stringify(item.arguments),
+                    });
+                }
+                else if (item.type === "tool_result.done") {
+                    if (!item.tool_call_id) {
+                        throw new Error("tool_call_id is required for tool result.");
+                    }
+                    // Tool results are input items
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const imageParts = [];
+                    if (item.images) {
+                        for (const imageUrl of item.images) {
+                            imageParts.push(this._convertImageUrl(imageUrl));
+                        }
+                    }
+                    // a plain string is the form the Responses API documents for a text
+                    // result and the one every endpoint fronting this model accepts; the
+                    // content-part list is reserved for results carrying images
+                    const output = imageParts.length > 0
+                        ? [{ type: "input_text", text: item.text }, ...imageParts]
+                        : item.text;
+                    inputList.push({
+                        type: "function_call_output",
+                        call_id: item.tool_call_id,
+                        output,
+                    });
+                }
+                else {
+                    throw new Error(`Unknown item: ${JSON.stringify(item)}`);
+                }
+            }
+            if (contentItems.length > 0) {
+                const entry = {
+                    type: "message",
+                    role: msg.role,
+                    content: contentItems,
+                };
+                if (lastPhase !== null) {
+                    entry.phase = lastPhase;
+                }
+                inputList.push(entry);
+            }
+        }
+        return inputList;
+    }
+    /**
+     * Transform one OpenAI Responses API stream event into a universal event, identifying items by
+     * output item id. An item needs no done: it is done when the next one begins or the stream
+     * ends.
+     */
+    transformModelOutputToUniEvent(modelOutput) {
+        let eventType = "delta";
+        const contentItems = [];
+        let usageMetadata = null;
+        let finishReason = null;
+        const openaiEventType = modelOutput.type;
+        if (openaiEventType === "response.output_text.delta") {
+            contentItems.push({
+                type: "text.delta",
+                text: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.reasoning_summary_text.delta" ||
+            openaiEventType === "response.reasoning_text.delta") {
+            contentItems.push({
+                type: "thinking.delta",
+                thinking: modelOutput.delta,
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.output_item.added") {
+            // an item begins: a delta under its id, empty unless it carries the call's name or the
+            // message's phase, ends the item before it
+            const item = modelOutput.item;
+            if (item.type === "function_call") {
+                contentItems.push({
+                    type: "tool_call.delta",
+                    name: item.name,
+                    arguments: "",
+                    tool_call_id: item.call_id,
+                    // a server that sends no item id still sends the call id
+                    fidelity: { item_id: item.id || item.call_id },
+                });
+            }
+            else if (item.type === "message") {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const phase = item.phase;
+                contentItems.push({
+                    type: "text.delta",
+                    text: "",
+                    fidelity: { item_id: item.id, ...(phase != null ? { phase } : {}) },
+                });
+            }
+            else if (item.type === "reasoning") {
+                contentItems.push({
+                    type: "thinking.delta",
+                    thinking: "",
+                    fidelity: { item_id: item.id },
+                });
+            }
+        }
+        else if (openaiEventType === "response.output_item.done") {
+            const item = modelOutput.item;
+            if (item.type === "reasoning") {
+                // the completed item carries the canonical wire fields to send back on the
+                // next turn (identical to the response.completed copy, but adjacent to the
+                // thinking deltas so the fidelity lands on the item that carried the text);
+                // record the channel plus the fields the server demands back. This event is the
+                // only source of encrypted_content, because the streaming-events reference says
+                // of response.output_item.added: "For reasoning items, encrypted_content may be
+                // incomplete while the item is in progress. Use the reasoning item from the
+                // corresponding response.output_item.done event when passing it as input to a
+                // subsequent request."
+                const fidelity = { item_id: item.id };
+                if (item.summary && item.summary.length > 0) {
+                    fidelity.channel = "summary";
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                else if (item.content?.length > 0) {
+                    fidelity.channel = "content";
+                }
+                for (const key of ["encrypted_content", "signature", "format"]) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (item[key] != null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        fidelity[key] = item[key];
+                    }
+                }
+                contentItems.push({ type: "thinking.delta", thinking: "", fidelity });
+            }
+        }
+        else if (openaiEventType === "response.function_call_arguments.delta") {
+            contentItems.push({
+                type: "tool_call.delta",
+                name: "",
+                arguments: modelOutput.delta,
+                tool_call_id: "",
+                fidelity: { item_id: modelOutput.item_id },
+            });
+        }
+        else if (openaiEventType === "response.completed" ||
+            openaiEventType === "response.incomplete") {
+            eventType = "stop";
+            const response = modelOutput.response;
+            const finishReasonMapping = {
+                completed: "stop",
+                incomplete: "length",
+            };
+            if (response.status) {
+                finishReason = finishReasonMapping[response.status] || "unknown";
+            }
+            if (response.usage) {
+                const inputTokens = response.usage.input_tokens;
+                const outputTokens = response.usage.output_tokens;
+                const cachedTokens = response.usage.input_tokens_details.cached_tokens;
+                const reasoningTokens = response.usage.output_tokens_details.reasoning_tokens;
+                usageMetadata = {
+                    cached_tokens: cachedTokens,
+                    prompt_tokens: inputTokens - cachedTokens,
+                    thoughts_tokens: reasoningTokens,
+                    response_tokens: outputTokens - reasoningTokens,
+                };
+            }
+        }
+        else if ([
+            "response.created",
+            "response.in_progress",
+            "response.output_text.done",
+            "response.function_call_arguments.done",
+            "response.reasoning_summary_part.added",
+            "response.reasoning_summary_part.done",
+            "response.reasoning_summary_text.done",
+            "response.reasoning_text.done",
+            "response.content_part.added",
+            "response.content_part.done",
+            // gateway heartbeat on long generations; carries no content
+            "keepalive",
+        ].includes(openaiEventType)) {
+            // lifecycle events, and repeats of what the deltas carry
+        }
+        else if ((0, utils_1.isDebugEnabled)()) {
+            throw new Error(`Unknown output: ${JSON.stringify(modelOutput)}`);
+        }
+        else {
+            // a gateway injects its own events (heartbeats, cost tickers) into the stream, and
+            // killing a long generation over one costs more than dropping it
+        }
+        return {
+            role: "assistant",
+            event_type: eventType,
+            content_items: contentItems,
+            usage_metadata: usageMetadata,
+            finish_reason: finishReason,
+        };
+    }
+    /**
+     * Stream generate using OpenAI Responses API with unified conversion methods.
+     */
+    async *_streamingResponseInternal(options) {
+        const openaiConfig = this.transformUniConfigToModelConfig(options.config);
+        const inputList = this.transformUniMessageToModelInput(options.messages, options.signal);
+        const params = {
+            ...openaiConfig,
+            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.OpenAIOfficialClient = OpenAIOfficialClient;