@adminforth/completion-adapter-openai-responses 1.0.0

package/dist/index.js

@@ -0,0 +1,613 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { AIMessage } from "@langchain/core/messages";
+import { ChatOpenAI } from "@langchain/openai";
+import { createMiddleware } from "langchain";
+import { encoding_for_model } from "tiktoken";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const RAW_REQUEST_LOG_PREFIX = "[CompletionAdapterOpenAIResponses] Raw /responses request";
+function extractOutputText(data) {
+    var _a;
+    let text = "";
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type !== "message" || !Array.isArray(item.content))
+            continue;
+        for (const part of item.content) {
+            if (part.type === "output_text" && typeof part.text === "string") {
+                text += part.text;
+            }
+        }
+    }
+    return text;
+}
+function extractReasoning(data) {
+    var _a, _b, _c;
+    let reasoning = "";
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type !== "reasoning")
+            continue;
+        for (const part of (_b = item.summary) !== null && _b !== void 0 ? _b : []) {
+            if ((part === null || part === void 0 ? void 0 : part.type) === "summary_text" && typeof part.text === "string") {
+                reasoning += part.text;
+            }
+        }
+        if (!reasoning) {
+            for (const part of (_c = item.content) !== null && _c !== void 0 ? _c : []) {
+                if ((part === null || part === void 0 ? void 0 : part.type) === "reasoning_text" && typeof part.text === "string") {
+                    reasoning += part.text;
+                }
+            }
+        }
+    }
+    return reasoning || undefined;
+}
+function extractFunctionCall(data) {
+    var _a;
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type === "function_call") {
+            return item;
+        }
+    }
+    return undefined;
+}
+function extractUsedTokens(data) {
+    var _a, _b;
+    const usage = data.usage;
+    if (!usage) {
+        return undefined;
+    }
+    const inputCached = (_b = (_a = usage.input_tokens_details) === null || _a === void 0 ? void 0 : _a.cached_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        input_uncached: Math.max(usage.input_tokens - inputCached, 0),
+        input_cached: inputCached,
+        output: usage.output_tokens,
+    };
+}
+function executeToolCall(toolCall, tools) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tool = tools === null || tools === void 0 ? void 0 : tools.find((candidate) => candidate.name === toolCall.name);
+        if (!tool) {
+            throw new Error(`Tool "${toolCall.name}" not found`);
+        }
+        const toolResult = yield tool.handler(JSON.parse(toolCall.arguments));
+        if (typeof toolResult === "string")
+            return toolResult;
+        if (typeof toolResult === "undefined")
+            return "";
+        return JSON.stringify(toolResult);
+    });
+}
+function parseSseBlock(block) {
+    let event;
+    let data = "";
+    for (const rawLine of block.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        if (line.startsWith("data:"))
+            data += line.slice(5).trim();
+    }
+    return data ? { event, data } : null;
+}
+function getAgentReasoningEffort(purpose) {
+    return purpose === "summary" ? "minimal" : "low";
+}
+function buildReasoningConfig(params) {
+    var _a;
+    return Object.assign({ summary: "auto", effort: params.effort }, ((_a = params.reasoning) !== null && _a !== void 0 ? _a : {}));
+}
+function getTurnKey(context) {
+    return `${context.sessionId}:${context.turnId}`;
+}
+function getResponseId(message) {
+    var _a;
+    const metadata = message.response_metadata;
+    return (_a = metadata === null || metadata === void 0 ? void 0 : metadata.id) !== null && _a !== void 0 ? _a : null;
+}
+function getPreviousResponseId(modelSettings) {
+    return modelSettings === null || modelSettings === void 0 ? void 0 : modelSettings.previous_response_id;
+}
+function getContinuationMessages(messages, previousResponseId) {
+    var _a;
+    let continuationStartIndex = null;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (AIMessage.isInstance(message) &&
+            ((_a = message.response_metadata) === null || _a === void 0 ? void 0 : _a.id) ===
+                previousResponseId) {
+            continuationStartIndex = index + 1;
+            break;
+        }
+    }
+    if (continuationStartIndex === null) {
+        return null;
+    }
+    return messages.slice(continuationStartIndex);
+}
+function createOpenAiResponsesContinuationMiddleware() {
+    const responseIdsByTurn = new Map();
+    return createMiddleware({
+        name: "OpenAiResponsesContinuationMiddleware",
+        wrapModelCall(request, handler) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const context = request.runtime.context;
+                const turnKey = getTurnKey(context);
+                const previousResponseId = (_a = getPreviousResponseId(request.modelSettings)) !== null && _a !== void 0 ? _a : responseIdsByTurn.get(turnKey);
+                const continuationMessages = previousResponseId
+                    ? getContinuationMessages(request.messages, previousResponseId)
+                    : null;
+                const response = (yield handler(previousResponseId && continuationMessages
+                    ? Object.assign(Object.assign({}, request), { messages: continuationMessages, modelSettings: Object.assign(Object.assign({}, request.modelSettings), { previous_response_id: previousResponseId }) }) : request));
+                const responseId = getResponseId(response);
+                if (responseId) {
+                    responseIdsByTurn.set(turnKey, responseId);
+                }
+                else {
+                    responseIdsByTurn.delete(turnKey);
+                }
+                return response;
+            });
+        },
+    });
+}
+export default class CompletionAdapterOpenAIResponses {
+    constructor(options) {
+        this.activeAbortController = null;
+        this.complete = (requestOrContent_1, ...args_1) => __awaiter(this, [requestOrContent_1, ...args_1], void 0, function* (requestOrContent, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
+            var _a, _b, _c;
+            const request = typeof requestOrContent === "string"
+                ? {
+                    content: requestOrContent,
+                    maxTokens,
+                    outputSchema,
+                    reasoningEffort,
+                    tools: Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined,
+                    onChunk: typeof toolsOrOnChunk === "function"
+                        ? toolsOrOnChunk
+                        : onChunk,
+                }
+                : requestOrContent;
+            const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, onChunk: streamChunkCallback, signal: requestSignal, } = request;
+            const model = this.options.model || "gpt-5-nano";
+            const isStreaming = typeof streamChunkCallback === "function";
+            const extra = this.options.extraRequestBodyParameters;
+            const _d = extra !== null && extra !== void 0 ? extra : {}, { reasoning: extraReasoning } = _d, extraWithoutReasoning = __rest(_d, ["reasoning"]);
+            let openAiTools = undefined;
+            if (tools && tools.length > 0) {
+                openAiTools = tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.input_schema,
+                    strict: false,
+                }));
+            }
+            const body = Object.assign({ model, input: content, max_output_tokens: requestMaxTokens, stream: isStreaming, text: requestOutputSchema
+                    ? {
+                        format: Object.assign({ type: "json_schema" }, requestOutputSchema),
+                    }
+                    : {
+                        format: {
+                            type: "text",
+                        },
+                    }, reasoning: Object.assign({}, buildReasoningConfig({
+                    reasoning: extraReasoning,
+                    effort: requestReasoningEffort,
+                })), tools: openAiTools }, extraWithoutReasoning);
+            const serializedBody = JSON.stringify(body);
+            if (this.shouldDumpRawRequest()) {
+                this.dumpRawRequest(this.getResponsesUrl(), serializedBody);
+            }
+            const abortController = new AbortController();
+            this.activeAbortController = abortController;
+            const abortFromRequestSignal = () => abortController.abort(requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.reason);
+            if (requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.aborted) {
+                abortController.abort(requestSignal.reason);
+            }
+            else {
+                requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.addEventListener("abort", abortFromRequestSignal, { once: true });
+            }
+            let resp = null;
+            try {
+                resp = yield fetch(this.getResponsesUrl(), {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.options.openAiApiKey}`,
+                    },
+                    body: serializedBody,
+                    signal: abortController.signal,
+                });
+            }
+            catch (error) {
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
+                }
+                if (abortController.signal.aborted) {
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Generation aborted",
+                        finishReason: "aborted",
+                    };
+                }
+                return {
+                    error: (error === null || error === void 0 ? void 0 : error.message) || "OpenAI request failed",
+                };
+            }
+            finally {
+                requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.removeEventListener("abort", abortFromRequestSignal);
+            }
+            if (!resp) {
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
+                }
+                return {
+                    error: "OpenAI request failed",
+                };
+            }
+            try {
+                if (!resp.ok) {
+                    let errorMessage = `OpenAI request failed with status ${resp.status}`;
+                    try {
+                        const errorData = (yield resp.json());
+                        if ((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message)
+                            errorMessage = errorData.error.message;
+                    }
+                    catch (_e) { }
+                    return { error: errorMessage };
+                }
+                if (!isStreaming) {
+                    const json = yield resp.json();
+                    const data = json;
+                    if (data.error) {
+                        return { error: data.error.message };
+                    }
+                    const usedTokens = extractUsedTokens(data);
+                    const toolCall = extractFunctionCall(data);
+                    if (toolCall) {
+                        try {
+                            const toolResult = yield executeToolCall(toolCall, tools);
+                            return {
+                                content: toolResult,
+                                finishReason: "tool_call",
+                                used_tokens: usedTokens,
+                            };
+                        }
+                        catch (error) {
+                            return {
+                                error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                                finishReason: "tool_call",
+                                used_tokens: usedTokens,
+                            };
+                        }
+                    }
+                    const parsedContent = extractOutputText(data);
+                    return {
+                        content: parsedContent,
+                        finishReason: ((_b = data.incomplete_details) === null || _b === void 0 ? void 0 : _b.reason)
+                            ? data.incomplete_details.reason
+                            : undefined,
+                        used_tokens: usedTokens,
+                    };
+                }
+                if (!resp.body) {
+                    return { error: "Response body is empty" };
+                }
+                const reader = resp.body.getReader();
+                const decoder = new TextDecoder("utf-8");
+                let buffer = "";
+                let fullContent = "";
+                let fullReasoning = "";
+                let finishReason;
+                let completedResponse;
+                let usedTokens;
+                const handleEvent = (event, eventType) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c, _d;
+                    const type = (event === null || event === void 0 ? void 0 : event.type) || eventType;
+                    if (type === "response.output_text.delta") {
+                        const delta = (event === null || event === void 0 ? void 0 : event.delta) || "";
+                        if (!delta)
+                            return;
+                        fullContent += delta;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, { type: "output", delta, text: fullContent }));
+                        return;
+                    }
+                    if (type === "response.reasoning_summary_text.delta" ||
+                        type === "response.reasoning_text.delta") {
+                        const delta = (event === null || event === void 0 ? void 0 : event.delta) || "";
+                        if (!delta)
+                            return;
+                        fullReasoning += delta;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                            type: "reasoning",
+                            delta,
+                            text: fullReasoning,
+                        }));
+                        return;
+                    }
+                    if (type === "response.completed" || type === "response.incomplete") {
+                        const response = event === null || event === void 0 ? void 0 : event.response;
+                        if (!response)
+                            return;
+                        const finalContent = extractOutputText(response);
+                        if (finalContent.startsWith(fullContent)) {
+                            const delta = finalContent.slice(fullContent.length);
+                            if (delta) {
+                                fullContent = finalContent;
+                                yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                    type: "output",
+                                    delta,
+                                    text: fullContent,
+                                }));
+                            }
+                        }
+                        const finalReasoning = extractReasoning(response) || "";
+                        if (finalReasoning.startsWith(fullReasoning)) {
+                            const delta = finalReasoning.slice(fullReasoning.length);
+                            if (delta) {
+                                fullReasoning = finalReasoning;
+                                yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                    type: "reasoning",
+                                    delta,
+                                    text: fullReasoning,
+                                }));
+                            }
+                        }
+                        finishReason =
+                            ((_a = response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason) || response.status || finishReason;
+                        completedResponse = response;
+                        usedTokens = extractUsedTokens(response);
+                        return;
+                    }
+                    if (type === "response.failed") {
+                        throw new Error(((_c = (_b = event === null || event === void 0 ? void 0 : event.response) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) ||
+                            ((_d = event === null || event === void 0 ? void 0 : event.error) === null || _d === void 0 ? void 0 : _d.message) ||
+                            "Response failed");
+                    }
+                });
+                try {
+                    while (true) {
+                        const { value, done } = yield reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split("\n\n");
+                        buffer = blocks.pop() || "";
+                        for (const block of blocks) {
+                            const parsedBlock = parseSseBlock(block);
+                            if (!(parsedBlock === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) || parsedBlock.data === "[DONE]")
+                                continue;
+                            let event;
+                            try {
+                                event = JSON.parse(parsedBlock.data);
+                            }
+                            catch (_f) {
+                                continue;
+                            }
+                            if ((_c = event === null || event === void 0 ? void 0 : event.error) === null || _c === void 0 ? void 0 : _c.message) {
+                                return { error: event.error.message };
+                            }
+                            yield handleEvent(event, parsedBlock.event);
+                        }
+                    }
+                    if (buffer.trim()) {
+                        const parsedBlock = parseSseBlock(buffer.trim());
+                        if ((parsedBlock === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) && parsedBlock.data !== "[DONE]") {
+                            try {
+                                yield handleEvent(JSON.parse(parsedBlock.data), parsedBlock.event);
+                            }
+                            catch (error) {
+                                return {
+                                    error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                                    content: fullContent || undefined,
+                                    finishReason,
+                                };
+                            }
+                        }
+                    }
+                    if (completedResponse) {
+                        const toolCall = extractFunctionCall(completedResponse);
+                        if (toolCall) {
+                            try {
+                                const toolResult = yield executeToolCall(toolCall, tools);
+                                if (toolResult) {
+                                    const delta = toolResult.startsWith(fullContent)
+                                        ? toolResult.slice(fullContent.length)
+                                        : toolResult;
+                                    if (delta) {
+                                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                            type: "output",
+                                            delta,
+                                            text: toolResult,
+                                        }));
+                                    }
+                                }
+                                return {
+                                    content: toolResult,
+                                    finishReason: "tool_call",
+                                    used_tokens: usedTokens,
+                                };
+                            }
+                            catch (error) {
+                                return {
+                                    error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                                    content: fullContent || undefined,
+                                    finishReason: "tool_call",
+                                    used_tokens: usedTokens,
+                                };
+                            }
+                        }
+                    }
+                    return {
+                        content: fullContent || undefined,
+                        finishReason,
+                        used_tokens: usedTokens,
+                    };
+                }
+                catch (error) {
+                    if (abortController.signal.aborted) {
+                        return {
+                            error: (error === null || error === void 0 ? void 0 : error.message) || "Generation aborted",
+                            content: fullContent || undefined,
+                            finishReason: "aborted",
+                            used_tokens: usedTokens,
+                        };
+                    }
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                        content: fullContent || undefined,
+                        finishReason,
+                        used_tokens: usedTokens,
+                    };
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+            finally {
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
+                }
+            }
+        });
+        this.options = options;
+        try {
+            this.encoding = encoding_for_model((this.options.model || "gpt-5-nano"));
+        }
+        catch (error) {
+            // console.warn(
+            //   `Failed to initialize tiktoken tokenizer for model "${this.options.model}", falling back to "gpt-5-nano". Error:`,
+            // );
+            this.encoding = encoding_for_model("gpt-5-nano");
+        }
+    }
+    validate() {
+        if (!this.options.openAiApiKey) {
+            throw new Error("openAiApiKey is required");
+        }
+    }
+    measureTokensCount(content) {
+        return this.encoding.encode(content).length;
+    }
+    abort() {
+        var _a;
+        (_a = this.activeAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+    }
+    isGenerationInProgress() {
+        return Boolean(this.activeAbortController);
+    }
+    getConfiguredBaseUrl() {
+        return this.options.baseUrl;
+    }
+    shouldUseComplitionApi() {
+        if (typeof this.options.useComplitionApi === "boolean") {
+            return this.options.useComplitionApi;
+        }
+        return Boolean(this.getConfiguredBaseUrl());
+    }
+    shouldDumpRawRequest() {
+        return this.options.dumpRawRequest === true;
+    }
+    getClientConfiguration() {
+        const configuredBaseUrl = this.getConfiguredBaseUrl();
+        const debugFetch = this.shouldDumpRawRequest()
+            ? this.createResponsesDebugFetch()
+            : undefined;
+        if (!configuredBaseUrl && !debugFetch) {
+            return undefined;
+        }
+        return Object.assign(Object.assign({}, (configuredBaseUrl ? { baseURL: configuredBaseUrl } : {})), (debugFetch ? { fetch: debugFetch } : {}));
+    }
+    createResponsesDebugFetch() {
+        return (input, init) => __awaiter(this, void 0, void 0, function* () {
+            const url = this.getFetchUrl(input);
+            if (this.isResponsesUrl(url) && typeof (init === null || init === void 0 ? void 0 : init.body) === "string") {
+                this.dumpRawRequest(url, init.body);
+            }
+            return fetch(input, init);
+        });
+    }
+    getFetchUrl(input) {
+        if (typeof input === "string") {
+            return input;
+        }
+        if (input instanceof URL) {
+            return input.toString();
+        }
+        return input.url;
+    }
+    isResponsesUrl(url) {
+        try {
+            return new URL(url).pathname.endsWith("/responses");
+        }
+        catch (_a) {
+            return url.endsWith("/responses") || url.includes("/responses?");
+        }
+    }
+    dumpRawRequest(url, body) {
+        console.info(`${RAW_REQUEST_LOG_PREFIX} ${url}`);
+        try {
+            console.info(JSON.stringify(JSON.parse(body), null, 2));
+        }
+        catch (_a) {
+            console.info(body);
+        }
+    }
+    getResponsesUrl() {
+        const baseUrl = this.getConfiguredBaseUrl() || DEFAULT_OPENAI_BASE_URL;
+        const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+        return new URL("responses", normalizedBaseUrl).toString();
+    }
+    getLangChainAgentSpec(params) {
+        const extraRequestBodyParameters = (this.options.extraRequestBodyParameters || {});
+        const { reasoning } = extraRequestBodyParameters, modelKwargs = __rest(extraRequestBodyParameters, ["reasoning"]);
+        const configuredBaseUrl = this.getConfiguredBaseUrl();
+        const normalizedModelKwargs = Object.assign({}, modelKwargs);
+        const clientConfiguration = this.getClientConfiguration();
+        const useComplitionApi = this.shouldUseComplitionApi();
+        const chatOpenAiOptions = {
+            model: this.options.model || "gpt-5-nano",
+            apiKey: this.options.openAiApiKey,
+            maxTokens: params.maxTokens,
+            reasoning: buildReasoningConfig({
+                reasoning,
+                effort: getAgentReasoningEffort(params.purpose),
+            }),
+            modelKwargs: normalizedModelKwargs,
+        };
+        chatOpenAiOptions.useResponsesApi = !useComplitionApi;
+        let supportsResponseContinuation = true;
+        if (configuredBaseUrl || useComplitionApi) {
+            supportsResponseContinuation = false;
+        }
+        if (clientConfiguration) {
+            chatOpenAiOptions.configuration = clientConfiguration;
+        }
+        return {
+            model: new ChatOpenAI(chatOpenAiOptions),
+            middleware: params.purpose === "primary" && supportsResponseContinuation
+                ? [createOpenAiResponsesContinuationMiddleware()]
+                : [],
+        };
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+export interface AdapterOptions {
+    /**
+     * OpenAI API key. Go to https://platform.openai.com/, go to Dashboard -> API keys -> Create new secret key
+     * Paste value in your .env file OPENAI_API_KEY=your_key
+     * Set openAiApiKey: process.env.OPENAI_API_KEY to access it
+     */
+    openAiApiKey: string;
+    /**
+     * Optional OpenAI-compatible base URL.
+     *
+     * Example: `https://oai.endpoints.kepler.ai.cloud.ovh.net/v1`
+     */
+    baseUrl?: string;
+    /**
+     * Forces LangChain agent mode to use the Chat Completions API instead of the
+     * Responses API.
+     *
+     * When omitted, the adapter keeps the current default behavior:
+     * - official OpenAI uses the Responses API
+     * - custom `baseUrl` providers use the Chat Completions API
+     */
+    useComplitionApi?: boolean;
+    /**
+     * Model name. Go to https://platform.openai.com/docs/models, select model and copy name.
+     * Default is `gpt-5-nano`.
+     */
+    model?: string;
+    /**
+     * Additional request body parameters to include in the API request.
+     */
+    extraRequestBodyParameters?: Record<string, unknown>;
+    /**
+     * Logs the exact JSON body sent to the OpenAI Responses endpoint.
+     * Authorization headers are not logged.
+     */
+    dumpRawRequest?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};