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

package/dist/index.d.ts

@@ -2,13 +2,22 @@ import type { AdapterOptions } from "./types.js";
 import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
 export type { AdapterOptions } from "./types.js";
 type StreamChunkCallback = (chunk: string, event?: CompletionStreamEvent) => void | Promise<void>;
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+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<{
+    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

@@ -82,11 +82,22 @@ function parseSseBlock(block) {
 }
 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 +110,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", {

package/index.ts

@@ -1,5 +1,9 @@
 import type { AdapterOptions } from "./types.js";
-import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
+import type {
+  CompletionAdapter,
+  CompletionStreamEvent,
+  CompletionTool,
+} from "adminforth";
 import { encoding_for_model, type TiktokenModel } from "tiktoken";
 import type OpenAI from "openai";
 
@@ -10,6 +14,23 @@ type StreamChunkCallback = (
   event?: CompletionStreamEvent,
 ) => void | Promise<void>;
 
+type ReasoningEffort =
+  | "none"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh";
+
+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 = {
@@ -137,10 +158,10 @@ export default class CompletionAdapterOpenAIResponses
   }
 
   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 +169,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 +208,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 +223,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.23",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",