@adminforth/completion-adapter-openai-responses 2.0.26 → 2.0.27

package/.woodpecker/buildRelease.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+pnpm run build 2>&1 | tee build.log
+build_status=${PIPESTATUS[0]}
+
+if [ $build_status -ne 0 ]; then
+  echo "Build failed. Exiting with status code $build_status"
+  exit $build_status
+fi

package/.woodpecker/buildSlackNotify.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+set -x
+
+COMMIT_SHORT_SHA=$(echo $CI_COMMIT_SHA | cut -c1-8)
+
+STATUS=${1}
+
+if [ "$STATUS" = "success" ]; then
+  MESSAGE="Did a build without issues on \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\`. Commit: _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+
+  curl  -s -X POST -H "Content-Type: application/json" -d '{
+    "username": "'"$CI_COMMIT_AUTHOR"'",
+    "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+    "attachments": [
+      {
+          "mrkdwn_in": ["text", "pretext"],
+          "color": "#36a64f",
+          "text": "'"$MESSAGE"'"
+      }
+    ]
+  }' "$DEVELOPERS_SLACK_WEBHOOK"
+  exit 0
+fi
+export BUILD_LOG=$(cat ./build.log)
+
+BUILD_LOG=$(echo $BUILD_LOG | sed 's/"/\\"/g')
+
+MESSAGE="Broke \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\` with commit _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+CODE_BLOCK="\`\`\`$BUILD_LOG\n\`\`\`"
+
+echo "Sending slack message to developers $MESSAGE"
+curl -sS -X POST -H "Content-Type: application/json" -d '{
+  "username": "'"$CI_COMMIT_AUTHOR"'",
+  "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+  "attachments": [
+    {
+        "mrkdwn_in": ["text", "pretext"],
+        "color": "#8A1C12",
+        "text": "'"$CODE_BLOCK"'",
+        "pretext": "'"$MESSAGE"'"
+    }
+  ]
+}' "$DEVELOPERS_SLACK_WEBHOOK" 2>&1

package/.woodpecker/release.yml

@@ -0,0 +1,56 @@
+clone:
+  git:
+    image: woodpeckerci/plugin-git
+    settings:
+      partial: false
+      depth: 5
+
+steps:
+  init-secrets:
+    when:
+      - event: push
+    image: infisical/cli
+    environment:
+      INFISICAL_TOKEN:
+        from_secret: VAULT_TOKEN
+    commands:
+      - infisical export --domain https://vault.devforth.io/api --format=dotenv-export --env="prod" > /woodpecker/deploy.vault.env
+
+  build:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event: push
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - pnpm install
+      - /bin/bash ./.woodpecker/buildRelease.sh
+      - npm audit signatures
+
+  release:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event:
+          - push
+        branch:
+          - main
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - pnpm exec semantic-release
+
+  slack-on-failure:
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [failure]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh failure
+
+  slack-on-success:
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [success]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh success

package/dist/index.d.ts

@@ -12,13 +12,28 @@ type CompletionRequestInput = {
     reasoningEffort?: ReasoningEffort;
     tools?: CompletionTool[];
     onChunk?: StreamChunkCallback;
+    signal?: AbortSignal;
+};
+type UsedTokens = {
+    input_uncached: number;
+    input_cached: number;
+    output: number;
+};
+type CompletionResult = {
+    content?: string;
+    finishReason?: string;
+    error?: string;
+    used_tokens?: UsedTokens;
 };
 export default class CompletionAdapterOpenAIResponses implements CompletionAdapter {
     options: AdapterOptions;
     private encoding;
+    private activeAbortController;
     constructor(options: AdapterOptions);
     validate(): void;
     measureTokensCount(content: string): number;
+    abort(): void;
+    isGenerationInProgress(): boolean;
     private getConfiguredBaseUrl;
     private shouldUseComplitionApi;
     private shouldDumpRawRequest;
@@ -35,9 +50,5 @@ export default class CompletionAdapterOpenAIResponses implements CompletionAdapt
         model: ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions>;
         middleware: import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>[];
     };
-    complete: (requestOrContent: CompletionRequestInput | string, maxTokens?: number, outputSchema?: any, reasoningEffort?: ReasoningEffort, toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback, onChunk?: StreamChunkCallback) => Promise<{
-        content?: string;
-        finishReason?: string;
-        error?: string;
-    }>;
+    complete: (requestOrContent: CompletionRequestInput | string, maxTokens?: number, outputSchema?: any, reasoningEffort?: ReasoningEffort, toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback, onChunk?: StreamChunkCallback) => Promise<CompletionResult>;
 }

package/dist/index.js

@@ -68,6 +68,19 @@ function extractFunctionCall(data) {
     }
     return undefined;
 }
+function extractUsedTokens(data) {
+    var _a, _b;
+    const usage = data.usage;
+    if (!usage) {
+        return undefined;
+    }
+    const inputCached = (_b = (_a = usage.input_tokens_details) === null || _a === void 0 ? void 0 : _a.cached_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        input_uncached: Math.max(usage.input_tokens - inputCached, 0),
+        input_cached: inputCached,
+        output: usage.output_tokens,
+    };
+}
 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);
@@ -101,7 +114,7 @@ function getAgentReasoningEffort(purpose) {
 }
 function buildReasoningConfig(params) {
     var _a;
-    return Object.assign({ summary: "detailed", effort: params.effort }, ((_a = params.reasoning) !== null && _a !== void 0 ? _a : {}));
+    return Object.assign({ summary: "auto", effort: params.effort }, ((_a = params.reasoning) !== null && _a !== void 0 ? _a : {}));
 }
 function getTurnKey(context) {
     return `${context.sessionId}:${context.turnId}`;
@@ -160,6 +173,7 @@ function createOpenAiResponsesContinuationMiddleware() {
 }
 export default class CompletionAdapterOpenAIResponses {
     constructor(options) {
+        this.activeAbortController = null;
         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"
@@ -174,7 +188,7 @@ export default class CompletionAdapterOpenAIResponses {
                         : onChunk,
                 }
                 : requestOrContent;
-            const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, onChunk: streamChunkCallback, } = request;
+            const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, onChunk: streamChunkCallback, signal: requestSignal, } = request;
             const model = this.options.model || "gpt-5-nano";
             const isStreaming = typeof streamChunkCallback === "function";
             const extra = this.options.extraRequestBodyParameters;
@@ -205,212 +219,275 @@ export default class CompletionAdapterOpenAIResponses {
             if (this.shouldDumpRawRequest()) {
                 this.dumpRawRequest(this.getResponsesUrl(), serializedBody);
             }
-            const resp = yield fetch(this.getResponsesUrl(), {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.options.openAiApiKey}`,
-                },
-                body: serializedBody,
-            });
-            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 (_e) { }
-                return { error: errorMessage };
+            const abortController = new AbortController();
+            this.activeAbortController = abortController;
+            const abortFromRequestSignal = () => abortController.abort(requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.reason);
+            if (requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.aborted) {
+                abortController.abort(requestSignal.reason);
+            }
+            else {
+                requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.addEventListener("abort", abortFromRequestSignal, { once: true });
             }
-            if (!isStreaming) {
-                const json = yield resp.json();
-                const data = json;
-                if (data.error) {
-                    return { error: data.error.message };
+            let resp = null;
+            try {
+                resp = yield fetch(this.getResponsesUrl(), {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.options.openAiApiKey}`,
+                    },
+                    body: serializedBody,
+                    signal: abortController.signal,
+                });
+            }
+            catch (error) {
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
                 }
-                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",
-                        };
-                    }
+                if (abortController.signal.aborted) {
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Generation aborted",
+                        finishReason: "aborted",
+                    };
                 }
-                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,
+                    error: (error === null || error === void 0 ? void 0 : error.message) || "OpenAI request failed",
                 };
             }
-            if (!resp.body) {
-                return { error: "Response body is empty" };
+            finally {
+                requestSignal === null || requestSignal === void 0 ? void 0 : requestSignal.removeEventListener("abort", abortFromRequestSignal);
             }
-            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");
+            if (!resp) {
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
                 }
-            });
+                return {
+                    error: "OpenAI request 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 (_f) {
-                            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 (!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 (_e) { }
+                    return { error: errorMessage };
                 }
-                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 (!isStreaming) {
+                    const json = yield resp.json();
+                    const data = json;
+                    if (data.error) {
+                        return { error: data.error.message };
                     }
-                }
-                if (completedResponse) {
-                    const toolCall = extractFunctionCall(completedResponse);
+                    const usedTokens = extractUsedTokens(data);
+                    const toolCall = extractFunctionCall(data);
                     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",
+                                used_tokens: usedTokens,
                             };
                         }
                         catch (error) {
                             return {
                                 error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
-                                content: fullContent || undefined,
                                 finishReason: "tool_call",
+                                used_tokens: usedTokens,
                             };
                         }
                     }
+                    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,
+                        used_tokens: usedTokens,
+                    };
+                }
+                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;
+                let usedTokens;
+                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;
+                        usedTokens = extractUsedTokens(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 (_f) {
+                                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",
+                                    used_tokens: usedTokens,
+                                };
+                            }
+                            catch (error) {
+                                return {
+                                    error: (error === null || error === void 0 ? void 0 : error.message) || "Tool execution failed",
+                                    content: fullContent || undefined,
+                                    finishReason: "tool_call",
+                                    used_tokens: usedTokens,
+                                };
+                            }
+                        }
+                    }
+                    return {
+                        content: fullContent || undefined,
+                        finishReason,
+                        used_tokens: usedTokens,
+                    };
+                }
+                catch (error) {
+                    if (abortController.signal.aborted) {
+                        return {
+                            error: (error === null || error === void 0 ? void 0 : error.message) || "Generation aborted",
+                            content: fullContent || undefined,
+                            finishReason: "aborted",
+                            used_tokens: usedTokens,
+                        };
+                    }
+                    return {
+                        error: (error === null || error === void 0 ? void 0 : error.message) || "Streaming failed",
+                        content: fullContent || undefined,
+                        finishReason,
+                        used_tokens: usedTokens,
+                    };
+                }
+                finally {
+                    reader.releaseLock();
                 }
-                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();
+                if (this.activeAbortController === abortController) {
+                    this.activeAbortController = null;
+                }
             }
         });
         this.options = options;
@@ -432,6 +509,13 @@ export default class CompletionAdapterOpenAIResponses {
     measureTokensCount(content) {
         return this.encoding.encode(content).length;
     }
+    abort() {
+        var _a;
+        (_a = this.activeAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+    }
+    isGenerationInProgress() {
+        return Boolean(this.activeAbortController);
+    }
     getConfiguredBaseUrl() {
         return this.options.baseUrl;
     }

package/index.ts

@@ -34,6 +34,7 @@ type CompletionRequestInput = {
   reasoningEffort?: ReasoningEffort;
   tools?: CompletionTool[];
   onChunk?: StreamChunkCallback;
+  signal?: AbortSignal;
 };
 
 type ResponseCreateBody = OpenAI.Responses.ResponseCreateParams;
@@ -59,6 +60,20 @@ type OpenAiResponsesMetadata = {
 type OpenAiResponsesContext = {
   sessionId: string;
   turnId: string;
+  abortSignal?: AbortSignal;
+};
+
+type UsedTokens = {
+  input_uncached: number;
+  input_cached: number;
+  output: number;
+};
+
+type CompletionResult = {
+  content?: string;
+  finishReason?: string;
+  error?: string;
+  used_tokens?: UsedTokens;
 };
 
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
@@ -118,6 +133,21 @@ function extractFunctionCall(
   return undefined;
 }
 
+function extractUsedTokens(data: OpenAIResponsesSuccess): UsedTokens | undefined {
+  const usage = data.usage;
+  if (!usage) {
+    return undefined;
+  }
+
+  const inputCached = usage.input_tokens_details?.cached_tokens ?? 0;
+
+  return {
+    input_uncached: Math.max(usage.input_tokens - inputCached, 0),
+    input_cached: inputCached,
+    output: usage.output_tokens,
+  };
+}
+
 async function executeToolCall(
   toolCall: OpenAIFunctionCall,
   tools?: CompletionTool[],
@@ -158,7 +188,7 @@ function buildReasoningConfig(params: {
   effort: Exclude<ReasoningEffort, "none"> | ReasoningEffort;
 }) {
   return {
-    summary: "detailed",
+    summary: "auto",
     effort: params.effort,
     ...(params.reasoning ?? {}),
   };
@@ -250,6 +280,7 @@ export default class CompletionAdapterOpenAIResponses
 {
   options: AdapterOptions;
   private encoding: ReturnType<typeof encoding_for_model>;
+  private activeAbortController: AbortController | null = null;
 
   constructor(options: AdapterOptions) {
     this.options = options;
@@ -275,6 +306,14 @@ export default class CompletionAdapterOpenAIResponses
     return this.encoding.encode(content).length;
   }
 
+  abort() {
+    this.activeAbortController?.abort();
+  }
+
+  isGenerationInProgress() {
+    return Boolean(this.activeAbortController);
+  }
+
   private getConfiguredBaseUrl() {
     return this.options.baseUrl;
   }
@@ -409,11 +448,7 @@ export default class CompletionAdapterOpenAIResponses
     reasoningEffort: ReasoningEffort = "low",
     toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback,
     onChunk?: StreamChunkCallback,
-  ): Promise<{
-    content?: string;
-    finishReason?: string;
-    error?: string;
-  }> => {
+  ): Promise<CompletionResult> => {
     const request =
       typeof requestOrContent === "string"
         ? {
@@ -435,6 +470,7 @@ export default class CompletionAdapterOpenAIResponses
       reasoningEffort: requestReasoningEffort = "low",
       tools,
       onChunk: streamChunkCallback,
+      signal: requestSignal,
     } = request;
     const model = this.options.model || "gpt-5-nano";
     const isStreaming = typeof streamChunkCallback === "function";
@@ -487,69 +523,117 @@ export default class CompletionAdapterOpenAIResponses
       this.dumpRawRequest(this.getResponsesUrl(), serializedBody);
     }
 
-    const resp = await fetch(this.getResponsesUrl(), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.options.openAiApiKey}`,
-      },
-      body: serializedBody,
-    });
-
-    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 };
+    const abortController = new AbortController();
+    this.activeAbortController = abortController;
+    const abortFromRequestSignal = () => abortController.abort(requestSignal?.reason);
+
+    if (requestSignal?.aborted) {
+      abortController.abort(requestSignal.reason);
+    } else {
+      requestSignal?.addEventListener("abort", abortFromRequestSignal, { once: true });
     }
 
-    if (!isStreaming) {
-      const json = await resp.json();
-      const data = json as OpenAIResponsesSuccess & OpenAIErrorResponse;
-      if (data.error) {
-        return { error: data.error.message };
+    let resp: Response | null = null;
+    try {
+      resp = await fetch(this.getResponsesUrl(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.options.openAiApiKey}`,
+        },
+        body: serializedBody,
+        signal: abortController.signal,
+      });
+    } catch (error: any) {
+      if (this.activeAbortController === abortController) {
+        this.activeAbortController = null;
       }
 
-      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",
-          };
-        }
+      if (abortController.signal.aborted) {
+        return {
+          error: error?.message || "Generation aborted",
+          finishReason: "aborted",
+        };
       }
 
-      const parsedContent = extractOutputText(data);
-
       return {
-        content: parsedContent,
-        finishReason: data.incomplete_details?.reason
-          ? data.incomplete_details.reason
-          : undefined,
+        error: error?.message || "OpenAI request failed",
       };
+    } finally {
+      requestSignal?.removeEventListener("abort", abortFromRequestSignal);
     }
 
-    if (!resp.body) {
-      return { error: "Response body is empty" };
+    if (!resp) {
+      if (this.activeAbortController === abortController) {
+        this.activeAbortController = null;
+      }
+
+      return {
+        error: "OpenAI request failed",
+      };
     }
 
-    const reader = resp.body.getReader();
-    const decoder = new TextDecoder("utf-8");
+    try {
+      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 };
+      }
 
-    let buffer = "";
-    let fullContent = "";
-    let fullReasoning = "";
-    let finishReason: string | undefined;
-    let completedResponse: OpenAIResponsesSuccess | undefined;
+      if (!isStreaming) {
+        const json = await resp.json();
+        const data = json as OpenAIResponsesSuccess & OpenAIErrorResponse;
+        if (data.error) {
+          return { error: data.error.message };
+        }
+
+        const usedTokens = extractUsedTokens(data);
+
+        const toolCall = extractFunctionCall(data);
+        if (toolCall) {
+          try {
+            const toolResult = await executeToolCall(toolCall, tools);
+            return {
+              content: toolResult,
+              finishReason: "tool_call",
+              used_tokens: usedTokens,
+            };
+          } catch (error: any) {
+            return {
+              error: error?.message || "Tool execution failed",
+              finishReason: "tool_call",
+              used_tokens: usedTokens,
+            };
+          }
+        }
+
+        const parsedContent = extractOutputText(data);
+
+        return {
+          content: parsedContent,
+          finishReason: data.incomplete_details?.reason
+            ? data.incomplete_details.reason
+            : undefined,
+          used_tokens: usedTokens,
+        };
+      }
+
+      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;
+      let usedTokens: UsedTokens | undefined;
 
     const handleEvent = async (event: any, eventType?: string) => {
       const type = event?.type || eventType;
@@ -610,6 +694,7 @@ export default class CompletionAdapterOpenAIResponses
         finishReason =
           response.incomplete_details?.reason || response.status || finishReason;
         completedResponse = response;
+        usedTokens = extractUsedTokens(response);
         return;
       }
 
@@ -687,12 +772,14 @@ export default class CompletionAdapterOpenAIResponses
             return {
               content: toolResult,
               finishReason: "tool_call",
+              used_tokens: usedTokens,
             };
           } catch (error: any) {
             return {
               error: error?.message || "Tool execution failed",
               content: fullContent || undefined,
               finishReason: "tool_call",
+              used_tokens: usedTokens,
             };
           }
         }
@@ -701,15 +788,31 @@ export default class CompletionAdapterOpenAIResponses
       return {
         content: fullContent || undefined,
         finishReason,
+        used_tokens: usedTokens,
       };
     } catch (error: any) {
+      if (abortController.signal.aborted) {
+        return {
+          error: error?.message || "Generation aborted",
+          content: fullContent || undefined,
+          finishReason: "aborted",
+          used_tokens: usedTokens,
+        };
+      }
+
       return {
         error: error?.message || "Streaming failed",
         content: fullContent || undefined,
         finishReason,
+        used_tokens: usedTokens,
       };
     } finally {
       reader.releaseLock();
     }
+    } finally {
+      if (this.activeAbortController === abortController) {
+        this.activeAbortController = null;
+      }
+    }
   };
 }

package/package.json

@@ -1,18 +1,27 @@
 {
   "name": "@adminforth/completion-adapter-openai-responses",
-  "version": "2.0.26",
+  "version": "2.0.27",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
+  "homepage": "https://adminforth.dev/docs/tutorial/Adapters/completion-adapter-openai-responses/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devforth/adminforth-completion-adapter-openai-responses.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsc && npm version patch",
-    "rollout": "npm run build && npm publish --access public"
+    "build": "tsc"
   },
   "keywords": [],
   "author": "DevForth (https://devforth.io)",
   "license": "MIT",
   "description": "AdminForth completion adapter for the OpenAI Responses API.",
   "devDependencies": {
+    "semantic-release": "^24.2.1",
+    "semantic-release-slack-bot": "^4.0.2",
     "typescript": "^5.9.3"
   },
   "dependencies": {
@@ -24,5 +33,30 @@
   },
   "peerDependencies": {
     "adminforth": "^2.24.0"
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "semantic-release-slack-bot",
+        {
+          "packageName": "@adminforth/completion-adapter-openai-responses",
+          "notifyOnSuccess": true,
+          "notifyOnFail": true,
+          "slackIcon": ":package:",
+          "markdownReleaseNotes": true
+        }
+      ]
+    ],
+    "branches": [
+      "main",
+      {
+        "name": "next",
+        "prerelease": true
+      }
+    ]
   }
 }