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

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,13 @@ export default class CompletionAdapterOpenAIResponses implements CompletionAdapt
     constructor(options: AdapterOptions);
     validate(): void;
     measureTokensCount(content: string): number;
+    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,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,6 +94,64 @@ 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 = (requestOrContent_1, ...args_1) => __awaiter(this, [requestOrContent_1, ...args_1], void 0, function* (requestOrContent, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
@@ -335,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");
         }
     }
@@ -347,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

@@ -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,15 @@ type OpenAIFunctionCall = Extract<
   { type: "function_call" }
 >;
 
+type OpenAiResponsesMetadata = {
+  id?: string;
+};
+
+type OpenAiResponsesContext = {
+  sessionId: string;
+  turnId: string;
+};
+
 function extractOutputText(data: OpenAIResponsesSuccess): string {
   let text = "";
 
@@ -127,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
 {
@@ -140,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);
     }
   }
@@ -157,6 +258,35 @@ 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 (
     requestOrContent: CompletionRequestInput | string,
     maxTokens = 50,

package/package.json

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