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

package/dist/index.js

@@ -8,33 +8,240 @@ 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) {
-        this.complete = (content_1, ...args_1) => __awaiter(this, [content_1, ...args_1], void 0, function* (content, stop = ["."], maxTokens = 50, outputSchema) {
-            // 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")
+        //@ts-ignore
+        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 resp = yield fetch("https://api.openai.com/v1/chat/completions", {
+            const isStreaming = typeof onChunk === "function";
+            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, //param
-                        },
-                    ], max_completion_tokens: maxTokens, response_format: outputSchema ? Object.assign({ type: "json_schema" }, outputSchema) : undefined }, this.options.extraRequestBodyParameters)),
+                body: JSON.stringify(body),
             });
-            const data = yield resp.json();
-            if (data.error) {
-                return { error: data.error.message };
+            if (!resp.ok) {
+                let errorMessage = `OpenAI request failed with status ${resp.status}`;
+                try {
+                    const errorData = (yield resp.json());
+                    if ((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message)
+                        errorMessage = errorData.error.message;
+                }
+                catch (_d) { }
+                return { error: errorMessage };
+            }
+            if (!isStreaming) {
+                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: parsedContent,
+                    finishReason: ((_b = data.incomplete_details) === null || _b === void 0 ? void 0 : _b.reason)
+                        ? data.incomplete_details.reason
+                        : undefined,
+                };
+            }
+            if (!resp.body) {
+                return { error: "Response body is empty" };
+            }
+            const reader = resp.body.getReader();
+            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)
+                        break;
+                    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 === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) || parsedBlock.data === "[DONE]")
+                            continue;
+                        let event;
+                        try {
+                            event = JSON.parse(parsedBlock.data);
+                        }
+                        catch (_e) {
+                            continue;
+                        }
+                        if ((_c = event === null || event === void 0 ? void 0 : event.error) === null || _c === void 0 ? void 0 : _c.message) {
+                            return { error: event.error.message };
+                        }
+                        yield handleEvent(event, parsedBlock.event);
+                    }
+                }
+                if (buffer.trim()) {
+                    const parsedBlock = parseSseBlock(buffer.trim());
+                    if ((parsedBlock === null || parsedBlock === void 0 ? void 0 : parsedBlock.data) && parsedBlock.data !== "[DONE]") {
+                        try {
+                            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,
+                            };
+                        }
+                    }
+                }
+                return {
+                    content: fullContent || undefined,
+                    finishReason,
+                };
+            }
+            catch (error) {
+                return {
+                    error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                    content: fullContent || undefined,
+                    finishReason,
+                };
+            }
+            finally {
+                reader.releaseLock();
             }
-            return {
-                content: data.choices[0].message.content,
-                finishReason: data.choices[0].finish_reason,
-            };
         });
         this.options = options;
         this.encoding = encoding_for_model((this.options.model || "gpt-5-nano"));
@@ -45,8 +252,6 @@ export default class CompletionAdapterOpenAIChatGPT {
         }
     }
     measureTokensCount(content) {
-        // Implement token counting logic here
-        const tokens = this.encoding.encode(content);
-        return tokens.length;
+        return this.encoding.encode(content).length;
     }
 }

package/index.ts

@@ -1,6 +1,77 @@
 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,
+  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
 {
@@ -10,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,
     );
   }
 
@@ -21,48 +92,221 @@ export default class CompletionAdapterOpenAIChatGPT
   }
 
   measureTokensCount(content: string): number {
-    // Implement token counting logic here
-    const tokens = this.encoding.encode(content);
-    return tokens.length;
+    return this.encoding.encode(content).length;
   }
-
-  complete = async (content: string, stop = ["."], maxTokens = 50, outputSchema?: any): Promise<{
+  //@ts-ignore
+  complete = async (
+    content: string,
+    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 resp = await fetch("https://api.openai.com/v1/chat/completions", {
+    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/responses", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.options.openAiApiKey}`,
       },
-      body: JSON.stringify({
-        model,
-        messages: [
-          {
-            role: "user",
-            content, //param
-          },
-        ],
-        max_completion_tokens: maxTokens,
-        response_format: outputSchema ? {      
-          type: "json_schema",
-          ...outputSchema,
-        } : undefined,
-        ...this.options.extraRequestBodyParameters,
-      }),
+      body: JSON.stringify(body),
     });
-    const data = await resp.json();
-    if (data.error) {
-      return { error: data.error.message };
+
+    if (!resp.ok) {
+      let errorMessage = `OpenAI request failed with status ${resp.status}`;
+      try {
+        const errorData = (await resp.json()) as OpenAIErrorResponse;
+        if (errorData.error?.message) errorMessage = errorData.error.message;
+      } catch {}
+      return { error: errorMessage };
+    }
+
+    if (!isStreaming) {
+      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: parsedContent,
+        finishReason: data.incomplete_details?.reason
+          ? data.incomplete_details.reason
+          : undefined,
+      };
+    }
+
+    if (!resp.body) {
+      return { error: "Response body is empty" };
     }
-    return {
-      content: data.choices[0].message.content,
-      finishReason: data.choices[0].finish_reason,
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+
+    let buffer = "";
+    let fullContent = "";
+    let fullReasoning = "";
+    let finishReason: string | undefined;
+
+    const handleEvent = async (event: any, eventType?: string) => {
+      const type = event?.type || eventType;
+
+      if (type === "response.output_text.delta") {
+        const delta = event?.delta || "";
+        if (!delta) return;
+        fullContent += delta;
+        await onChunk?.(delta, { type: "output", delta, text: fullContent });
+        return;
+      }
+
+      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;
+      }
+
+      if (
+        type === "response.completed" ||
+        type === "response.incomplete"
+      ) {
+        const response = event?.response as OpenAIResponsesSuccess | undefined;
+        if (!response) return;
+
+        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 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,
+            });
+          }
+        }
+
+        finishReason =
+          response.incomplete_details?.reason || response.status || finishReason;
+        return;
+      }
+
+      if (type === "response.failed") {
+        throw new Error(
+          event?.response?.error?.message ||
+            event?.error?.message ||
+            "Response failed",
+        );
+      }
     };
+
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+
+        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;
+
+          let event: any;
+          try {
+            event = JSON.parse(parsedBlock.data);
+          } catch {
+            continue;
+          }
+
+          if (event?.error?.message) {
+            return { error: event.error.message };
+          }
+
+          await handleEvent(event, parsedBlock.event);
+        }
+      }
+
+      if (buffer.trim()) {
+        const parsedBlock = parseSseBlock(buffer.trim());
+        if (parsedBlock?.data && parsedBlock.data !== "[DONE]") {
+          try {
+            await handleEvent(JSON.parse(parsedBlock.data), parsedBlock.event);
+          } catch (error: any) {
+            return {
+              error: error?.message || "Streaming failed",
+              content: fullContent || undefined,
+              finishReason,
+            };
+          }
+        }
+      }
+
+      return {
+        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.10",
+  "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": {