@adminforth/completion-adapter-openai-responses 2.0.24 → 2.0.26

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

@@ -19,6 +19,15 @@ 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;

package/dist/index.js

@@ -22,6 +22,8 @@ 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 = "";
@@ -97,6 +99,10 @@ function parseSseBlock(block) {
 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}`;
 }
@@ -172,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) => ({
@@ -179,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
@@ -190,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}`;
@@ -209,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) {
@@ -331,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) {
@@ -421,22 +432,96 @@ 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"]);
-        return {
-            model: new ChatOpenAI({
-                model: this.options.model || "gpt-5-nano",
-                apiKey: this.options.openAiApiKey,
-                useResponsesApi: true,
-                maxTokens: params.maxTokens,
-                reasoning: reasoning !== null && reasoning !== void 0 ? reasoning : {
-                    effort: getAgentReasoningEffort(params.purpose),
-                    summary: "auto",
-                },
-                modelKwargs,
+        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),
             }),
-            middleware: params.purpose === "primary"
+            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

@@ -61,6 +61,12 @@ type OpenAiResponsesContext = {
   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 = "";
 
@@ -147,6 +153,17 @@ function getAgentReasoningEffort(
   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}`;
 }
@@ -258,6 +275,86 @@ 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;
@@ -265,23 +362,41 @@ export default class CompletionAdapterOpenAIResponses
     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({
-        model: this.options.model || "gpt-5-nano",
-        apiKey: this.options.openAiApiKey,
-        useResponsesApi: true,
-        maxTokens: params.maxTokens,
-        reasoning: reasoning ?? {
-          effort: getAgentReasoningEffort(params.purpose),
-          summary: "auto",
-        },
-        modelKwargs,
-      } as any),
+      model: new ChatOpenAI(chatOpenAiOptions as any),
       middleware:
-        params.purpose === "primary"
+        params.purpose === "primary" && supportsResponseContinuation
           ? [createOpenAiResponsesContinuationMiddleware()]
           : [],
     };
@@ -323,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) => ({
@@ -331,7 +450,7 @@ export default class CompletionAdapterOpenAIResponses
         name: tool.name,
         description: tool.description,
         parameters: tool.input_schema,
-        strict: true,
+        strict: false,
       }));
     }
 
@@ -353,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) {
@@ -585,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.24",
+  "version": "2.0.26",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

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;
+}