@adminforth/completion-adapter-openai-responses 2.0.21

package/Changelog.md

@@ -0,0 +1,6 @@
+## [2.0.19] - 2026-04-23
+
+### Added
+
+- Added the OpenAI Responses completion adapter package.
+- Added compatibility guidance for migrating from `@adminforth/completion-adapter-open-ai-chat-gpt`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Devforth.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @adminforth/completion-adapter-openai-responses
+
+AdminForth completion adapter for the OpenAI Responses API.
+
+This package is the fully compatible successor to `@adminforth/completion-adapter-open-ai-chat-gpt`.
+
+## Installation
+
+```bash
+pnpm i @adminforth/completion-adapter-openai-responses
+```
+
+## Usage
+
+```ts
+import CompletionAdapterOpenAIResponses from "@adminforth/completion-adapter-openai-responses";
+
+const adapter = new CompletionAdapterOpenAIResponses({
+	openAiApiKey: process.env.OPENAI_API_KEY as string,
+	model: "gpt-5-nano",
+	extraRequestBodyParameters: {
+		temperature: 0.7,
+	},
+});
+```
+
+The adapter supports:
+
+- regular text completion
+- `json_schema` structured output
+- reasoning effort control
+- tool calls
+- streaming output chunks
+- streaming reasoning chunks

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+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>;
+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<{
+        content?: string;
+        finishReason?: string;
+        error?: string;
+    }>;
+}

package/dist/index.js

@@ -0,0 +1,339 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 extractFunctionCall(data) {
+    var _a;
+    for (const item of (_a = data.output) !== null && _a !== void 0 ? _a : []) {
+        if (item.type === "function_call") {
+            return item;
+        }
+    }
+    return undefined;
+}
+function executeToolCall(toolCall, tools) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tool = tools === null || tools === void 0 ? void 0 : tools.find((candidate) => candidate.name === toolCall.name);
+        if (!tool) {
+            throw new Error(`Tool "${toolCall.name}" not found`);
+        }
+        const toolResult = yield tool.handler(JSON.parse(toolCall.arguments));
+        if (typeof toolResult === "string")
+            return toolResult;
+        if (typeof toolResult === "undefined")
+            return "";
+        return JSON.stringify(toolResult);
+    });
+}
+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 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) {
+            var _a, _b, _c;
+            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;
+            if (tools && tools.length > 0) {
+                openAiTools = tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.input_schema,
+                    strict: true,
+                }));
+            }
+            const body = Object.assign({ model, input: content, max_output_tokens: maxTokens, stream: isStreaming, text: outputSchema
+                    ? {
+                        format: Object.assign({ type: "json_schema" }, outputSchema),
+                    }
+                    : {
+                        format: {
+                            type: "text",
+                        },
+                    }, reasoning: {
+                    effort: reasoningEffort,
+                    summary: "auto",
+                }, tools: openAiTools }, extra);
+            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(body),
+            });
+            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 toolCall = extractFunctionCall(data);
+                if (toolCall) {
+                    try {
+                        const toolResult = yield executeToolCall(toolCall, tools);
+                        return {
+                            content: toolResult,
+                            finishReason: "tool_call",
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                            finishReason: "tool_call",
+                        };
+                    }
+                }
+                const parsedContent = extractOutputText(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;
+            let completedResponse;
+            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 (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(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 (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(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 (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(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 (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                type: "reasoning",
+                                delta,
+                                text: fullReasoning,
+                            }));
+                        }
+                    }
+                    finishReason =
+                        ((_a = response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason) || response.status || finishReason;
+                    completedResponse = response;
+                    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,
+                            };
+                        }
+                    }
+                }
+                if (completedResponse) {
+                    const toolCall = extractFunctionCall(completedResponse);
+                    if (toolCall) {
+                        try {
+                            const toolResult = yield executeToolCall(toolCall, tools);
+                            if (toolResult) {
+                                const delta = toolResult.startsWith(fullContent)
+                                    ? toolResult.slice(fullContent.length)
+                                    : toolResult;
+                                if (delta) {
+                                    yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                        type: "output",
+                                        delta,
+                                        text: toolResult,
+                                    }));
+                                }
+                            }
+                            return {
+                                content: toolResult,
+                                finishReason: "tool_call",
+                            };
+                        }
+                        catch (error) {
+                            return {
+                                error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                                content: fullContent || undefined,
+                                finishReason: "tool_call",
+                            };
+                        }
+                    }
+                }
+                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();
+            }
+        });
+        this.options = options;
+        try {
+            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:`);
+            this.encoding = encoding_for_model("gpt-5-nano");
+        }
+    }
+    validate() {
+        if (!this.options.openAiApiKey) {
+            throw new Error("openAiApiKey is required");
+        }
+    }
+    measureTokensCount(content) {
+        return this.encoding.encode(content).length;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export interface AdapterOptions {
+    /**
+     * OpenAI API key. Go to https://platform.openai.com/, go to Dashboard -> API keys -> Create new secret key
+     * Paste value in your .env file OPENAI_API_KEY=your_key
+     * Set openAiApiKey: process.env.OPENAI_API_KEY to access it
+     */
+    openAiApiKey: string;
+    /**
+     * Model name. Go to https://platform.openai.com/docs/models, select model and copy name.
+     * Default is `gpt-5-nano`.
+     */
+    model?: string;
+    /**
+     * Additional request body parameters to include in the API request.
+     */
+    extraRequestBodyParameters?: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/index.ts

@@ -0,0 +1,418 @@
+import type { AdapterOptions } from "./types.js";
+import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
+import { encoding_for_model, type TiktokenModel } from "tiktoken";
+import type OpenAI from "openai";
+
+export type { AdapterOptions } from "./types.js";
+
+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;
+  };
+};
+type OpenAITool = OpenAI.Responses.Tool;
+type OpenAIFunctionCall = Extract<
+  OpenAI.Responses.ResponseOutputItem,
+  { type: "function_call" }
+>;
+
+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 extractFunctionCall(
+  data: OpenAIResponsesSuccess,
+): OpenAIFunctionCall | undefined {
+  for (const item of data.output ?? []) {
+    if (item.type === "function_call") {
+      return item;
+    }
+  }
+
+  return undefined;
+}
+
+async function executeToolCall(
+  toolCall: OpenAIFunctionCall,
+  tools?: CompletionTool[],
+): Promise<string> {
+  const tool = tools?.find((candidate) => candidate.name === toolCall.name);
+  if (!tool) {
+    throw new Error(`Tool "${toolCall.name}" not found`);
+  }
+
+  const toolResult = await tool.handler(JSON.parse(toolCall.arguments));
+  if (typeof toolResult === "string") return toolResult;
+  if (typeof toolResult === "undefined") return "";
+  return JSON.stringify(toolResult);
+}
+
+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 CompletionAdapterOpenAIResponses
+  implements CompletionAdapter
+{
+  options: AdapterOptions;
+  private encoding: ReturnType<typeof encoding_for_model>;
+
+  constructor(options: AdapterOptions) {
+    this.options = options;
+    try {
+      this.encoding = encoding_for_model(
+        (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:`,
+      );
+      this.encoding = encoding_for_model("gpt-5-nano" as TiktokenModel);
+    }
+  }
+
+  validate() {
+    if (!this.options.openAiApiKey) {
+      throw new Error("openAiApiKey is required");
+    }
+  }
+
+  measureTokensCount(content: string): number {
+    return this.encoding.encode(content).length;
+  }
+
+  complete = async (
+    content: string,
+    maxTokens = 50,
+    outputSchema?: any,
+    reasoningEffort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" = "low",
+    toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback,
+    onChunk?: StreamChunkCallback,
+  ): Promise<{
+    content?: string;
+    finishReason?: string;
+    error?: string;
+  }> => {
+    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;
+    if (tools && tools.length > 0) {
+      openAiTools = tools.map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        strict: true,
+      }));
+    }
+
+    const body = {
+      model,
+      input: content,
+      max_output_tokens: maxTokens,
+      stream: isStreaming,
+      text: outputSchema
+        ? {
+            format: {
+              type: "json_schema",
+              ...outputSchema,
+            },
+          }
+        : {
+            format: {
+              type: "text",
+            },
+          },
+      reasoning: {
+        effort: reasoningEffort,
+        summary: "auto",
+      },
+      tools: openAiTools,
+      ...extra,
+    } 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(body),
+    });
+
+    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 toolCall = extractFunctionCall(data);
+      if (toolCall) {
+        try {
+          const toolResult = await executeToolCall(toolCall, tools);
+          return {
+            content: toolResult,
+            finishReason: "tool_call",
+          };
+        } catch (error: any) {
+          return {
+            error: error?.message || "Tool execution failed",
+            finishReason: "tool_call",
+          };
+        }
+      }
+
+      const parsedContent = extractOutputText(data);
+
+      return {
+        content: parsedContent,
+        finishReason: data.incomplete_details?.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: string | undefined;
+    let completedResponse: OpenAIResponsesSuccess | 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 streamChunkCallback?.(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 streamChunkCallback?.(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 streamChunkCallback?.(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 streamChunkCallback?.(delta, {
+              type: "reasoning",
+              delta,
+              text: fullReasoning,
+            });
+          }
+        }
+
+        finishReason =
+          response.incomplete_details?.reason || response.status || finishReason;
+        completedResponse = response;
+        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,
+            };
+          }
+        }
+      }
+
+      if (completedResponse) {
+        const toolCall = extractFunctionCall(completedResponse);
+        if (toolCall) {
+          try {
+            const toolResult = await executeToolCall(toolCall, tools);
+            if (toolResult) {
+              const delta = toolResult.startsWith(fullContent)
+                ? toolResult.slice(fullContent.length)
+                : toolResult;
+              if (delta) {
+                await streamChunkCallback?.(delta, {
+                  type: "output",
+                  delta,
+                  text: toolResult,
+                });
+              }
+            }
+
+            return {
+              content: toolResult,
+              finishReason: "tool_call",
+            };
+          } catch (error: any) {
+            return {
+              error: error?.message || "Tool execution failed",
+              content: fullContent || undefined,
+              finishReason: "tool_call",
+            };
+          }
+        }
+      }
+
+      return {
+        content: fullContent || undefined,
+        finishReason,
+      };
+    } catch (error: any) {
+      return {
+        error: error?.message || "Streaming failed",
+        content: fullContent || undefined,
+        finishReason,
+      };
+    } finally {
+      reader.releaseLock();
+    }
+  };
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@adminforth/completion-adapter-openai-responses",
+  "version": "2.0.21",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc && npm version patch",
+    "rollout": "npm run build && npm publish --access public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "AdminForth completion adapter for the OpenAI Responses API.",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "openai": "^6.34.0",
+    "tiktoken": "^1.0.22"
+  },
+  "peerDependencies": {
+    "adminforth": "^2.24.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "node16",
+    "outDir": "./dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "strictNullChecks": true
+  },
+  "exclude": ["node_modules", "dist", "custom"]
+}

package/types.ts

@@ -0,0 +1,19 @@
+export interface AdapterOptions {
+  /**
+   * OpenAI API key. Go to https://platform.openai.com/, go to Dashboard -> API keys -> Create new secret key
+   * Paste value in your .env file OPENAI_API_KEY=your_key
+   * Set openAiApiKey: process.env.OPENAI_API_KEY to access it
+   */
+  openAiApiKey: string;
+
+  /**
+   * Model name. Go to https://platform.openai.com/docs/models, select model and copy name.
+   * Default is `gpt-5-nano`.
+   */
+  model?: string;
+
+  /**
+   * Additional request body parameters to include in the API request.
+   */
+  extraRequestBodyParameters?: Record<string, unknown>;
+}