@adminforth/completion-adapter-open-ai-chat-gpt 2.0.11 → 2.0.13

package/dist/index.js

@@ -8,48 +8,111 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { encoding_for_model } from "tiktoken";
+function extractOutputText(data) {
+    var _a;
+    let text = "";
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type !== "message" || !Array.isArray(item.content))
+            continue;
+        for (const part of item.content) {
+            if (part.type === "output_text" && typeof part.text === "string") {
+                text += part.text;
+            }
+        }
+    }
+    return text;
+}
+function extractReasoning(data) {
+    var _a, _b, _c;
+    let reasoning = "";
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type !== "reasoning")
+            continue;
+        for (const part of (_b = item.summary) !== null && _b !== void 0 ? _b : []) {
+            if ((part === null || part === void 0 ? void 0 : part.type) === "summary_text" && typeof part.text === "string") {
+                reasoning += part.text;
+            }
+        }
+        if (!reasoning) {
+            for (const part of (_c = item.content) !== null && _c !== void 0 ? _c : []) {
+                if ((part === null || part === void 0 ? void 0 : part.type) === "reasoning_text" && typeof part.text === "string") {
+                    reasoning += part.text;
+                }
+            }
+        }
+    }
+    return reasoning || undefined;
+}
+function parseSseBlock(block) {
+    let event;
+    let data = "";
+    for (const rawLine of block.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        if (line.startsWith("data:"))
+            data += line.slice(5).trim();
+    }
+    return data ? { event, data } : null;
+}
 export default class CompletionAdapterOpenAIChatGPT {
     constructor(options) {
         //@ts-ignore
-        this.complete = (content_1, ...args_1) => __awaiter(this, [content_1, ...args_1], void 0, function* (content, maxTokens = 50, outputSchema, onChunk) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            // stop parameter is alredy not supported
-            // adapter users should explicitely ask model to stop at dot if needed (or "Complete only up to the end of sentence")
+        this.complete = (content_1, ...args_1) => __awaiter(this, [content_1, ...args_1], void 0, function* (content, maxTokens = 50, outputSchema, reasoningEffort = "low", onChunk) {
+            var _a, _b, _c;
             const model = this.options.model || "gpt-5-nano";
             const isStreaming = typeof onChunk === "function";
-            const resp = yield fetch("https://api.openai.com/v1/chat/completions", {
+            const body = {
+                model,
+                input: content,
+                max_output_tokens: maxTokens,
+                stream: isStreaming,
+                text: outputSchema
+                    ? {
+                        format: Object.assign({ type: "json_schema" }, outputSchema),
+                    }
+                    : {
+                        format: {
+                            type: "text",
+                        },
+                    },
+                reasoning: {
+                    effort: reasoningEffort,
+                }
+            };
+            const resp = yield fetch("https://api.openai.com/v1/responses", {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                     Authorization: `Bearer ${this.options.openAiApiKey}`,
                 },
-                body: JSON.stringify(Object.assign({ model, messages: [
-                        {
-                            role: "user",
-                            content,
-                        },
-                    ], max_completion_tokens: maxTokens, response_format: outputSchema
-                        ? Object.assign({ type: "json_schema" }, outputSchema) : undefined, stream: isStreaming }, this.options.extraRequestBodyParameters)),
+                body: JSON.stringify(body),
             });
             if (!resp.ok) {
                 let errorMessage = `OpenAI request failed with status ${resp.status}`;
                 try {
-                    const errorData = yield resp.json();
-                    if ((_a = errorData === null || errorData === void 0 ? void 0 : errorData.error) === null || _a === void 0 ? void 0 : _a.message) {
+                    const errorData = (yield resp.json());
+                    if ((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message)
                         errorMessage = errorData.error.message;
-                    }
                 }
-                catch (_p) { }
+                catch (_d) { }
                 return { error: errorMessage };
             }
             if (!isStreaming) {
-                const data = yield resp.json();
+                const json = yield resp.json();
+                const data = json;
                 if (data.error) {
                     return { error: data.error.message };
                 }
+                const parsedContent = extractOutputText(data);
+                const reasoning = extractReasoning(data);
                 return {
-                    content: (_d = (_c = (_b = data.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) === null || _d === void 0 ? void 0 : _d.content,
-                    finishReason: (_f = (_e = data.choices) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.finish_reason,
+                    content: parsedContent,
+                    finishReason: ((_b = data.incomplete_details) === null || _b === void 0 ? void 0 : _b.reason)
+                        ? data.incomplete_details.reason
+                        : undefined,
                 };
             }
             if (!resp.body) {
@@ -59,79 +122,121 @@ export default class CompletionAdapterOpenAIChatGPT {
             const decoder = new TextDecoder("utf-8");
             let buffer = "";
             let fullContent = "";
+            let fullReasoning = "";
             let finishReason;
+            const handleEvent = (event, eventType) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d;
+                const type = (event === null || event === void 0 ? void 0 : event.type) || eventType;
+                if (type === "response.output_text.delta") {
+                    const delta = (event === null || event === void 0 ? void 0 : event.delta) || "";
+                    if (!delta)
+                        return;
+                    fullContent += delta;
+                    yield (onChunk === null || onChunk === void 0 ? void 0 : onChunk(delta, { type: "output", delta, text: fullContent }));
+                    return;
+                }
+                if (type === "response.reasoning_summary_text.delta" ||
+                    type === "response.reasoning_text.delta") {
+                    const delta = (event === null || event === void 0 ? void 0 : event.delta) || "";
+                    if (!delta)
+                        return;
+                    fullReasoning += delta;
+                    yield (onChunk === null || onChunk === void 0 ? void 0 : onChunk(delta, {
+                        type: "reasoning",
+                        delta,
+                        text: fullReasoning,
+                    }));
+                    return;
+                }
+                if (type === "response.completed" ||
+                    type === "response.incomplete") {
+                    const response = event === null || event === void 0 ? void 0 : event.response;
+                    if (!response)
+                        return;
+                    const finalContent = extractOutputText(response);
+                    if (finalContent.startsWith(fullContent)) {
+                        const delta = finalContent.slice(fullContent.length);
+                        if (delta) {
+                            fullContent = finalContent;
+                            yield (onChunk === null || onChunk === void 0 ? void 0 : onChunk(delta, {
+                                type: "output",
+                                delta,
+                                text: fullContent,
+                            }));
+                        }
+                    }
+                    const finalReasoning = extractReasoning(response) || "";
+                    if (finalReasoning.startsWith(fullReasoning)) {
+                        const delta = finalReasoning.slice(fullReasoning.length);
+                        if (delta) {
+                            fullReasoning = finalReasoning;
+                            yield (onChunk === null || onChunk === void 0 ? void 0 : onChunk(delta, {
+                                type: "reasoning",
+                                delta,
+                                text: fullReasoning,
+                            }));
+                        }
+                    }
+                    finishReason =
+                        ((_a = response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason) || response.status || finishReason;
+                    return;
+                }
+                if (type === "response.failed") {
+                    throw new Error(((_c = (_b = event === null || event === void 0 ? void 0 : event.response) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) ||
+                        ((_d = event === null || event === void 0 ? void 0 : event.error) === null || _d === void 0 ? void 0 : _d.message) ||
+                        "Response failed");
+                }
+            });
             try {
                 while (true) {
                     const { value, done } = yield reader.read();
-                    if (done) {
+                    if (done)
                         break;
-                    }
                     buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() || "";
-                    for (const rawLine of lines) {
-                        const line = rawLine.trim();
-                        if (!line || !line.startsWith("data:")) {
+                    const blocks = buffer.split("\n\n");
+                    buffer = blocks.pop() || "";
+                    for (const block of blocks) {
+                        const parsedBlock = parseSseBlock(block);
+                        if (!(parsedBlock === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) || parsedBlock.data === "[DONE]")
                             continue;
-                        }
-                        const dataStr = line.slice(5).trim();
-                        if (dataStr === "[DONE]") {
-                            return {
-                                content: fullContent,
-                                finishReason,
-                            };
-                        }
-                        let parsed;
+                        let event;
                         try {
-                            parsed = JSON.parse(dataStr);
+                            event = JSON.parse(parsedBlock.data);
                         }
-                        catch (_q) {
+                        catch (_e) {
                             continue;
                         }
-                        if ((_g = parsed.error) === null || _g === void 0 ? void 0 : _g.message) {
-                            return { error: parsed.error.message };
+                        if ((_c = event === null || event === void 0 ? void 0 : event.error) === null || _c === void 0 ? void 0 : _c.message) {
+                            return { error: event.error.message };
                         }
-                        const choice = (_h = parsed.choices) === null || _h === void 0 ? void 0 : _h[0];
-                        if (!choice) {
-                            continue;
-                        }
-                        if (choice.finish_reason) {
-                            finishReason = choice.finish_reason;
-                        }
-                        const chunk = (_k = (_j = choice.delta) === null || _j === void 0 ? void 0 : _j.content) !== null && _k !== void 0 ? _k : "";
-                        if (!chunk) {
-                            continue;
-                        }
-                        fullContent += chunk;
-                        yield onChunk(chunk);
+                        yield handleEvent(event, parsedBlock.event);
                     }
                 }
-                if (buffer.trim().startsWith("data:")) {
-                    const dataStr = buffer.trim().slice(5).trim();
-                    if (dataStr && dataStr !== "[DONE]") {
+                if (buffer.trim()) {
+                    const parsedBlock = parseSseBlock(buffer.trim());
+                    if ((parsedBlock === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) && parsedBlock.data !== "[DONE]") {
                         try {
-                            const parsed = JSON.parse(dataStr);
-                            const choice = (_l = parsed.choices) === null || _l === void 0 ? void 0 : _l[0];
-                            const chunk = (_o = (_m = choice === null || choice === void 0 ? void 0 : choice.delta) === null || _m === void 0 ? void 0 : _m.content) !== null && _o !== void 0 ? _o : "";
-                            if (chunk) {
-                                fullContent += chunk;
-                                yield onChunk(chunk);
-                            }
-                            if (choice === null || choice === void 0 ? void 0 : choice.finish_reason) {
-                                finishReason = choice.finish_reason;
-                            }
+                            yield handleEvent(JSON.parse(parsedBlock.data), parsedBlock.event);
+                        }
+                        catch (error) {
+                            return {
+                                error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                                content: fullContent || undefined,
+                                finishReason,
+                            };
                         }
-                        catch (_r) { }
                     }
                 }
                 return {
-                    content: fullContent,
+                    content: fullContent || undefined,
                     finishReason,
                 };
             }
             catch (error) {
                 return {
                     error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                    content: fullContent || undefined,
+                    finishReason,
                 };
             }
             finally {
@@ -147,8 +252,6 @@ export default class CompletionAdapterOpenAIChatGPT {
         }
     }
     measureTokensCount(content) {
-        //TODO: Implement token counting logic
-        const tokens = this.encoding.encode(content);
-        return tokens.length;
+        return this.encoding.encode(content).length;
     }
 }

package/index.ts

@@ -1,8 +1,76 @@
 import type { AdapterOptions } from "./types.js";
-import type { CompletionAdapter } from "adminforth";
+import type { CompletionAdapter, CompletionStreamEvent } from "adminforth";
 import { encoding_for_model, type TiktokenModel } from "tiktoken";
+import type OpenAI from "openai";
 
-type StreamChunkCallback = (chunk: string) => void | Promise<void>;
+type StreamChunkCallback = (
+  chunk: string,
+  event?: CompletionStreamEvent,
+) => void | Promise<void>;
+
+type ResponseCreateBody = OpenAI.Responses.ResponseCreateParams;
+type OpenAIResponsesSuccess = OpenAI.Responses.Response;
+type OpenAIErrorResponse = {
+  error?: {
+    message?: string;
+    type?: string;
+    param?: string | null;
+    code?: string | null;
+  };
+};
+
+function extractOutputText(data: OpenAIResponsesSuccess): string {
+  let text = "";
+
+  for (const item of data.output ?? []) {
+    if (item.type !== "message" || !Array.isArray(item.content)) continue;
+    for (const part of item.content) {
+      if (part.type === "output_text" && typeof part.text === "string") {
+        text += part.text;
+      }
+    }
+  }
+
+  return text;
+}
+
+function extractReasoning(data: OpenAIResponsesSuccess): string | undefined {
+  let reasoning = "";
+
+  for (const item of data.output ?? []) {
+    if (item.type !== "reasoning") continue;
+
+    for (const part of item.summary ?? []) {
+      if (part?.type === "summary_text" && typeof part.text === "string") {
+        reasoning += part.text;
+      }
+    }
+
+    if (!reasoning) {
+      for (const part of item.content ?? []) {
+        if (part?.type === "reasoning_text" && typeof part.text === "string") {
+          reasoning += part.text;
+        }
+      }
+    }
+  }
+
+  return reasoning || undefined;
+}
+
+function parseSseBlock(block: string) {
+  let event: string | undefined;
+  let data = "";
+
+  for (const rawLine of block.split("\n")) {
+    const line = rawLine.trimEnd();
+    if (!line) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    if (line.startsWith("data:")) data += line.slice(5).trim();
+  }
+
+  return data ? { event, data } : null;
+}
 
 export default class CompletionAdapterOpenAIChatGPT
   implements CompletionAdapter
@@ -13,7 +81,7 @@ export default class CompletionAdapterOpenAIChatGPT
   constructor(options: AdapterOptions) {
     this.options = options;
     this.encoding = encoding_for_model(
-      (this.options.model || "gpt-5-nano") as TiktokenModel
+      (this.options.model || "gpt-5-nano") as TiktokenModel,
     );
   }
 
@@ -24,72 +92,77 @@ export default class CompletionAdapterOpenAIChatGPT
   }
 
   measureTokensCount(content: string): number {
-    //TODO: Implement token counting logic
-    const tokens = this.encoding.encode(content);
-    return tokens.length;
+    return this.encoding.encode(content).length;
   }
   //@ts-ignore
   complete = async (
     content: string,
-    maxTokens: number = 50,
+    maxTokens = 50,
     outputSchema?: any,
+    reasoningEffort: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' = "low",
     onChunk?: StreamChunkCallback,
   ): Promise<{
     content?: string;
     finishReason?: string;
     error?: string;
   }> => {
-    // stop parameter is alredy not supported
-    // adapter users should explicitely ask model to stop at dot if needed (or "Complete only up to the end of sentence")
     const model = this.options.model || "gpt-5-nano";
     const isStreaming = typeof onChunk === "function";
+    const body = {
+      model,
+      input: content,
+      max_output_tokens: maxTokens,
+      stream: isStreaming,
+      text: outputSchema
+        ? {
+            format: {
+              type: "json_schema",
+              ...outputSchema,
+            },
+          }
+        : {
+            format: {
+              type: "text",
+            },
+          },
+        reasoning: {
+          effort: reasoningEffort,
+        }
+    } as ResponseCreateBody;
 
-    const resp = await fetch("https://api.openai.com/v1/chat/completions", {
+    const resp = await fetch("https://api.openai.com/v1/responses", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.options.openAiApiKey}`,
       },
-      body: JSON.stringify({
-        model,
-        messages: [
-          {
-            role: "user",
-            content,
-          },
-        ],
-        max_completion_tokens: maxTokens,
-        response_format: outputSchema
-          ? {
-              type: "json_schema",
-              ...outputSchema,
-            }
-          : undefined,
-        stream: isStreaming,
-        ...this.options.extraRequestBodyParameters,
-      }),
+      body: JSON.stringify(body),
     });
 
     if (!resp.ok) {
       let errorMessage = `OpenAI request failed with status ${resp.status}`;
       try {
-        const errorData = await resp.json();
-        if (errorData?.error?.message) {
-          errorMessage = errorData.error.message;
-        }
+        const errorData = (await resp.json()) as OpenAIErrorResponse;
+        if (errorData.error?.message) errorMessage = errorData.error.message;
       } catch {}
       return { error: errorMessage };
     }
 
     if (!isStreaming) {
-      const data = await resp.json();
+      const json = await resp.json();
+      const data = json as OpenAIResponsesSuccess & OpenAIErrorResponse;
       if (data.error) {
         return { error: data.error.message };
       }
 
+      const parsedContent = extractOutputText(data);
+      const reasoning = extractReasoning(data);
+
       return {
-        content: data.choices?.[0]?.message?.content,
-        finishReason: data.choices?.[0]?.finish_reason,
+        content: parsedContent,
+        finishReason: data.incomplete_details?.reason
+          ? data.incomplete_details.reason
+          : undefined,
       };
     }
 
@@ -102,94 +175,138 @@ export default class CompletionAdapterOpenAIChatGPT
 
     let buffer = "";
     let fullContent = "";
+    let fullReasoning = "";
     let finishReason: string | undefined;
 
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) {
-          break;
-        }
+    const handleEvent = async (event: any, eventType?: string) => {
+      const type = event?.type || eventType;
 
-        buffer += decoder.decode(value, { stream: true });
+      if (type === "response.output_text.delta") {
+        const delta = event?.delta || "";
+        if (!delta) return;
+        fullContent += delta;
+        await onChunk?.(delta, { type: "output", delta, text: fullContent });
+        return;
+      }
 
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
+      if (
+        type === "response.reasoning_summary_text.delta" ||
+        type === "response.reasoning_text.delta"
+      ) {
+        const delta = event?.delta || "";
+        if (!delta) return;
+        fullReasoning += delta;
+        await onChunk?.(delta, {
+          type: "reasoning",
+          delta,
+          text: fullReasoning,
+        });
+        return;
+      }
 
-        for (const rawLine of lines) {
-          const line = rawLine.trim();
+      if (
+        type === "response.completed" ||
+        type === "response.incomplete"
+      ) {
+        const response = event?.response as OpenAIResponsesSuccess | undefined;
+        if (!response) return;
 
-          if (!line || !line.startsWith("data:")) {
-            continue;
+        const finalContent = extractOutputText(response);
+        if (finalContent.startsWith(fullContent)) {
+          const delta = finalContent.slice(fullContent.length);
+          if (delta) {
+            fullContent = finalContent;
+            await onChunk?.(delta, {
+              type: "output",
+              delta,
+              text: fullContent,
+            });
           }
+        }
 
-          const dataStr = line.slice(5).trim();
-
-          if (dataStr === "[DONE]") {
-            return {
-              content: fullContent,
-              finishReason,
-            };
+        const finalReasoning = extractReasoning(response) || "";
+        if (finalReasoning.startsWith(fullReasoning)) {
+          const delta = finalReasoning.slice(fullReasoning.length);
+          if (delta) {
+            fullReasoning = finalReasoning;
+            await onChunk?.(delta, {
+              type: "reasoning",
+              delta,
+              text: fullReasoning,
+            });
           }
+        }
 
-          let parsed: any;
-          try {
-            parsed = JSON.parse(dataStr);
-          } catch {
-            continue;
-          }
+        finishReason =
+          response.incomplete_details?.reason || response.status || finishReason;
+        return;
+      }
 
-          if (parsed.error?.message) {
-            return { error: parsed.error.message };
-          }
+      if (type === "response.failed") {
+        throw new Error(
+          event?.response?.error?.message ||
+            event?.error?.message ||
+            "Response failed",
+        );
+      }
+    };
 
-          const choice = parsed.choices?.[0];
-          if (!choice) {
-            continue;
-          }
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
 
-          if (choice.finish_reason) {
-            finishReason = choice.finish_reason;
-          }
+        buffer += decoder.decode(value, { stream: true });
+
+        const blocks = buffer.split("\n\n");
+        buffer = blocks.pop() || "";
+
+        for (const block of blocks) {
+          const parsedBlock = parseSseBlock(block);
+          if (!parsedBlock?.data || parsedBlock.data === "[DONE]") continue;
 
-          const chunk = choice.delta?.content ?? "";
-          if (!chunk) {
+          let event: any;
+          try {
+            event = JSON.parse(parsedBlock.data);
+          } catch {
             continue;
           }
 
-          fullContent += chunk;
-          await onChunk(chunk);
+          if (event?.error?.message) {
+            return { error: event.error.message };
+          }
+
+          await handleEvent(event, parsedBlock.event);
         }
       }
 
-      if (buffer.trim().startsWith("data:")) {
-        const dataStr = buffer.trim().slice(5).trim();
-        if (dataStr && dataStr !== "[DONE]") {
+      if (buffer.trim()) {
+        const parsedBlock = parseSseBlock(buffer.trim());
+        if (parsedBlock?.data && parsedBlock.data !== "[DONE]") {
           try {
-            const parsed = JSON.parse(dataStr);
-            const choice = parsed.choices?.[0];
-            const chunk = choice?.delta?.content ?? "";
-            if (chunk) {
-              fullContent += chunk;
-              await onChunk(chunk);
-            }
-            if (choice?.finish_reason) {
-              finishReason = choice.finish_reason;
-            }
-          } catch {}
+            await handleEvent(JSON.parse(parsedBlock.data), parsedBlock.event);
+          } catch (error: any) {
+            return {
+              error: error?.message || "Streaming failed",
+              content: fullContent || undefined,
+              finishReason,
+            };
+          }
         }
       }
 
       return {
-        content: fullContent,
+        content: fullContent || undefined,
         finishReason,
       };
     } catch (error: any) {
       return {
         error: error?.message || "Streaming failed",
+        content: fullContent || undefined,
+        finishReason,
       };
     } finally {
       reader.releaseLock();
     }
   };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/completion-adapter-open-ai-chat-gpt",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -16,6 +16,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "openai": "^6.34.0",
     "tiktoken": "^1.0.22"
   },
   "peerDependencies": {