@adminforth/completion-adapter-openai-responses 1.0.0 → 1.0.1

package/dist/langchain.d.ts

@@ -0,0 +1,14 @@
+import { ChatOpenAI } from "@langchain/openai";
+import type { AdapterOptions } from "./types.js";
+export type AgentModelPurpose = "primary" | "summary";
+export declare function createLangChainAgentSpec(params: {
+    options: AdapterOptions;
+    maxTokens: number;
+    purpose: AgentModelPurpose;
+    configuredBaseUrl?: string;
+    clientConfiguration?: Record<string, unknown>;
+    useComplitionApi: boolean;
+}): {
+    model: ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions>;
+    middleware: import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>[];
+};

package/dist/langchain.js

@@ -0,0 +1,114 @@
+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";
+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 function createLangChainAgentSpec(params) {
+    const extraRequestBodyParameters = params.options.extraRequestBodyParameters || {};
+    const { reasoning } = extraRequestBodyParameters, modelKwargs = __rest(extraRequestBodyParameters, ["reasoning"]);
+    const normalizedModelKwargs = Object.assign({}, modelKwargs);
+    const chatOpenAiOptions = {
+        model: params.options.model || "gpt-5-nano",
+        apiKey: params.options.openAiApiKey,
+        maxTokens: params.maxTokens,
+        reasoning: buildReasoningConfig({
+            reasoning,
+            effort: getAgentReasoningEffort(params.purpose),
+        }),
+        modelKwargs: normalizedModelKwargs,
+    };
+    chatOpenAiOptions.useResponsesApi = !params.useComplitionApi;
+    let supportsResponseContinuation = true;
+    if (params.configuredBaseUrl || params.useComplitionApi) {
+        supportsResponseContinuation = false;
+    }
+    if (params.clientConfiguration) {
+        chatOpenAiOptions.configuration = params.clientConfiguration;
+    }
+    return {
+        model: new ChatOpenAI(chatOpenAiOptions),
+        middleware: params.purpose === "primary" && supportsResponseContinuation
+            ? [createOpenAiResponsesContinuationMiddleware()]
+            : [],
+    };
+}

package/dist/openai.d.ts

@@ -0,0 +1,50 @@
+import type { CompletionStreamEvent, CompletionTool } from "adminforth";
+import type { AdapterOptions } from "./types.js";
+export type StreamChunkCallback = (chunk: string, event?: CompletionStreamEvent) => void | Promise<void>;
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type CompletionRequestInput = {
+    content: string;
+    maxTokens?: number;
+    outputSchema?: any;
+    reasoningEffort?: ReasoningEffort;
+    tools?: CompletionTool[];
+    onChunk?: StreamChunkCallback;
+    signal?: AbortSignal;
+    previousResponseId?: string;
+};
+export type UsedTokens = {
+    input_uncached: number;
+    input_cached: number;
+    output: number;
+};
+export type CompletionResult = {
+    content?: string;
+    finishReason?: string;
+    responseId?: string;
+    used_tokens?: UsedTokens;
+    error?: undefined;
+} | {
+    error: string;
+    content?: string;
+    finishReason?: string;
+    responseId?: string;
+    used_tokens?: UsedTokens;
+};
+type FetchInput = Parameters<typeof fetch>[0];
+type FetchInit = Parameters<typeof fetch>[1];
+export declare class OpenAIResponsesService {
+    private options;
+    private client;
+    constructor(options: AdapterOptions);
+    getClientConfiguration(): {
+        fetch?: ((input: FetchInput, init?: FetchInit) => Promise<Response>) | undefined;
+        baseURL?: string | undefined;
+    } | undefined;
+    complete(request: CompletionRequestInput, signal: AbortSignal): Promise<CompletionResult>;
+    private getClient;
+    private createResponsesDebugFetch;
+    private getFetchUrl;
+    private isResponsesUrl;
+    private dumpRawRequest;
+}
+export {};

package/dist/openai.js

@@ -0,0 +1,349 @@
+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;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import OpenAI from "openai";
+const RAW_REQUEST_LOG_PREFIX = "[CompletionAdapterOpenAIResponses] Raw /responses request";
+function extractOutputText(data) {
+    return data.output_text || "";
+}
+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 resolveToolCallResult(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const toolCall = extractFunctionCall(params.response);
+        if (!toolCall) {
+            return null;
+        }
+        try {
+            const toolResult = yield executeToolCall(toolCall, params.tools);
+            if (typeof params.currentContent === "string" && toolResult) {
+                const delta = toolResult.startsWith(params.currentContent)
+                    ? toolResult.slice(params.currentContent.length)
+                    : toolResult;
+                if (delta) {
+                    yield ((_a = params.onChunk) === null || _a === void 0 ? void 0 : _a.call(params, delta, {
+                        type: "output",
+                        delta,
+                        text: toolResult,
+                    }));
+                }
+            }
+            return {
+                content: toolResult,
+                finishReason: "tool_call",
+                responseId: params.response.id,
+                used_tokens: params.usedTokens,
+            };
+        }
+        catch (error) {
+            return {
+                error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                content: params.currentContent || undefined,
+                finishReason: "tool_call",
+                responseId: params.response.id,
+                used_tokens: params.usedTokens,
+            };
+        }
+    });
+}
+function handleCompletedResponse(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const usedTokens = extractUsedTokens(params.response);
+        const toolCallResult = yield resolveToolCallResult({
+            response: params.response,
+            tools: params.tools,
+            usedTokens,
+        });
+        if (toolCallResult) {
+            return toolCallResult;
+        }
+        return {
+            content: extractOutputText(params.response),
+            finishReason: ((_a = params.response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason)
+                ? params.response.incomplete_details.reason
+                : undefined,
+            responseId: params.response.id,
+            used_tokens: usedTokens,
+        };
+    });
+}
+function buildReasoningConfig(params) {
+    return Object.assign({ summary: "auto", effort: params.effort }, params.reasoning);
+}
+function splitExtraRequestBodyParameters(extra) {
+    const { reasoning } = extra, bodyParameters = __rest(extra, ["reasoning"]);
+    return {
+        reasoning,
+        bodyParameters,
+    };
+}
+function mapTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length)) {
+        return undefined;
+    }
+    return tools.map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        strict: false,
+    }));
+}
+function buildResponseBody(params) {
+    var _a;
+    const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, } = params.request;
+    const { reasoning: extraReasoning, bodyParameters: extraBodyParameters, } = splitExtraRequestBodyParameters((_a = params.options.extraRequestBodyParameters) !== null && _a !== void 0 ? _a : {});
+    return Object.assign(Object.assign(Object.assign({}, extraBodyParameters), { model: params.options.model || "gpt-5-nano", input: content, max_output_tokens: requestMaxTokens, text: requestOutputSchema
+            ? {
+                format: Object.assign({ type: "json_schema" }, requestOutputSchema),
+            }
+            : {
+                format: {
+                    type: "text",
+                },
+            }, reasoning: buildReasoningConfig({
+            reasoning: extraReasoning,
+            effort: requestReasoningEffort,
+        }), tools: mapTools(tools) }), (params.request.previousResponseId
+        ? { previous_response_id: params.request.previousResponseId }
+        : {}));
+}
+export class OpenAIResponsesService {
+    constructor(options) {
+        this.options = options;
+        this.client = null;
+    }
+    getClientConfiguration() {
+        const configuredBaseUrl = this.options.baseUrl;
+        const debugFetch = this.options.dumpRawRequest === true
+            ? this.createResponsesDebugFetch()
+            : undefined;
+        if (!configuredBaseUrl && !debugFetch) {
+            return undefined;
+        }
+        return Object.assign(Object.assign({}, (configuredBaseUrl ? { baseURL: configuredBaseUrl } : {})), (debugFetch ? { fetch: debugFetch } : {}));
+    }
+    complete(request, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const { tools, onChunk: streamChunkCallback } = request;
+            const isStreaming = typeof streamChunkCallback === "function";
+            const body = buildResponseBody({
+                options: this.options,
+                request,
+            });
+            let fullContent = "";
+            let fullReasoning = "";
+            let finishReason;
+            let completedResponse;
+            let usedTokens;
+            const handleStreamEvent = (event) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                switch (event.type) {
+                    case "response.output_text.delta": {
+                        const delta = event.delta || "";
+                        if (!delta)
+                            return;
+                        fullContent += delta;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                            type: "output",
+                            delta,
+                            text: fullContent,
+                        }));
+                        return;
+                    }
+                    case "response.reasoning_summary_text.delta":
+                    case "response.reasoning_text.delta": {
+                        const delta = event.delta || "";
+                        if (!delta)
+                            return;
+                        fullReasoning += delta;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                            type: "reasoning",
+                            delta,
+                            text: fullReasoning,
+                        }));
+                        return;
+                    }
+                    case "response.completed":
+                    case "response.incomplete": {
+                        const response = event.response;
+                        finishReason =
+                            ((_a = response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason) || response.status || finishReason;
+                        completedResponse = response;
+                        usedTokens = extractUsedTokens(response);
+                        return;
+                    }
+                    case "response.failed":
+                        throw new Error(((_b = event.response.error) === null || _b === void 0 ? void 0 : _b.message) || "Response failed");
+                    case "error":
+                        throw new Error(event.message || "Response failed");
+                }
+            });
+            try {
+                if (!isStreaming) {
+                    const params = Object.assign(Object.assign({}, body), { stream: false });
+                    const data = yield this.getClient().responses.create(params, { signal });
+                    return handleCompletedResponse({ response: data, tools });
+                }
+                const params = Object.assign(Object.assign({}, body), { stream: true });
+                const stream = yield this.getClient().responses.create(params, { signal });
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        const event = _c;
+                        yield handleStreamEvent(event);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (completedResponse) {
+                    const toolCallResult = yield resolveToolCallResult({
+                        response: completedResponse,
+                        tools,
+                        currentContent: fullContent,
+                        onChunk: streamChunkCallback,
+                        usedTokens,
+                    });
+                    if (toolCallResult) {
+                        return toolCallResult;
+                    }
+                }
+                return {
+                    content: fullContent || undefined,
+                    finishReason,
+                    responseId: completedResponse === null || completedResponse === void 0 ? void 0 : completedResponse.id,
+                    used_tokens: usedTokens,
+                };
+            }
+            catch (error) {
+                if (signal.aborted) {
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Generation aborted",
+                        content: fullContent || undefined,
+                        finishReason: "aborted",
+                        used_tokens: usedTokens,
+                    };
+                }
+                if (isStreaming) {
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                        content: fullContent || undefined,
+                        finishReason,
+                        used_tokens: usedTokens,
+                    };
+                }
+                return {
+                    error: (error === null || error === void 0 ? void 0 : error.message) || "OpenAI request failed",
+                };
+            }
+        });
+    }
+    getClient() {
+        if (!this.client) {
+            this.client = new OpenAI(Object.assign({ apiKey: this.options.openAiApiKey }, this.getClientConfiguration()));
+        }
+        return this.client;
+    }
+    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);
+        }
+    }
+}

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type OpenAI from "openai";
+export type AdapterExtraRequestBodyParameters = Partial<Omit<OpenAI.Responses.ResponseCreateParamsNonStreaming, "stream">>;
 export interface AdapterOptions {
     /**
      * OpenAI API key. Go to https://platform.openai.com/, go to Dashboard -> API keys -> Create new secret key
@@ -28,7 +30,7 @@ export interface AdapterOptions {
     /**
      * Additional request body parameters to include in the API request.
      */
-    extraRequestBodyParameters?: Record<string, unknown>;
+    extraRequestBodyParameters?: AdapterExtraRequestBodyParameters;
     /**
      * Logs the exact JSON body sent to the OpenAI Responses endpoint.
      * Authorization headers are not logged.