@adminforth/completion-adapter-openai-responses 2.0.23 → 2.0.25

package/README.md

@@ -24,6 +24,19 @@ const adapter = new CompletionAdapterOpenAIResponses({
 });
 ```
 
+OpenAI-compatible providers can be used by overriding the base URL:
+
+```ts
+const adapter = new CompletionAdapterOpenAIResponses({
+	openAiApiKey: process.env.OVH_AI_ENDPOINTS_ACCESS_TOKEN as string,
+	baseUrl: "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1",
+	model: "gpt-oss-20b",
+	extraRequestBodyParameters: {
+		store: false,
+	},
+});
+```
+
 The adapter supports:
 
 - regular text completion

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import type { AdapterOptions } from "./types.js";
 import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
+import { ChatOpenAI } from "@langchain/openai";
 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;
@@ -17,6 +19,22 @@ export default class CompletionAdapterOpenAIResponses implements CompletionAdapt
     constructor(options: AdapterOptions);
     validate(): void;
     measureTokensCount(content: string): number;
+    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>;
+        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<{
         content?: string;
         finishReason?: string;

package/dist/index.js

@@ -7,7 +7,23 @@ 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 = "";
@@ -80,6 +96,68 @@ function parseSseBlock(block) {
     }
     return data ? { event, data } : null;
 }
+function getAgentReasoningEffort(purpose) {
+    return purpose === "summary" ? "minimal" : "low";
+}
+function buildReasoningConfig(params) {
+    var _a;
+    return Object.assign({ summary: "detailed", 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.complete = (requestOrContent_1, ...args_1) => __awaiter(this, [requestOrContent_1, ...args_1], void 0, function* (requestOrContent, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
@@ -100,6 +178,7 @@ export default class CompletionAdapterOpenAIResponses {
             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) => ({
@@ -107,7 +186,7 @@ export default class CompletionAdapterOpenAIResponses {
                     name: tool.name,
                     description: tool.description,
                     parameters: tool.input_schema,
-                    strict: true,
+                    strict: false,
                 }));
             }
             const body = Object.assign({ model, input: content, max_output_tokens: requestMaxTokens, stream: isStreaming, text: requestOutputSchema
@@ -118,17 +197,21 @@ export default class CompletionAdapterOpenAIResponses {
                         format: {
                             type: "text",
                         },
-                    }, reasoning: {
+                    }, reasoning: Object.assign({}, buildReasoningConfig({
+                    reasoning: extraReasoning,
                     effort: requestReasoningEffort,
-                    summary: "auto",
-                }, tools: openAiTools }, extra);
-            const resp = yield fetch("https://api.openai.com/v1/responses", {
+                })), tools: openAiTools }, extraWithoutReasoning);
+            const serializedBody = JSON.stringify(body);
+            if (this.shouldDumpRawRequest()) {
+                this.dumpRawRequest(this.getResponsesUrl(), serializedBody);
+            }
+            const resp = yield fetch(this.getResponsesUrl(), {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                     Authorization: `Bearer ${this.options.openAiApiKey}`,
                 },
-                body: JSON.stringify(body),
+                body: serializedBody,
             });
             if (!resp.ok) {
                 let errorMessage = `OpenAI request failed with status ${resp.status}`;
@@ -137,7 +220,7 @@ export default class CompletionAdapterOpenAIResponses {
                     if ((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message)
                         errorMessage = errorData.error.message;
                 }
-                catch (_d) { }
+                catch (_e) { }
                 return { error: errorMessage };
             }
             if (!isStreaming) {
@@ -259,7 +342,7 @@ export default class CompletionAdapterOpenAIResponses {
                         try {
                             event = JSON.parse(parsedBlock.data);
                         }
-                        catch (_e) {
+                        catch (_f) {
                             continue;
                         }
                         if ((_c = event === null || event === void 0 ? void 0 : event.error) === null || _c === void 0 ? void 0 : _c.message) {
@@ -335,7 +418,9 @@ export default class CompletionAdapterOpenAIResponses {
             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:`);
+            // 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");
         }
     }
@@ -347,4 +432,98 @@ export default class CompletionAdapterOpenAIResponses {
     measureTokensCount(content) {
         return this.encoding.encode(content).length;
     }
+    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

@@ -5,6 +5,21 @@ export interface AdapterOptions {
      * 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`.
@@ -14,4 +29,9 @@ export interface AdapterOptions {
      * 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/index.ts

@@ -4,6 +4,9 @@ import type {
   CompletionStreamEvent,
   CompletionTool,
 } from "adminforth";
+import { AIMessage } from "@langchain/core/messages";
+import { ChatOpenAI } from "@langchain/openai";
+import { createMiddleware } from "langchain";
 import { encoding_for_model, type TiktokenModel } from "tiktoken";
 import type OpenAI from "openai";
 
@@ -22,6 +25,8 @@ type ReasoningEffort =
   | "high"
   | "xhigh";
 
+type AgentModelPurpose = "primary" | "summary";
+
 type CompletionRequestInput = {
   content: string;
   maxTokens?: number;
@@ -47,6 +52,21 @@ type OpenAIFunctionCall = Extract<
   { type: "function_call" }
 >;
 
+type OpenAiResponsesMetadata = {
+  id?: string;
+};
+
+type OpenAiResponsesContext = {
+  sessionId: string;
+  turnId: string;
+};
+
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const RAW_REQUEST_LOG_PREFIX = "[CompletionAdapterOpenAIResponses] Raw /responses request";
+
+type FetchInput = Parameters<typeof fetch>[0];
+type FetchInit = Parameters<typeof fetch>[1];
+
 function extractOutputText(data: OpenAIResponsesSuccess): string {
   let text = "";
 
@@ -127,6 +147,104 @@ function parseSseBlock(block: string) {
   return data ? { event, data } : null;
 }
 
+function getAgentReasoningEffort(
+  purpose: AgentModelPurpose,
+): Exclude<ReasoningEffort, "none"> {
+  return purpose === "summary" ? "minimal" : "low";
+}
+
+function buildReasoningConfig(params: {
+  reasoning?: Record<string, unknown>;
+  effort: Exclude<ReasoningEffort, "none"> | ReasoningEffort;
+}) {
+  return {
+    summary: "detailed",
+    effort: params.effort,
+    ...(params.reasoning ?? {}),
+  };
+}
+
+function getTurnKey(context: OpenAiResponsesContext) {
+  return `${context.sessionId}:${context.turnId}`;
+}
+
+function getResponseId(message: AIMessage) {
+  const metadata = message.response_metadata as OpenAiResponsesMetadata | undefined;
+  return metadata?.id ?? null;
+}
+
+function getPreviousResponseId(modelSettings?: Record<string, unknown>) {
+  return (modelSettings as { previous_response_id?: string } | undefined)
+    ?.previous_response_id;
+}
+
+function getContinuationMessages<T extends { response_metadata?: unknown }>(
+  messages: T[],
+  previousResponseId: string,
+) {
+  let continuationStartIndex: number | null = null;
+
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+
+    if (
+      AIMessage.isInstance(message) &&
+      (message.response_metadata as OpenAiResponsesMetadata | undefined)?.id ===
+        previousResponseId
+    ) {
+      continuationStartIndex = index + 1;
+      break;
+    }
+  }
+
+  if (continuationStartIndex === null) {
+    return null;
+  }
+
+  return messages.slice(continuationStartIndex);
+}
+
+function createOpenAiResponsesContinuationMiddleware() {
+  const responseIdsByTurn = new Map<string, string>();
+
+  return createMiddleware({
+    name: "OpenAiResponsesContinuationMiddleware",
+    async wrapModelCall(request, handler) {
+      const context = request.runtime.context as OpenAiResponsesContext;
+      const turnKey = getTurnKey(context);
+      const previousResponseId =
+        getPreviousResponseId(request.modelSettings) ??
+        responseIdsByTurn.get(turnKey);
+      const continuationMessages = previousResponseId
+        ? getContinuationMessages(request.messages, previousResponseId)
+        : null;
+
+      const response = (await handler(
+        previousResponseId && continuationMessages
+          ? {
+              ...request,
+              messages: continuationMessages,
+              modelSettings: {
+                ...request.modelSettings,
+                previous_response_id: previousResponseId,
+              },
+            }
+          : request,
+      )) as AIMessage;
+
+      const responseId = getResponseId(response);
+
+      if (responseId) {
+        responseIdsByTurn.set(turnKey, responseId);
+      } else {
+        responseIdsByTurn.delete(turnKey);
+      }
+
+      return response;
+    },
+  });
+}
+
 export default class CompletionAdapterOpenAIResponses
   implements CompletionAdapter
 {
@@ -140,9 +258,9 @@ export default class CompletionAdapterOpenAIResponses
         (this.options.model || "gpt-5-nano") as TiktokenModel,
       );
     } catch (error) {
-      console.warn(
-        `Failed to initialize tiktoken tokenizer for model "${this.options.model}", falling back to "gpt-5-nano". 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" as TiktokenModel);
     }
   }
@@ -157,6 +275,133 @@ export default class CompletionAdapterOpenAIResponses
     return this.encoding.encode(content).length;
   }
 
+  private getConfiguredBaseUrl() {
+    return this.options.baseUrl;
+  }
+
+  private shouldUseComplitionApi() {
+    if (typeof this.options.useComplitionApi === "boolean") {
+      return this.options.useComplitionApi;
+    }
+
+    return Boolean(this.getConfiguredBaseUrl());
+  }
+
+  private shouldDumpRawRequest() {
+    return this.options.dumpRawRequest === true;
+  }
+
+  private getClientConfiguration() {
+    const configuredBaseUrl = this.getConfiguredBaseUrl();
+    const debugFetch = this.shouldDumpRawRequest()
+      ? this.createResponsesDebugFetch()
+      : undefined;
+
+    if (!configuredBaseUrl && !debugFetch) {
+      return undefined;
+    }
+
+    return {
+      ...(configuredBaseUrl ? { baseURL: configuredBaseUrl } : {}),
+      ...(debugFetch ? { fetch: debugFetch } : {}),
+    };
+  }
+
+  private createResponsesDebugFetch() {
+    return async (input: FetchInput, init?: FetchInit) => {
+      const url = this.getFetchUrl(input);
+
+      if (this.isResponsesUrl(url) && typeof init?.body === "string") {
+        this.dumpRawRequest(url, init.body);
+      }
+
+      return fetch(input, init);
+    };
+  }
+
+  private getFetchUrl(input: FetchInput) {
+    if (typeof input === "string") {
+      return input;
+    }
+
+    if (input instanceof URL) {
+      return input.toString();
+    }
+
+    return input.url;
+  }
+
+  private isResponsesUrl(url: string) {
+    try {
+      return new URL(url).pathname.endsWith("/responses");
+    } catch {
+      return url.endsWith("/responses") || url.includes("/responses?");
+    }
+  }
+
+  private dumpRawRequest(url: string, body: string) {
+    console.info(`${RAW_REQUEST_LOG_PREFIX} ${url}`);
+    try {
+      console.info(JSON.stringify(JSON.parse(body), null, 2));
+    } catch {
+      console.info(body);
+    }
+  }
+
+  private getResponsesUrl() {
+    const baseUrl = this.getConfiguredBaseUrl() || DEFAULT_OPENAI_BASE_URL;
+    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+
+    return new URL("responses", normalizedBaseUrl).toString();
+  }
+
+  getLangChainAgentSpec(params: {
+    maxTokens: number;
+    purpose: AgentModelPurpose;
+  }) {
+    const extraRequestBodyParameters =
+      (this.options.extraRequestBodyParameters || {}) as Record<string, unknown> & {
+        reasoning?: Record<string, unknown>;
+        text?: Record<string, unknown>;
+      };
+    const { reasoning, ...modelKwargs } = extraRequestBodyParameters;
+    const configuredBaseUrl = this.getConfiguredBaseUrl();
+    const normalizedModelKwargs = { ...modelKwargs };
+
+
+    const clientConfiguration = this.getClientConfiguration();
+    const useComplitionApi = this.shouldUseComplitionApi();
+    const chatOpenAiOptions: Record<string, unknown> = {
+      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 as any),
+      middleware:
+        params.purpose === "primary" && supportsResponseContinuation
+          ? [createOpenAiResponsesContinuationMiddleware()]
+          : [],
+    };
+  }
+
   complete = async (
     requestOrContent: CompletionRequestInput | string,
     maxTokens = 50,
@@ -193,7 +438,11 @@ export default class CompletionAdapterOpenAIResponses
     } = request;
     const model = this.options.model || "gpt-5-nano";
     const isStreaming = typeof streamChunkCallback === "function";
-    const extra = this.options.extraRequestBodyParameters;
+    const extra =
+      this.options.extraRequestBodyParameters as
+        | (Record<string, unknown> & { reasoning?: Record<string, unknown> })
+        | undefined;
+    const { reasoning: extraReasoning, ...extraWithoutReasoning } = extra ?? {};
     let openAiTools: OpenAITool[] | undefined = undefined;
     if (tools && tools.length > 0) {
       openAiTools = tools.map((tool) => ({
@@ -201,7 +450,7 @@ export default class CompletionAdapterOpenAIResponses
         name: tool.name,
         description: tool.description,
         parameters: tool.input_schema,
-        strict: true,
+        strict: false,
       }));
     }
 
@@ -223,20 +472,28 @@ export default class CompletionAdapterOpenAIResponses
             },
           },
       reasoning: {
-        effort: requestReasoningEffort,
-        summary: "auto",
+        ...buildReasoningConfig({
+          reasoning: extraReasoning,
+          effort: requestReasoningEffort,
+        }),
       },
       tools: openAiTools,
-      ...extra,
+      ...extraWithoutReasoning,
     } as ResponseCreateBody;
 
-    const resp = await fetch("https://api.openai.com/v1/responses", {
+    const serializedBody = JSON.stringify(body);
+
+    if (this.shouldDumpRawRequest()) {
+      this.dumpRawRequest(this.getResponsesUrl(), serializedBody);
+    }
+
+    const resp = await fetch(this.getResponsesUrl(), {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.options.openAiApiKey}`,
       },
-      body: JSON.stringify(body),
+      body: serializedBody,
     });
 
     if (!resp.ok) {
@@ -455,4 +712,4 @@ export default class CompletionAdapterOpenAIResponses
       reader.releaseLock();
     }
   };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/completion-adapter-openai-responses",
-  "version": "2.0.23",
+  "version": "2.0.25",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -9,13 +9,16 @@
     "rollout": "npm run build && npm publish --access public"
   },
   "keywords": [],
-  "author": "",
+  "author": "DevForth (https://devforth.io)",
   "license": "MIT",
   "description": "AdminForth completion adapter for the OpenAI Responses API.",
   "devDependencies": {
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@langchain/core": "^1.1.41",
+    "@langchain/openai": "1.4.4",
+    "langchain": "^1.3.4",
     "openai": "^6.34.0",
     "tiktoken": "^1.0.22"
   },

package/types.ts

@@ -6,6 +6,23 @@ export interface AdapterOptions {
    */
   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`.
@@ -16,4 +33,10 @@ export interface AdapterOptions {
    * 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;
+}