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

package/README.md

@@ -45,3 +45,23 @@ The adapter supports:
 - tool calls
 - streaming output chunks
 - streaming reasoning chunks
+- Responses API continuation with `previousResponseId`
+
+## Responses continuation
+
+For regular completion flows you can pass the previous Responses API id to reuse
+server-side context. The adapter returns the current `responseId`, which can be
+used as `previousResponseId` on the next call:
+
+```ts
+const first = await adapter.complete({
+	content: "Summarize the project requirements",
+	maxTokens: 300,
+});
+
+const second = await adapter.complete({
+	content: "Now turn that into three implementation milestones",
+	maxTokens: 300,
+	previousResponseId: first.responseId,
+});
+```

package/dist/index.d.ts

@@ -1,34 +1,13 @@
 import type { AdapterOptions } from "./types.js";
-import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
-import { ChatOpenAI } from "@langchain/openai";
+import type { CompletionAdapter, CompletionTool } from "adminforth";
+import { type CompletionRequestInput, type CompletionResult, type ReasoningEffort, type StreamChunkCallback } from "./openai.js";
+import { type AgentModelPurpose } from "./langchain.js";
 export type { AdapterOptions } from "./types.js";
-type StreamChunkCallback = (chunk: string, event?: CompletionStreamEvent) => void | Promise<void>;
-type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
-type AgentModelPurpose = "primary" | "summary";
-type CompletionRequestInput = {
-    content: string;
-    maxTokens?: number;
-    outputSchema?: any;
-    reasoningEffort?: ReasoningEffort;
-    tools?: CompletionTool[];
-    onChunk?: StreamChunkCallback;
-    signal?: AbortSignal;
-};
-type UsedTokens = {
-    input_uncached: number;
-    input_cached: number;
-    output: number;
-};
-type CompletionResult = {
-    content?: string;
-    finishReason?: string;
-    error?: string;
-    used_tokens?: UsedTokens;
-};
-export default class CompletionAdapterOpenAIResponses implements CompletionAdapter {
+declare class CompletionAdapterOpenAIResponses implements CompletionAdapter {
     options: AdapterOptions;
     private encoding;
     private activeAbortController;
+    private openAi;
     constructor(options: AdapterOptions);
     validate(): void;
     measureTokensCount(content: string): number;
@@ -36,19 +15,14 @@ export default class CompletionAdapterOpenAIResponses implements CompletionAdapt
     isGenerationInProgress(): boolean;
     private getConfiguredBaseUrl;
     private shouldUseComplitionApi;
-    private shouldDumpRawRequest;
-    private getClientConfiguration;
-    private createResponsesDebugFetch;
-    private getFetchUrl;
-    private isResponsesUrl;
-    private dumpRawRequest;
-    private getResponsesUrl;
     getLangChainAgentSpec(params: {
         maxTokens: number;
         purpose: AgentModelPurpose;
     }): {
-        model: ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions>;
+        model: import("@langchain/openai").ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions>;
         middleware: import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>[];
     };
     complete: (requestOrContent: CompletionRequestInput | string, maxTokens?: number, outputSchema?: any, reasoningEffort?: ReasoningEffort, toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback, onChunk?: StreamChunkCallback) => Promise<CompletionResult>;
 }
+export { CompletionAdapterOpenAIResponses };
+export default CompletionAdapterOpenAIResponses;

package/dist/index.js

@@ -7,175 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 {
+import { OpenAIResponsesService, } from "./openai.js";
+import { createLangChainAgentSpec, } from "./langchain.js";
+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,
@@ -188,37 +26,7 @@ export default class CompletionAdapterOpenAIResponses {
                         : 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 { signal: requestSignal } = request;
             const abortController = new AbortController();
             this.activeAbortController = abortController;
             const abortFromRequestSignal = () => abortController.abort(requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.reason);
@@ -228,269 +36,18 @@ export default class CompletionAdapterOpenAIResponses {
             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",
-                };
+                return yield this.openAi.complete(request, abortController.signal);
             }
             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;
+        this.openAi = new OpenAIResponsesService(options);
         try {
             this.encoding = encoding_for_model((this.options.model || "gpt-5-nano"));
         }
@@ -525,89 +82,16 @@ export default class CompletionAdapterOpenAIResponses {
         }
         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,
+        return createLangChainAgentSpec({
+            options: this.options,
             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()]
-                : [],
-        };
+            purpose: params.purpose,
+            configuredBaseUrl: this.getConfiguredBaseUrl(),
+            clientConfiguration: this.openAi.getClientConfiguration(),
+            useComplitionApi: this.shouldUseComplitionApi(),
+        });
     }
 }
+export { CompletionAdapterOpenAIResponses };
+export default CompletionAdapterOpenAIResponses;