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

package/dist/index.d.ts

@@ -1,14 +1,32 @@
 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;
+    outputSchema?: any;
+    reasoningEffort?: ReasoningEffort;
+    tools?: CompletionTool[];
+    onChunk?: StreamChunkCallback;
+};
 export default class CompletionAdapterOpenAIResponses implements CompletionAdapter {
     options: AdapterOptions;
     private encoding;
     constructor(options: AdapterOptions);
     validate(): void;
     measureTokensCount(content: string): number;
-    complete: (content: string, maxTokens?: number, outputSchema?: any, reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh", toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback, onChunk?: StreamChunkCallback) => Promise<{
+    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;
         error?: string;

package/dist/index.js

@@ -7,6 +7,20 @@ 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";
 function extractOutputText(data) {
     var _a;
@@ -80,13 +94,82 @@ function parseSseBlock(block) {
     }
     return data ? { event, data } : null;
 }
+function getAgentReasoningEffort(purpose) {
+    return purpose === "summary" ? "minimal" : "low";
+}
+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 = (content_1, ...args_1) => __awaiter(this, [content_1, ...args_1], void 0, function* (content, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
+        this.complete = (requestOrContent_1, ...args_1) => __awaiter(this, [requestOrContent_1, ...args_1], void 0, function* (requestOrContent, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
             var _a, _b, _c;
+            const request = typeof requestOrContent === "string"
+                ? {
+                    content: requestOrContent,
+                    maxTokens,
+                    outputSchema,
+                    reasoningEffort,
+                    tools: Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined,
+                    onChunk: typeof toolsOrOnChunk === "function"
+                        ? toolsOrOnChunk
+                        : onChunk,
+                }
+                : requestOrContent;
+            const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, onChunk: streamChunkCallback, } = request;
             const model = this.options.model || "gpt-5-nano";
-            const tools = Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined;
-            const streamChunkCallback = typeof toolsOrOnChunk === "function" ? toolsOrOnChunk : onChunk;
             const isStreaming = typeof streamChunkCallback === "function";
             const extra = this.options.extraRequestBodyParameters;
             let openAiTools = undefined;
@@ -99,16 +182,16 @@ export default class CompletionAdapterOpenAIResponses {
                     strict: true,
                 }));
             }
-            const body = Object.assign({ model, input: content, max_output_tokens: maxTokens, stream: isStreaming, text: outputSchema
+            const body = Object.assign({ model, input: content, max_output_tokens: requestMaxTokens, stream: isStreaming, text: requestOutputSchema
                     ? {
-                        format: Object.assign({ type: "json_schema" }, outputSchema),
+                        format: Object.assign({ type: "json_schema" }, requestOutputSchema),
                     }
                     : {
                         format: {
                             type: "text",
                         },
                     }, reasoning: {
-                    effort: reasoningEffort,
+                    effort: requestReasoningEffort,
                     summary: "auto",
                 }, tools: openAiTools }, extra);
             const resp = yield fetch("https://api.openai.com/v1/responses", {
@@ -324,7 +407,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");
         }
     }
@@ -336,4 +421,24 @@ export default class CompletionAdapterOpenAIResponses {
     measureTokensCount(content) {
         return this.encoding.encode(content).length;
     }
+    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,
+            }),
+            middleware: params.purpose === "primary"
+                ? [createOpenAiResponsesContinuationMiddleware()]
+                : [],
+        };
+    }
 }

package/index.ts

@@ -1,5 +1,12 @@
 import type { AdapterOptions } from "./types.js";
-import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
+import type {
+  CompletionAdapter,
+  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";
 
@@ -10,6 +17,25 @@ type StreamChunkCallback = (
   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;
+};
+
 type ResponseCreateBody = OpenAI.Responses.ResponseCreateParams;
 type OpenAIResponsesSuccess = OpenAI.Responses.Response;
 type OpenAIErrorResponse = {
@@ -26,6 +52,15 @@ type OpenAIFunctionCall = Extract<
   { type: "function_call" }
 >;
 
+type OpenAiResponsesMetadata = {
+  id?: string;
+};
+
+type OpenAiResponsesContext = {
+  sessionId: string;
+  turnId: string;
+};
+
 function extractOutputText(data: OpenAIResponsesSuccess): string {
   let text = "";
 
@@ -106,6 +141,93 @@ function parseSseBlock(block: string) {
   return data ? { event, data } : null;
 }
 
+function getAgentReasoningEffort(
+  purpose: AgentModelPurpose,
+): Exclude<ReasoningEffort, "none"> {
+  return purpose === "summary" ? "minimal" : "low";
+}
+
+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
 {
@@ -119,9 +241,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);
     }
   }
@@ -136,11 +258,40 @@ export default class CompletionAdapterOpenAIResponses
     return this.encoding.encode(content).length;
   }
 
+  getLangChainAgentSpec(params: {
+    maxTokens: number;
+    purpose: AgentModelPurpose;
+  }) {
+    const extraRequestBodyParameters =
+      (this.options.extraRequestBodyParameters || {}) as Record<string, unknown> & {
+        reasoning?: Record<string, unknown>;
+      };
+    const { reasoning, ...modelKwargs } = extraRequestBodyParameters;
+
+    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),
+      middleware:
+        params.purpose === "primary"
+          ? [createOpenAiResponsesContinuationMiddleware()]
+          : [],
+    };
+  }
+
   complete = async (
-    content: string,
+    requestOrContent: CompletionRequestInput | string,
     maxTokens = 50,
     outputSchema?: any,
-    reasoningEffort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" = "low",
+    reasoningEffort: ReasoningEffort = "low",
     toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback,
     onChunk?: StreamChunkCallback,
   ): Promise<{
@@ -148,10 +299,29 @@ export default class CompletionAdapterOpenAIResponses
     finishReason?: string;
     error?: string;
   }> => {
+    const request =
+      typeof requestOrContent === "string"
+        ? {
+            content: requestOrContent,
+            maxTokens,
+            outputSchema,
+            reasoningEffort,
+            tools: Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined,
+            onChunk:
+              typeof toolsOrOnChunk === "function"
+                ? toolsOrOnChunk
+                : onChunk,
+          }
+        : requestOrContent;
+    const {
+      content,
+      maxTokens: requestMaxTokens = 50,
+      outputSchema: requestOutputSchema,
+      reasoningEffort: requestReasoningEffort = "low",
+      tools,
+      onChunk: streamChunkCallback,
+    } = request;
     const model = this.options.model || "gpt-5-nano";
-    const tools = Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined;
-    const streamChunkCallback =
-      typeof toolsOrOnChunk === "function" ? toolsOrOnChunk : onChunk;
     const isStreaming = typeof streamChunkCallback === "function";
     const extra = this.options.extraRequestBodyParameters;
     let openAiTools: OpenAITool[] | undefined = undefined;
@@ -168,13 +338,13 @@ export default class CompletionAdapterOpenAIResponses
     const body = {
       model,
       input: content,
-      max_output_tokens: maxTokens,
+      max_output_tokens: requestMaxTokens,
       stream: isStreaming,
-      text: outputSchema
+      text: requestOutputSchema
         ? {
             format: {
               type: "json_schema",
-              ...outputSchema,
+              ...requestOutputSchema,
             },
           }
         : {
@@ -183,7 +353,7 @@ export default class CompletionAdapterOpenAIResponses
             },
           },
       reasoning: {
-        effort: reasoningEffort,
+        effort: requestReasoningEffort,
         summary: "auto",
       },
       tools: openAiTools,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/completion-adapter-openai-responses",
-  "version": "2.0.21",
+  "version": "2.0.24",
   "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"
   },