@proteinjs/conversation 2.5.0 → 2.7.0

package/dist/src/OpenAiResponses.js

@@ -0,0 +1,1621 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiResponsesError = exports.OpenAiResponses = exports.DEFAULT_MAX_BACKGROUND_WAIT_MS = exports.DEFAULT_MAX_TOOL_CALLS = exports.DEFAULT_RESPONSES_MODEL = void 0;
+var openai_1 = require("openai");
+var logger_1 = require("@proteinjs/logger");
+var UsageData_1 = require("./UsageData");
+var ChatCompletionMessageParamFactory_1 = require("./ChatCompletionMessageParamFactory");
+exports.DEFAULT_RESPONSES_MODEL = 'gpt-5.2';
+exports.DEFAULT_MAX_TOOL_CALLS = 50;
+/** Default hard cap for background-mode polling duration (ms): 1 hour. */
+exports.DEFAULT_MAX_BACKGROUND_WAIT_MS = 60 * 60 * 1000;
+/** Best-effort timeout for cancel calls (avoid hanging abort/timeout paths). */
+var DEFAULT_CANCEL_TIMEOUT_MS = 10000;
+/**
+ * OpenAI Responses API wrapper (tool-loop + usage tracking + ConversationModules).
+ * - Uses Responses API directly
+ * - Supports custom function tools (tool calling loop)
+ * - Supports structured outputs (JSON schema / Zod)
+ * - Tracks usage + tool calls using existing types
+ * - Supports background mode (polling)
+ * - Supports ConversationModules (system messages + tool registration)
+ */
+var OpenAiResponses = /** @class */ (function () {
+    function OpenAiResponses(opts) {
+        if (opts === void 0) { opts = {}; }
+        var _a, _b;
+        this.modulesProcessed = false;
+        this.processingModulesPromise = null;
+        this.systemMessages = [];
+        this.functions = [];
+        this.client = new openai_1.OpenAI();
+        this.logger = new logger_1.Logger({ name: 'OpenAiResponses', logLevel: opts.logLevel });
+        this.modules = (_a = opts.modules) !== null && _a !== void 0 ? _a : [];
+        this.allowedFunctionNames = opts.allowedFunctionNames;
+        this.defaultModel = (_b = opts.defaultModel) !== null && _b !== void 0 ? _b : exports.DEFAULT_RESPONSES_MODEL;
+        this.defaultMaxToolCalls = typeof opts.maxToolCalls === 'number' ? opts.maxToolCalls : exports.DEFAULT_MAX_TOOL_CALLS;
+        this.defaultMaxBackgroundWaitMs =
+            typeof opts.maxBackgroundWaitMs === 'number' &&
+                Number.isFinite(opts.maxBackgroundWaitMs) &&
+                opts.maxBackgroundWaitMs > 0
+                ? Math.floor(opts.maxBackgroundWaitMs)
+                : exports.DEFAULT_MAX_BACKGROUND_WAIT_MS;
+    }
+    /** Plain text generation (supports tool calling). */
+    OpenAiResponses.prototype.generateText = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model, backgroundMode, maxToolCalls, maxBackgroundWaitMs, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+                    case 1:
+                        _a.sent();
+                        model = this.resolveModel(args.model);
+                        backgroundMode = this.resolveBackgroundMode({
+                            requested: args.backgroundMode,
+                            model: model,
+                            reasoningEffort: args.reasoningEffort,
+                        });
+                        maxToolCalls = typeof args.maxToolCalls === 'number' ? args.maxToolCalls : this.defaultMaxToolCalls;
+                        maxBackgroundWaitMs = this.resolveMaxBackgroundWaitMs(args.maxBackgroundWaitMs);
+                        return [4 /*yield*/, this.run({
+                                model: model,
+                                messages: args.messages,
+                                temperature: args.temperature,
+                                topP: args.topP,
+                                maxTokens: args.maxTokens,
+                                abortSignal: args.abortSignal,
+                                onToolInvocation: args.onToolInvocation,
+                                reasoningEffort: args.reasoningEffort,
+                                maxToolCalls: maxToolCalls,
+                                backgroundMode: backgroundMode,
+                                maxBackgroundWaitMs: maxBackgroundWaitMs,
+                                textFormat: undefined,
+                                serviceTier: args.serviceTier,
+                            })];
+                    case 2:
+                        result = _a.sent();
+                        if (!args.onUsageData) return [3 /*break*/, 4];
+                        return [4 /*yield*/, args.onUsageData(result.usagedata)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /** Back-compat alias for callers that use `generateResponse`. */
+    OpenAiResponses.prototype.generateResponse = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.generateText(args)];
+            });
+        });
+    };
+    /** Structured object generation (supports tool calling). */
+    OpenAiResponses.prototype.generateObject = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model, backgroundMode, maxToolCalls, maxBackgroundWaitMs, textFormat, result, object, outcome;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+                    case 1:
+                        _a.sent();
+                        model = this.resolveModel(args.model);
+                        backgroundMode = this.resolveBackgroundMode({
+                            requested: args.backgroundMode,
+                            model: model,
+                            reasoningEffort: args.reasoningEffort,
+                        });
+                        maxToolCalls = typeof args.maxToolCalls === 'number' ? args.maxToolCalls : this.defaultMaxToolCalls;
+                        maxBackgroundWaitMs = this.resolveMaxBackgroundWaitMs(args.maxBackgroundWaitMs);
+                        textFormat = this.buildTextFormat(args.schema);
+                        return [4 /*yield*/, this.run({
+                                model: model,
+                                messages: args.messages,
+                                temperature: args.temperature,
+                                topP: args.topP,
+                                maxTokens: args.maxTokens,
+                                abortSignal: args.abortSignal,
+                                onToolInvocation: args.onToolInvocation,
+                                reasoningEffort: args.reasoningEffort,
+                                maxToolCalls: maxToolCalls,
+                                backgroundMode: backgroundMode,
+                                maxBackgroundWaitMs: maxBackgroundWaitMs,
+                                textFormat: textFormat,
+                                serviceTier: args.serviceTier,
+                            })];
+                    case 2:
+                        result = _a.sent();
+                        object = this.parseAndValidateStructuredOutput(result.message, args.schema, {
+                            model: model,
+                            maxOutputTokens: args.maxTokens,
+                            requestedServiceTier: args.serviceTier,
+                            serviceTier: result.serviceTier,
+                        });
+                        outcome = {
+                            object: object,
+                            usageData: result.usagedata,
+                        };
+                        if (!args.onUsageData) return [3 /*break*/, 4];
+                        return [4 /*yield*/, args.onUsageData(outcome.usageData)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, outcome];
+                }
+            });
+        });
+    };
+    // -----------------------------------------
+    // Core runner (tool loop)
+    // -----------------------------------------
+    OpenAiResponses.prototype.run = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var usage, toolInvocations, tools, _a, instructions, input, toolCallsExecuted, previousResponseId, nextInput, response, functionCalls, message, toolOutputs;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        usage = new UsageData_1.UsageDataAccumulator({ model: args.model });
+                        toolInvocations = [];
+                        tools = this.buildResponseTools(this.functions);
+                        _a = this.buildInstructionsAndInput(args.messages), instructions = _a.instructions, input = _a.input;
+                        toolCallsExecuted = 0;
+                        nextInput = input;
+                        _b.label = 1;
+                    case 1: return [4 /*yield*/, this.createResponseAndMaybeWait({
+                            model: args.model,
+                            // Always pass instructions; they are not carried over with previous_response_id.
+                            instructions: instructions,
+                            input: nextInput,
+                            previousResponseId: previousResponseId,
+                            tools: tools,
+                            temperature: args.temperature,
+                            topP: args.topP,
+                            maxTokens: args.maxTokens,
+                            reasoningEffort: args.reasoningEffort,
+                            textFormat: args.textFormat,
+                            backgroundMode: args.backgroundMode,
+                            maxBackgroundWaitMs: args.maxBackgroundWaitMs,
+                            abortSignal: args.abortSignal,
+                            serviceTier: args.serviceTier,
+                        })];
+                    case 2:
+                        response = _b.sent();
+                        this.addUsageFromResponse(response, usage, { requestedServiceTier: args.serviceTier });
+                        // For structured outputs we should not attempt to parse incomplete/failed/cancelled responses.
+                        // For plain-text generation, we allow "incomplete" to pass through (partial output),
+                        // but still fail on other non-completed statuses.
+                        this.throwIfResponseUnusable(response, {
+                            allowIncomplete: !args.textFormat,
+                            model: args.model,
+                            maxOutputTokens: args.maxTokens,
+                            requestedServiceTier: args.serviceTier,
+                        });
+                        functionCalls = this.extractFunctionCalls(response);
+                        if (functionCalls.length < 1) {
+                            message = this.extractAssistantText(response);
+                            if (!message) {
+                                throw new Error("Response was empty");
+                            }
+                            return [2 /*return*/, {
+                                    message: message,
+                                    usagedata: usage.usageData,
+                                    toolInvocations: toolInvocations,
+                                    serviceTier: response.service_tier ? response.service_tier : undefined,
+                                }];
+                        }
+                        if (toolCallsExecuted + functionCalls.length > args.maxToolCalls) {
+                            throw new Error("Max tool calls (".concat(args.maxToolCalls, ") reached. Stopping execution."));
+                        }
+                        if (!response.id) {
+                            throw new Error("Responses API did not return an id for a tool-calling response.");
+                        }
+                        return [4 /*yield*/, this.executeFunctionCalls({
+                                calls: functionCalls,
+                                functions: this.functions,
+                                usage: usage,
+                                toolInvocations: toolInvocations,
+                                onToolInvocation: args.onToolInvocation,
+                            })];
+                    case 3:
+                        toolOutputs = _b.sent();
+                        toolCallsExecuted += functionCalls.length;
+                        previousResponseId = response.id;
+                        nextInput = toolOutputs;
+                        this.logger.debug({
+                            message: "Tool loop continuing",
+                            obj: { toolCallsExecuted: toolCallsExecuted, lastToolCallCount: functionCalls.length, responseId: previousResponseId },
+                        });
+                        _b.label = 4;
+                    case 4: return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.throwIfResponseUnusable = function (response, opts) {
+        var _a;
+        var statusRaw = typeof (response === null || response === void 0 ? void 0 : response.status) === 'string' ? String(response.status) : '';
+        var status = statusRaw.toLowerCase();
+        if (!status || status === 'completed') {
+            return;
+        }
+        if (status === 'incomplete' && opts.allowIncomplete) {
+            return;
+        }
+        var id = typeof (response === null || response === void 0 ? void 0 : response.id) === 'string' ? response.id : '';
+        var reason = (_a = response === null || response === void 0 ? void 0 : response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason;
+        var apiErr = response === null || response === void 0 ? void 0 : response.error;
+        var serviceTier = typeof (response === null || response === void 0 ? void 0 : response.service_tier) === 'string' && response.service_tier.trim() ? response.service_tier.trim() : '';
+        var directOutputText = typeof (response === null || response === void 0 ? void 0 : response.output_text) === 'string' ? response.output_text : '';
+        var assistantText = this.extractAssistantText(response);
+        var outTextLen = directOutputText ? directOutputText.length : 0;
+        var assistantLen = assistantText ? assistantText.length : 0;
+        var usage = response === null || response === void 0 ? void 0 : response.usage;
+        var inputTokens = typeof (usage === null || usage === void 0 ? void 0 : usage.input_tokens) === 'number' ? usage.input_tokens : undefined;
+        var outputTokens = typeof (usage === null || usage === void 0 ? void 0 : usage.output_tokens) === 'number' ? usage.output_tokens : undefined;
+        var totalTokens = typeof (usage === null || usage === void 0 ? void 0 : usage.total_tokens) === 'number'
+            ? usage.total_tokens
+            : typeof inputTokens === 'number' && typeof outputTokens === 'number'
+                ? inputTokens + outputTokens
+                : undefined;
+        var msg = "Responses API returned status=\"".concat(status, "\"");
+        if (id) {
+            msg += " (id=".concat(id, ")");
+        }
+        msg += ".";
+        var details = {
+            response_id: id || undefined,
+            status: status,
+            model: typeof opts.model === 'string' && opts.model.trim() ? opts.model : undefined,
+            max_output_tokens: typeof opts.maxOutputTokens === 'number' ? opts.maxOutputTokens : undefined,
+            requested_service_tier: typeof opts.requestedServiceTier === 'string' && opts.requestedServiceTier.trim()
+                ? opts.requestedServiceTier.trim()
+                : undefined,
+            service_tier: serviceTier || undefined,
+            incomplete_reason: typeof reason === 'string' && reason.trim() ? reason : undefined,
+            api_error: apiErr !== null && apiErr !== void 0 ? apiErr : undefined,
+            usage_input_tokens: inputTokens,
+            usage_output_tokens: outputTokens,
+            usage_total_tokens: totalTokens,
+            output_text_len: outTextLen || undefined,
+            output_text_tail: outTextLen > 0 ? truncateTail(directOutputText, 400) : undefined,
+            assistant_text_len: assistantLen || undefined,
+            assistant_text_tail: assistantLen > 0 ? truncateTail(assistantText, 400) : undefined,
+        };
+        var extra = [];
+        if (details.model) {
+            extra.push("model=".concat(details.model));
+        }
+        if (typeof details.max_output_tokens === 'number') {
+            extra.push("max_output_tokens=".concat(details.max_output_tokens));
+        }
+        if (typeof details.requested_service_tier === 'string') {
+            extra.push("requested_service_tier=".concat(details.requested_service_tier));
+        }
+        if (typeof details.service_tier === 'string') {
+            extra.push("service_tier=".concat(details.service_tier));
+        }
+        if (details.incomplete_reason) {
+            extra.push("reason=".concat(details.incomplete_reason));
+        }
+        if (typeof details.output_text_len === 'number') {
+            extra.push("output_text_len=".concat(details.output_text_len));
+        }
+        if (typeof details.assistant_text_len === 'number') {
+            extra.push("assistant_text_len=".concat(details.assistant_text_len));
+        }
+        if (extra.length > 0) {
+            msg += " ".concat(extra.join(' '), ".");
+        }
+        throw new OpenAiResponsesError({
+            code: 'RESPONSE_STATUS',
+            message: msg,
+            details: details,
+        });
+    };
+    OpenAiResponses.prototype.toOpenAiApiError = function (error, meta) {
+        var status = extractHttpStatus(error);
+        var requestId = extractRequestId(error);
+        var retryable = isRetryableHttpStatus(status);
+        var errMsg = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
+        var errName = error instanceof Error ? error.name : undefined;
+        var aborted = meta.aborted === true || isAbortError(error);
+        var msg = "OpenAI ".concat(meta.operation, " failed.");
+        var extra = [];
+        if (aborted) {
+            extra.push("aborted=true");
+        }
+        if (typeof status === 'number') {
+            extra.push("status=".concat(status));
+        }
+        if (requestId) {
+            extra.push("requestId=".concat(requestId));
+        }
+        if (meta.responseId) {
+            extra.push("responseId=".concat(meta.responseId));
+        }
+        if (meta.backgroundMode) {
+            extra.push("background=true");
+        }
+        if (typeof meta.pollAttempt === 'number') {
+            extra.push("pollAttempt=".concat(meta.pollAttempt));
+        }
+        if (typeof meta.waitedMs === 'number') {
+            extra.push("waitedMs=".concat(meta.waitedMs));
+        }
+        if (typeof meta.maxWaitMs === 'number') {
+            extra.push("maxWaitMs=".concat(meta.maxWaitMs));
+        }
+        if (typeof meta.lastStatus === 'string' && meta.lastStatus.trim()) {
+            extra.push("lastStatus=".concat(meta.lastStatus.trim()));
+        }
+        if (typeof meta.model === 'string' && meta.model.trim()) {
+            extra.push("model=".concat(meta.model.trim()));
+        }
+        if (meta.reasoningEffort) {
+            extra.push("reasoningEffort=".concat(meta.reasoningEffort));
+        }
+        if (typeof meta.requestedServiceTier === 'string' && meta.requestedServiceTier.trim()) {
+            extra.push("requested_service_tier=".concat(meta.requestedServiceTier.trim()));
+        }
+        if (typeof meta.serviceTier === 'string' && meta.serviceTier.trim()) {
+            extra.push("service_tier=".concat(meta.serviceTier.trim()));
+        }
+        if (extra.length > 0) {
+            msg += " ".concat(extra.join(' '), ".");
+        }
+        if (errMsg) {
+            msg += " error=".concat(JSON.stringify(errMsg), ".");
+        }
+        var details = {
+            operation: meta.operation,
+            status: typeof status === 'number' ? status : undefined,
+            request_id: requestId,
+            response_id: meta.responseId,
+            previous_response_id: meta.previousResponseId,
+            background: meta.backgroundMode ? true : undefined,
+            poll_attempt: meta.pollAttempt,
+            waited_ms: meta.waitedMs,
+            max_wait_ms: meta.maxWaitMs,
+            last_status: typeof meta.lastStatus === 'string' && meta.lastStatus.trim() ? meta.lastStatus.trim() : undefined,
+            model: typeof meta.model === 'string' && meta.model.trim() ? meta.model.trim() : undefined,
+            reasoning_effort: meta.reasoningEffort,
+            requested_service_tier: typeof meta.requestedServiceTier === 'string' && meta.requestedServiceTier.trim()
+                ? meta.requestedServiceTier.trim()
+                : undefined,
+            service_tier: typeof meta.serviceTier === 'string' && meta.serviceTier.trim() ? meta.serviceTier.trim() : undefined,
+            error_name: errName,
+            aborted: aborted ? true : undefined,
+        };
+        return new OpenAiResponsesError({
+            code: 'OPENAI_API',
+            message: msg,
+            details: details,
+            cause: error,
+            retryable: retryable,
+        });
+    };
+    OpenAiResponses.prototype.resolveMaxBackgroundWaitMs = function (ms) {
+        var n = typeof ms === 'number' && Number.isFinite(ms) && ms > 0 ? Math.floor(ms) : this.defaultMaxBackgroundWaitMs;
+        // Ensure we never return a non-positive number even if misconfigured elsewhere.
+        return n > 0 ? n : exports.DEFAULT_MAX_BACKGROUND_WAIT_MS;
+    };
+    OpenAiResponses.prototype.cancelResponseBestEffort = function (responseId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resp, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!responseId) {
+                            return [2 /*return*/, { attempted: false }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.responses.cancel(responseId)];
+                    case 2:
+                        resp = _a.sent();
+                        // Docs show cancelled as the post-cancel status.
+                        if ((resp === null || resp === void 0 ? void 0 : resp.status) === 'cancelled') {
+                            return [2 /*return*/, { attempted: true, ok: true }];
+                        }
+                        return [2 /*return*/, {
+                                attempted: true,
+                                ok: false,
+                                error: {
+                                    message: 'Cancel did not return status=cancelled',
+                                    status: resp === null || resp === void 0 ? void 0 : resp.status,
+                                },
+                            }];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, { attempted: true, ok: false, error: safeErrorSummary(e_1) }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.createResponseAndMaybeWait = function (args) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var body, created, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        body = {
+                            model: args.model,
+                            input: args.input,
+                        };
+                        if (args.instructions) {
+                            body.instructions = args.instructions;
+                        }
+                        if (args.previousResponseId) {
+                            body.previous_response_id = args.previousResponseId;
+                        }
+                        if (args.tools.length > 0) {
+                            body.tools = args.tools;
+                        }
+                        if (typeof args.temperature === 'number') {
+                            body.temperature = args.temperature;
+                        }
+                        if (typeof args.topP === 'number') {
+                            body.top_p = args.topP;
+                        }
+                        if (typeof args.maxTokens === 'number') {
+                            body.max_output_tokens = args.maxTokens;
+                        }
+                        if (args.reasoningEffort) {
+                            body.reasoning = { effort: args.reasoningEffort };
+                        }
+                        if (args.textFormat) {
+                            body.text = { format: args.textFormat };
+                        }
+                        if (typeof args.serviceTier === 'string' && args.serviceTier.trim()) {
+                            body.service_tier = args.serviceTier.trim();
+                        }
+                        if (args.backgroundMode) {
+                            body.background = true;
+                            body.store = true;
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.responses.create(body, args.abortSignal ? { signal: args.abortSignal } : undefined)];
+                    case 2:
+                        created = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _b.sent();
+                        throw this.toOpenAiApiError(error_1, {
+                            operation: 'responses.create',
+                            model: args.model,
+                            reasoningEffort: args.reasoningEffort,
+                            backgroundMode: args.backgroundMode,
+                            previousResponseId: args.previousResponseId,
+                            aborted: ((_a = args.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) ? true : undefined,
+                            requestedServiceTier: args.serviceTier,
+                        });
+                    case 4:
+                        if (!args.backgroundMode) {
+                            return [2 /*return*/, created];
+                        }
+                        if (!(created === null || created === void 0 ? void 0 : created.id)) {
+                            return [2 /*return*/, created];
+                        }
+                        return [4 /*yield*/, this.waitForCompletion(created.id, args.abortSignal, {
+                                model: args.model,
+                                reasoningEffort: args.reasoningEffort,
+                                maxWaitMs: this.resolveMaxBackgroundWaitMs(args.maxBackgroundWaitMs),
+                                requestedServiceTier: args.serviceTier,
+                            })];
+                    case 5: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.waitForCompletion = function (responseId, abortSignal, ctx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxWaitMs, startedAtMs, delayMs, pollAttempt, lastStatus, cancelAttempted, warnEveryMs, nextWarnAtMs, throwPollingStop, waitedMs, resp, error_2, status_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.logger.debug({ message: 'Waiting for completion', obj: { responseId: responseId } });
+                        maxWaitMs = this.resolveMaxBackgroundWaitMs(ctx === null || ctx === void 0 ? void 0 : ctx.maxWaitMs);
+                        startedAtMs = Date.now();
+                        delayMs = 1000;
+                        pollAttempt = 0;
+                        lastStatus = '';
+                        cancelAttempted = false;
+                        warnEveryMs = 10 * 60 * 1000;
+                        nextWarnAtMs = warnEveryMs;
+                        throwPollingStop = function (args) { return __awaiter(_this, void 0, void 0, function () {
+                            var waitedMs, cancel, baseDetails, msg;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        waitedMs = Date.now() - startedAtMs;
+                                        cancel = undefined;
+                                        if (!!cancelAttempted) return [3 /*break*/, 2];
+                                        cancelAttempted = true;
+                                        return [4 /*yield*/, this.cancelResponseBestEffort(responseId)];
+                                    case 1:
+                                        cancel = _a.sent();
+                                        _a.label = 2;
+                                    case 2:
+                                        baseDetails = {
+                                            operation: 'responses.retrieve',
+                                            response_id: responseId,
+                                            background: true,
+                                            poll_attempt: pollAttempt,
+                                            waited_ms: waitedMs,
+                                            max_wait_ms: maxWaitMs,
+                                            last_status: lastStatus || undefined,
+                                            model: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.model) === 'string' && ctx.model.trim() ? ctx.model.trim() : undefined,
+                                            reasoning_effort: ctx === null || ctx === void 0 ? void 0 : ctx.reasoningEffort,
+                                            requested_service_tier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier) === 'string' && ctx.requestedServiceTier.trim()
+                                                ? ctx.requestedServiceTier.trim()
+                                                : undefined,
+                                            aborted: args.kind === 'aborted' ? true : undefined,
+                                            timeout: args.kind === 'timeout' ? true : undefined,
+                                            cancel_attempted: (cancel === null || cancel === void 0 ? void 0 : cancel.attempted) ? true : undefined,
+                                            cancel_ok: cancel && cancel.attempted && 'ok' in cancel ? cancel.ok : undefined,
+                                            cancel_timed_out: cancel && cancel.attempted && cancel.timedOut ? true : undefined,
+                                            cancel_error: cancel && cancel.attempted && cancel.error ? cancel.error : undefined,
+                                        };
+                                        if (args.cause) {
+                                            baseDetails.polling_cause = safeErrorSummary(args.cause);
+                                        }
+                                        msg = args.kind === 'timeout'
+                                            ? "Background response exceeded max wait (maxWaitMs=".concat(maxWaitMs, ") while polling (id=").concat(responseId, ").")
+                                            : "Background polling aborted (id=".concat(responseId, ").");
+                                        throw new OpenAiResponsesError({
+                                            code: 'OPENAI_API',
+                                            message: msg,
+                                            details: baseDetails,
+                                            cause: args.cause,
+                                        });
+                                }
+                            });
+                        }); };
+                        _a.label = 1;
+                    case 1:
+                        waitedMs = Date.now() - startedAtMs;
+                        if (!(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, throwPollingStop({ kind: 'aborted' })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!(waitedMs >= maxWaitMs)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, throwPollingStop({ kind: 'timeout' })];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        // Warn every 10 minutes elapsed (best-effort; may log slightly after the boundary).
+                        if (waitedMs >= nextWarnAtMs) {
+                            nextWarnAtMs += warnEveryMs;
+                            this.logger.warn({
+                                message: "Background polling still in progress",
+                                obj: {
+                                    responseId: responseId,
+                                    status: lastStatus || undefined,
+                                    waitedMs: waitedMs,
+                                    pollAttempt: pollAttempt,
+                                    model: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.model) === 'string' && ctx.model.trim() ? ctx.model.trim() : undefined,
+                                    reasoningEffort: ctx === null || ctx === void 0 ? void 0 : ctx.reasoningEffort,
+                                    serviceTier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier) === 'string' && ctx.requestedServiceTier.trim()
+                                        ? ctx.requestedServiceTier.trim()
+                                        : undefined,
+                                },
+                            });
+                        }
+                        pollAttempt += 1;
+                        resp = void 0;
+                        _a.label = 6;
+                    case 6:
+                        _a.trys.push([6, 8, , 11]);
+                        return [4 /*yield*/, this.client.responses.retrieve(responseId, undefined, abortSignal ? { signal: abortSignal } : undefined)];
+                    case 7:
+                        resp = _a.sent();
+                        return [3 /*break*/, 11];
+                    case 8:
+                        error_2 = _a.sent();
+                        if (!((abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) || isAbortError(error_2))) return [3 /*break*/, 10];
+                        return [4 /*yield*/, throwPollingStop({ kind: 'aborted', cause: error_2 })];
+                    case 9:
+                        _a.sent();
+                        _a.label = 10;
+                    case 10: throw this.toOpenAiApiError(error_2, {
+                        operation: 'responses.retrieve',
+                        model: ctx === null || ctx === void 0 ? void 0 : ctx.model,
+                        reasoningEffort: ctx === null || ctx === void 0 ? void 0 : ctx.reasoningEffort,
+                        backgroundMode: true,
+                        responseId: responseId,
+                        pollAttempt: pollAttempt,
+                        waitedMs: waitedMs,
+                        maxWaitMs: maxWaitMs,
+                        lastStatus: lastStatus,
+                        requestedServiceTier: ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier,
+                    });
+                    case 11:
+                        status_1 = typeof (resp === null || resp === void 0 ? void 0 : resp.status) === 'string' ? resp.status : '';
+                        lastStatus = status_1;
+                        // Terminal states
+                        if (status_1 === 'completed' || status_1 === 'failed' || status_1 === 'incomplete' || status_1 === 'cancelled') {
+                            return [2 /*return*/, resp];
+                        }
+                        this.logger.debug({ message: "Polling response", obj: { responseId: responseId, status: status_1, delayMs: delayMs, pollAttempt: pollAttempt, waitedMs: waitedMs } });
+                        // Sleep but wake early if aborted, so abort latency is low.
+                        return [4 /*yield*/, sleepWithAbort(delayMs, abortSignal)];
+                    case 12:
+                        // Sleep but wake early if aborted, so abort latency is low.
+                        _a.sent();
+                        _a.label = 13;
+                    case 13: return [3 /*break*/, 1];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // -----------------------------------------
+    // Tool calls
+    // -----------------------------------------
+    OpenAiResponses.prototype.buildResponseTools = function (functions) {
+        var tools = [];
+        if (!functions || functions.length < 1) {
+            return tools;
+        }
+        for (var _i = 0, functions_1 = functions; _i < functions_1.length; _i++) {
+            var f = functions_1[_i];
+            var def = f.definition;
+            if (!(def === null || def === void 0 ? void 0 : def.name)) {
+                continue;
+            }
+            tools.push({
+                type: 'function',
+                name: def.name,
+                description: def.description,
+                parameters: def.parameters,
+                // strict: true,
+            });
+        }
+        return tools;
+    };
+    OpenAiResponses.prototype.extractFunctionCalls = function (response) {
+        var out = Array.isArray(response.output) ? response.output : [];
+        var calls = [];
+        for (var _i = 0, out_1 = out; _i < out_1.length; _i++) {
+            var item = out_1[_i];
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            var rec = item;
+            if (rec.type !== 'function_call') {
+                continue;
+            }
+            var call_id = typeof rec.call_id === 'string' ? rec.call_id : '';
+            var name_1 = typeof rec.name === 'string' ? rec.name : '';
+            var args = typeof rec.arguments === 'string' ? rec.arguments : '';
+            if (!call_id || !name_1) {
+                continue;
+            }
+            calls.push({ type: 'function_call', call_id: call_id, name: name_1, arguments: args });
+        }
+        return calls;
+    };
+    OpenAiResponses.prototype.executeFunctionCalls = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var outputs, _i, _a, call, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        outputs = [];
+                        _i = 0, _a = args.calls;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        call = _a[_i];
+                        _c = (_b = outputs).push;
+                        return [4 /*yield*/, this.executeFunctionCall({
+                                call: call,
+                                functions: args.functions,
+                                usage: args.usage,
+                                toolInvocations: args.toolInvocations,
+                                onToolInvocation: args.onToolInvocation,
+                            })];
+                    case 2:
+                        _c.apply(_b, [_d.sent()]);
+                        _d.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, outputs];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.executeFunctionCall = function (args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return __awaiter(this, void 0, void 0, function () {
+            var callId, rawName, shortName, functionToCall, startedAt, parsedArgs, finishedAt, rec, argsObj, returnObject, finishedAt, rec, output, error_3, finishedAt, errMessage, errStack, rec;
+            return __generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0:
+                        callId = args.call.call_id;
+                        rawName = args.call.name;
+                        shortName = (_a = rawName.split('.').pop()) !== null && _a !== void 0 ? _a : rawName;
+                        functionToCall = (_b = args.functions.find(function (fx) { return fx.definition.name === rawName; })) !== null && _b !== void 0 ? _b : args.functions.find(function (fx) { var _a; return ((_a = fx.definition.name.split('.').pop()) !== null && _a !== void 0 ? _a : fx.definition.name) === shortName; });
+                        startedAt = new Date();
+                        try {
+                            parsedArgs = JSON.parse((_c = args.call.arguments) !== null && _c !== void 0 ? _c : '{}');
+                        }
+                        catch (_o) {
+                            parsedArgs = args.call.arguments;
+                        }
+                        (_d = args.onToolInvocation) === null || _d === void 0 ? void 0 : _d.call(args, {
+                            type: 'started',
+                            id: callId,
+                            name: (_f = (_e = functionToCall === null || functionToCall === void 0 ? void 0 : functionToCall.definition) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : shortName,
+                            startedAt: startedAt,
+                            input: parsedArgs,
+                        });
+                        if (!functionToCall) {
+                            finishedAt = new Date();
+                            rec = {
+                                id: callId,
+                                name: shortName,
+                                startedAt: startedAt,
+                                finishedAt: finishedAt,
+                                input: parsedArgs,
+                                ok: false,
+                                error: { message: "Assistant attempted to call nonexistent function" },
+                            };
+                            args.toolInvocations.push(rec);
+                            (_g = args.onToolInvocation) === null || _g === void 0 ? void 0 : _g.call(args, { type: 'finished', result: rec });
+                            return [2 /*return*/, {
+                                    type: 'function_call_output',
+                                    call_id: callId,
+                                    output: JSON.stringify({ error: (_h = rec.error) === null || _h === void 0 ? void 0 : _h.message, functionName: shortName }),
+                                }];
+                        }
+                        _m.label = 1;
+                    case 1:
+                        _m.trys.push([1, 4, , 5]);
+                        argsObj = void 0;
+                        try {
+                            argsObj = JSON.parse((_j = args.call.arguments) !== null && _j !== void 0 ? _j : '{}');
+                        }
+                        catch (_p) {
+                            argsObj = {};
+                        }
+                        args.usage.recordToolCall(functionToCall.definition.name);
+                        return [4 /*yield*/, functionToCall.call(argsObj)];
+                    case 2:
+                        returnObject = _m.sent();
+                        finishedAt = new Date();
+                        rec = {
+                            id: callId,
+                            name: functionToCall.definition.name,
+                            startedAt: startedAt,
+                            finishedAt: finishedAt,
+                            input: argsObj,
+                            ok: true,
+                            data: returnObject,
+                        };
+                        args.toolInvocations.push(rec);
+                        (_k = args.onToolInvocation) === null || _k === void 0 ? void 0 : _k.call(args, { type: 'finished', result: rec });
+                        return [4 /*yield*/, this.formatToolReturn(returnObject)];
+                    case 3:
+                        output = _m.sent();
+                        return [2 /*return*/, {
+                                type: 'function_call_output',
+                                call_id: callId,
+                                output: output,
+                            }];
+                    case 4:
+                        error_3 = _m.sent();
+                        finishedAt = new Date();
+                        errMessage = error_3 instanceof Error ? error_3.message : String(error_3);
+                        errStack = error_3 instanceof Error ? error_3.stack : undefined;
+                        rec = {
+                            id: callId,
+                            name: functionToCall.definition.name,
+                            startedAt: startedAt,
+                            finishedAt: finishedAt,
+                            input: parsedArgs,
+                            ok: false,
+                            error: { message: errMessage, stack: errStack },
+                        };
+                        args.toolInvocations.push(rec);
+                        (_l = args.onToolInvocation) === null || _l === void 0 ? void 0 : _l.call(args, { type: 'finished', result: rec });
+                        throw error_3;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.formatToolReturn = function (returnObject) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messageParams, normalized;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof returnObject === 'undefined') {
+                            return [2 /*return*/, JSON.stringify({ result: 'Function with no return value executed successfully' })];
+                        }
+                        if (!(returnObject instanceof ChatCompletionMessageParamFactory_1.ChatCompletionMessageParamFactory)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, returnObject.create()];
+                    case 1:
+                        messageParams = _a.sent();
+                        normalized = (messageParams !== null && messageParams !== void 0 ? messageParams : [])
+                            .map(function (m) { return ({
+                            role: m.role,
+                            content: _this.extractTextContent(m.content),
+                        }); })
+                            .filter(function (m) { return typeof m.content === 'string' && m.content.trim().length > 0; });
+                        return [2 /*return*/, JSON.stringify({ messages: normalized })];
+                    case 2: return [2 /*return*/, JSON.stringify(returnObject)];
+                }
+            });
+        });
+    };
+    // -----------------------------------------
+    // Usage + text extraction
+    // -----------------------------------------
+    OpenAiResponses.prototype.addUsageFromResponse = function (response, usage, ctx) {
+        var _a;
+        if (!response.usage) {
+            return;
+        }
+        usage.addTokenUsage({
+            inputTokens: response.usage.input_tokens,
+            cachedInputTokens: response.usage.input_tokens_details.cached_tokens,
+            outputTokens: response.usage.output_tokens,
+            reasoningTokens: response.usage.output_tokens_details.reasoning_tokens,
+            totalTokens: response.usage.total_tokens,
+        }, { serviceTier: (_a = response.service_tier) !== null && _a !== void 0 ? _a : ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier });
+    };
+    OpenAiResponses.prototype.extractAssistantText = function (response) {
+        var out = Array.isArray(response.output) ? response.output : [];
+        var lastJoined = '';
+        for (var _i = 0, out_2 = out; _i < out_2.length; _i++) {
+            var item = out_2[_i];
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            var rec = item;
+            if (rec.type !== 'message') {
+                continue;
+            }
+            if (rec.role !== 'assistant') {
+                continue;
+            }
+            var contentRaw = rec.content;
+            if (!Array.isArray(contentRaw)) {
+                continue;
+            }
+            var pieces = [];
+            for (var _a = 0, contentRaw_1 = contentRaw; _a < contentRaw_1.length; _a++) {
+                var c = contentRaw_1[_a];
+                if (!c || typeof c !== 'object') {
+                    continue;
+                }
+                var part = c;
+                if (part.type !== 'output_text') {
+                    continue;
+                }
+                var t = part.text;
+                if (typeof t === 'string' && t.trim()) {
+                    pieces.push(t);
+                }
+            }
+            var joined = pieces.join('\n').trim();
+            if (joined) {
+                lastJoined = joined;
+            }
+        }
+        if (lastJoined) {
+            return lastJoined;
+        }
+        var direct = typeof response.output_text === 'string' ? response.output_text.trim() : '';
+        if (direct) {
+            return direct;
+        }
+        return '';
+    };
+    // -----------------------------------------
+    // Structured outputs (JSON schema / Zod)
+    // -----------------------------------------
+    OpenAiResponses.prototype.buildTextFormat = function (schema) {
+        if (this.isZodSchema(schema)) {
+            // Prefer the official helper when schema is Zod.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            var mod = require('openai/helpers/zod');
+            return mod.zodTextFormat(schema, 'output');
+        }
+        return {
+            type: 'json_schema',
+            name: 'output',
+            strict: true,
+            schema: this.strictifyJsonSchema(schema),
+        };
+    };
+    OpenAiResponses.prototype.parseAndValidateStructuredOutput = function (text, schema, ctx) {
+        var parsed = this.parseJson(text, ctx);
+        if (this.isZodSchema(schema)) {
+            var res = schema.safeParse(parsed);
+            if (!(res === null || res === void 0 ? void 0 : res.success)) {
+                throw new Error("Structured output failed schema validation");
+            }
+            return res.data;
+        }
+        return parsed;
+    };
+    OpenAiResponses.prototype.isZodSchema = function (schema) {
+        if (!schema || (typeof schema !== 'object' && typeof schema !== 'function')) {
+            return false;
+        }
+        return typeof schema.safeParse === 'function';
+    };
+    OpenAiResponses.prototype.parseJson = function (text, ctx) {
+        var _a;
+        var cleaned = String(text !== null && text !== void 0 ? text : '')
+            .trim()
+            .replace(/^```(?:json)?/i, '')
+            .replace(/```$/i, '')
+            .trim();
+        try {
+            return JSON.parse(cleaned);
+        }
+        catch (err1) {
+            var firstErrMsg = err1 instanceof Error ? err1.message : String(err1);
+            var s = cleaned;
+            var firstObj = s.indexOf('{');
+            var firstArr = s.indexOf('[');
+            var start = firstObj === -1 ? firstArr : firstArr === -1 ? firstObj : Math.min(firstObj, firstArr);
+            var lastObj = s.lastIndexOf('}');
+            var lastArr = s.lastIndexOf(']');
+            var end = Math.max(lastObj, lastArr);
+            if (start >= 0 && end > start) {
+                var candidate = s.slice(start, end + 1);
+                try {
+                    return JSON.parse(candidate);
+                }
+                catch (err2) {
+                    var secondErrMsg = err2 instanceof Error ? err2.message : String(err2);
+                    var pos2rel = extractJsonParsePosition(secondErrMsg);
+                    var pos2 = typeof pos2rel === 'number' ? start + pos2rel : undefined;
+                    var pos1 = extractJsonParsePosition(firstErrMsg);
+                    var pos_1 = typeof pos2 === 'number' ? pos2 : pos1;
+                    var lc_1 = (_a = extractJsonParseLineCol(secondErrMsg)) !== null && _a !== void 0 ? _a : extractJsonParseLineCol(firstErrMsg);
+                    var details_1 = {
+                        model: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.model) === 'string' && ctx.model.trim() ? ctx.model : undefined,
+                        max_output_tokens: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.maxOutputTokens) === 'number' ? ctx.maxOutputTokens : undefined,
+                        requested_service_tier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier) === 'string' && String(ctx.requestedServiceTier).trim()
+                            ? String(ctx.requestedServiceTier).trim()
+                            : undefined,
+                        service_tier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.serviceTier) === 'string' && ctx.serviceTier.trim() ? ctx.serviceTier.trim() : undefined,
+                        cleaned_len: s.length,
+                        cleaned_head: truncateHead(s, 250),
+                        cleaned_tail: truncateTail(s, 500),
+                        json_start: start,
+                        json_end: end,
+                        json_candidate_len: candidate.length,
+                        first_error: firstErrMsg,
+                        second_error: secondErrMsg,
+                        error_pos: typeof pos_1 === 'number' ? pos_1 : undefined,
+                        error_line: lc_1 === null || lc_1 === void 0 ? void 0 : lc_1.line,
+                        error_column: lc_1 === null || lc_1 === void 0 ? void 0 : lc_1.column,
+                        error_context: typeof pos_1 === 'number' ? snippetAround(s, pos_1, 160) : undefined,
+                    };
+                    var msg_1 = "Failed to parse model output as JSON. " +
+                        "cleaned_len=".concat(s.length, " json_start=").concat(start, " json_end=").concat(end, ". ") +
+                        "first_error=".concat(JSON.stringify(firstErrMsg), " second_error=").concat(JSON.stringify(secondErrMsg), ".");
+                    throw new OpenAiResponsesError({
+                        code: 'JSON_PARSE',
+                        message: msg_1,
+                        details: details_1,
+                        cause: err2,
+                    });
+                }
+            }
+            var pos = extractJsonParsePosition(firstErrMsg);
+            var lc = extractJsonParseLineCol(firstErrMsg);
+            var details = {
+                model: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.model) === 'string' && ctx.model.trim() ? ctx.model : undefined,
+                max_output_tokens: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.maxOutputTokens) === 'number' ? ctx.maxOutputTokens : undefined,
+                requested_service_tier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.requestedServiceTier) === 'string' && String(ctx.requestedServiceTier).trim()
+                    ? String(ctx.requestedServiceTier).trim()
+                    : undefined,
+                service_tier: typeof (ctx === null || ctx === void 0 ? void 0 : ctx.serviceTier) === 'string' && ctx.serviceTier.trim() ? ctx.serviceTier.trim() : undefined,
+                cleaned_len: s.length,
+                cleaned_head: truncateHead(s, 250),
+                cleaned_tail: truncateTail(s, 500),
+                json_start: start >= 0 ? start : undefined,
+                json_end: end >= 0 ? end : undefined,
+                first_error: firstErrMsg,
+                error_pos: typeof pos === 'number' ? pos : undefined,
+                error_line: lc === null || lc === void 0 ? void 0 : lc.line,
+                error_column: lc === null || lc === void 0 ? void 0 : lc.column,
+                error_context: typeof pos === 'number' ? snippetAround(s, pos, 160) : undefined,
+            };
+            var msg = "Failed to parse model output as JSON. " +
+                "cleaned_len=".concat(s.length, ". ") +
+                "error=".concat(JSON.stringify(firstErrMsg), ".");
+            throw new OpenAiResponsesError({
+                code: 'JSON_PARSE',
+                message: msg,
+                details: details,
+                cause: err1,
+            });
+        }
+    };
+    /**
+     * Strictifies a plain JSON Schema for OpenAI Structured Outputs (strict mode):
+     *  - Ensures every object has `additionalProperties: false`
+     *  - Ensures every object has a `required` array that includes **all** keys in `properties`
+     *  - Adds missing `type: "object"` / `type: "array"` where implied by keywords
+     */
+    OpenAiResponses.prototype.strictifyJsonSchema = function (schema) {
+        var root = JSON.parse(JSON.stringify(schema !== null && schema !== void 0 ? schema : {}));
+        var visit = function (node) {
+            if (!node || typeof node !== 'object') {
+                return;
+            }
+            if (!node.type) {
+                if (node.properties || node.additionalProperties || node.patternProperties) {
+                    node.type = 'object';
+                }
+                else if (node.items || node.prefixItems) {
+                    node.type = 'array';
+                }
+            }
+            var types = Array.isArray(node.type) ? node.type : node.type ? [node.type] : [];
+            if (types.includes('object')) {
+                if (node.additionalProperties !== false) {
+                    node.additionalProperties = false;
+                }
+                if (node.properties && typeof node.properties === 'object') {
+                    var propKeys = Object.keys(node.properties);
+                    var currentReq = Array.isArray(node.required) ? node.required.slice() : [];
+                    node.required = Array.from(new Set(__spreadArray(__spreadArray([], currentReq, true), propKeys, true)));
+                    for (var _i = 0, propKeys_1 = propKeys; _i < propKeys_1.length; _i++) {
+                        var k = propKeys_1[_i];
+                        visit(node.properties[k]);
+                    }
+                }
+                if (node.patternProperties && typeof node.patternProperties === 'object') {
+                    for (var _a = 0, _b = Object.keys(node.patternProperties); _a < _b.length; _a++) {
+                        var k = _b[_a];
+                        visit(node.patternProperties[k]);
+                    }
+                }
+                for (var _c = 0, _d = ['$defs', 'definitions']; _c < _d.length; _c++) {
+                    var defsKey = _d[_c];
+                    if (node[defsKey] && typeof node[defsKey] === 'object') {
+                        for (var _e = 0, _f = Object.keys(node[defsKey]); _e < _f.length; _e++) {
+                            var key = _f[_e];
+                            visit(node[defsKey][key]);
+                        }
+                    }
+                }
+            }
+            if (types.includes('array')) {
+                if (node.items) {
+                    if (Array.isArray(node.items)) {
+                        node.items.forEach(visit);
+                    }
+                    else {
+                        visit(node.items);
+                    }
+                }
+                if (Array.isArray(node.prefixItems)) {
+                    node.prefixItems.forEach(visit);
+                }
+            }
+            for (var _g = 0, _h = ['oneOf', 'anyOf', 'allOf']; _g < _h.length; _g++) {
+                var k = _h[_g];
+                if (Array.isArray(node[k])) {
+                    node[k].forEach(visit);
+                }
+            }
+            if (node.not) {
+                visit(node.not);
+            }
+        };
+        visit(root);
+        return root;
+    };
+    // -----------------------------------------
+    // Messages + modules
+    // -----------------------------------------
+    OpenAiResponses.prototype.buildInstructionsAndInput = function (messages) {
+        var instructionsParts = [];
+        instructionsParts.push.apply(instructionsParts, this.systemMessages);
+        var input = [];
+        for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+            var m = messages_1[_i];
+            var msg = typeof m === 'string' ? { role: 'user', content: m } : m;
+            if (msg.role === 'system') {
+                var c = this.extractTextContent(msg.content).trim();
+                if (c) {
+                    instructionsParts.push(c);
+                }
+                continue;
+            }
+            if (msg.role === 'tool') {
+                continue;
+            }
+            var role = msg.role === 'assistant' ? 'assistant' : 'user';
+            var content = this.extractTextContent(msg.content).trim();
+            if (!content) {
+                continue;
+            }
+            input.push({ role: role, content: content });
+        }
+        var instructions = instructionsParts.map(function (s) { return String(s !== null && s !== void 0 ? s : '').trim(); }).filter(Boolean).length > 0
+            ? instructionsParts
+                .map(function (s) { return String(s !== null && s !== void 0 ? s : '').trim(); })
+                .filter(Boolean)
+                .join('\n\n')
+            : undefined;
+        return { instructions: instructions, input: input };
+    };
+    OpenAiResponses.prototype.extractTextContent = function (content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (!content) {
+            return '';
+        }
+        if (Array.isArray(content)) {
+            return content
+                .map(function (p) {
+                if (typeof p === 'string') {
+                    return p;
+                }
+                if ((p === null || p === void 0 ? void 0 : p.type) === 'text' && typeof (p === null || p === void 0 ? void 0 : p.text) === 'string') {
+                    return p.text;
+                }
+                return '';
+            })
+                .join('\n');
+        }
+        return '';
+    };
+    OpenAiResponses.prototype.ensureModulesProcessed = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.modulesProcessed) {
+                            return [2 /*return*/];
+                        }
+                        if (this.processingModulesPromise) {
+                            return [2 /*return*/, this.processingModulesPromise];
+                        }
+                        this.processingModulesPromise = this.processModules();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.processingModulesPromise];
+                    case 2:
+                        _a.sent();
+                        this.modulesProcessed = true;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_4 = _a.sent();
+                        this.processingModulesPromise = null;
+                        throw error_4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.processModules = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, module_1, moduleName, rawSystem, sysArr, trimmed, formatted, moduleFunctions, filtered, fnInstructions;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!this.modules || this.modules.length < 1) {
+                            return [2 /*return*/];
+                        }
+                        _i = 0, _a = this.modules;
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        module_1 = _a[_i];
+                        moduleName = module_1.getName();
+                        return [4 /*yield*/, Promise.resolve(module_1.getSystemMessages())];
+                    case 2:
+                        rawSystem = _c.sent();
+                        sysArr = Array.isArray(rawSystem) ? rawSystem : rawSystem ? [rawSystem] : [];
+                        trimmed = sysArr.map(function (s) { return String(s !== null && s !== void 0 ? s : '').trim(); }).filter(Boolean);
+                        if (trimmed.length > 0) {
+                            formatted = trimmed.join('. ');
+                            this.systemMessages.push("The following are instructions from the ".concat(moduleName, " module:\n").concat(formatted));
+                        }
+                        moduleFunctions = module_1.getFunctions();
+                        filtered = this.filterFunctions(moduleFunctions);
+                        (_b = this.functions).push.apply(_b, filtered);
+                        fnInstructions = this.buildFunctionInstructionsMessage(moduleName, filtered);
+                        if (fnInstructions) {
+                            this.systemMessages.push(fnInstructions);
+                        }
+                        _c.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.filterFunctions = function (functions) {
+        if (!this.allowedFunctionNames || this.allowedFunctionNames.length < 1) {
+            return functions;
+        }
+        var allow = new Set(this.allowedFunctionNames.map(function (n) { return String(n).trim(); }).filter(Boolean));
+        return functions.filter(function (f) {
+            var _a, _b, _c;
+            var name = String((_b = (_a = f.definition) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '').trim();
+            if (!name) {
+                return false;
+            }
+            var short = (_c = name.split('.').pop()) !== null && _c !== void 0 ? _c : name;
+            return allow.has(name) || allow.has(short);
+        });
+    };
+    OpenAiResponses.prototype.buildFunctionInstructionsMessage = function (moduleName, functions) {
+        var _a, _b;
+        var msg = "The following are instructions from functions in the ".concat(moduleName, " module:");
+        var added = false;
+        for (var _i = 0, functions_2 = functions; _i < functions_2.length; _i++) {
+            var f = functions_2[_i];
+            var name_2 = String((_b = (_a = f.definition) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '').trim();
+            var instructions = f.instructions;
+            if (!name_2 || !instructions || instructions.length < 1) {
+                continue;
+            }
+            var paragraph = instructions
+                .map(function (s) { return String(s !== null && s !== void 0 ? s : '').trim(); })
+                .filter(Boolean)
+                .join('. ');
+            if (!paragraph) {
+                continue;
+            }
+            added = true;
+            msg += " ".concat(name_2, ": ").concat(paragraph, ".");
+        }
+        return added ? msg : null;
+    };
+    // -----------------------------------------
+    // Model/background defaults
+    // -----------------------------------------
+    OpenAiResponses.prototype.resolveModel = function (model) {
+        return model !== null && model !== void 0 ? model : this.defaultModel;
+    };
+    OpenAiResponses.prototype.resolveBackgroundMode = function (args) {
+        if (typeof args.requested === 'boolean') {
+            return args.requested;
+        }
+        if (this.isProModel(args.model)) {
+            return true;
+        }
+        if (this.isHighReasoningEffort(args.reasoningEffort)) {
+            return true;
+        }
+        return false;
+    };
+    OpenAiResponses.prototype.isProModel = function (model) {
+        var m = String(model !== null && model !== void 0 ? model : '').toLowerCase();
+        return /(^|[-_.])pro($|[-_.])/.test(m);
+    };
+    OpenAiResponses.prototype.isHighReasoningEffort = function (effort) {
+        var v = String(effort !== null && effort !== void 0 ? effort : '').toLowerCase();
+        return v === 'high' || v === 'xhigh';
+    };
+    return OpenAiResponses;
+}());
+exports.OpenAiResponses = OpenAiResponses;
+var OpenAiResponsesError = /** @class */ (function (_super) {
+    __extends(OpenAiResponsesError, _super);
+    function OpenAiResponsesError(args) {
+        var _newTarget = this.constructor;
+        var _a;
+        var _this = _super.call(this, args.message) || this;
+        _this.name = 'OpenAiResponsesError';
+        _this.code = args.code;
+        _this.details = (_a = args.details) !== null && _a !== void 0 ? _a : {};
+        _this.cause = args.cause;
+        _this.retryable = typeof args.retryable === 'boolean' ? args.retryable : true;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return OpenAiResponsesError;
+}(Error));
+exports.OpenAiResponsesError = OpenAiResponsesError;
+function truncateHead(text, max) {
+    var s = String(text !== null && text !== void 0 ? text : '');
+    if (max <= 0) {
+        return '';
+    }
+    if (s.length <= max) {
+        return s;
+    }
+    return s.slice(0, max) + '...';
+}
+function truncateTail(text, max) {
+    var s = String(text !== null && text !== void 0 ? text : '');
+    if (max <= 0) {
+        return '';
+    }
+    if (s.length <= max) {
+        return s;
+    }
+    return '...' + s.slice(s.length - max);
+}
+function extractJsonParsePosition(errMsg) {
+    var m = String(errMsg !== null && errMsg !== void 0 ? errMsg : '').match(/at position\s+(\d+)/i);
+    if (!m) {
+        return undefined;
+    }
+    var n = Number(m[1]);
+    return Number.isFinite(n) ? n : undefined;
+}
+function extractJsonParseLineCol(errMsg) {
+    var m = String(errMsg !== null && errMsg !== void 0 ? errMsg : '').match(/line\s+(\d+)\s+column\s+(\d+)/i);
+    if (!m) {
+        return undefined;
+    }
+    var line = Number(m[1]);
+    var column = Number(m[2]);
+    return {
+        line: Number.isFinite(line) ? line : undefined,
+        column: Number.isFinite(column) ? column : undefined,
+    };
+}
+function snippetAround(text, pos, radius) {
+    var s = String(text !== null && text !== void 0 ? text : '');
+    var p = Math.max(0, Math.min(s.length, Number.isFinite(pos) ? pos : 0));
+    var r = Math.max(0, radius);
+    var start = Math.max(0, p - r);
+    var end = Math.min(s.length, p + r);
+    var before = s.slice(start, p);
+    var after = s.slice(p, end);
+    var left = start > 0 ? '...' : '';
+    var right = end < s.length ? '...' : '';
+    return "".concat(left).concat(before, "<<HERE>>").concat(after).concat(right);
+}
+function sleep(ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+}
+/**
+ * Sleep, but wake early if the signal is aborted.
+ * (We do not throw here; the caller should check `signal.aborted` and act.)
+ */
+function sleepWithAbort(ms, signal) {
+    if (!signal) {
+        return sleep(ms);
+    }
+    if (signal.aborted) {
+        return Promise.resolve();
+    }
+    return new Promise(function (resolve) {
+        var _a;
+        var t = setTimeout(function () {
+            cleanup();
+            resolve();
+        }, ms);
+        var onAbort = function () {
+            cleanup();
+            resolve();
+        };
+        var cleanup = function () {
+            var _a;
+            try {
+                clearTimeout(t);
+            }
+            catch (_b) {
+                // ignore
+            }
+            try {
+                (_a = signal.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(signal, 'abort', onAbort);
+            }
+            catch (_c) {
+                // ignore
+            }
+        };
+        try {
+            (_a = signal.addEventListener) === null || _a === void 0 ? void 0 : _a.call(signal, 'abort', onAbort, { once: true });
+        }
+        catch (_b) {
+            // If addEventListener isn't available, fall back to plain sleep.
+        }
+    });
+}
+function extractHttpStatus(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    var rec = error;
+    var status = rec.status;
+    if (typeof status === 'number' && Number.isFinite(status)) {
+        return status;
+    }
+    var statusCode = rec.statusCode;
+    if (typeof statusCode === 'number' && Number.isFinite(statusCode)) {
+        return statusCode;
+    }
+    return undefined;
+}
+function extractRequestId(error) {
+    var _a;
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    var rec = error;
+    var direct = (_a = rec.request_id) !== null && _a !== void 0 ? _a : rec.requestId;
+    if (typeof direct === 'string' && direct.trim()) {
+        return direct.trim();
+    }
+    var headers = rec.headers;
+    if (!headers) {
+        return undefined;
+    }
+    if (typeof headers.get === 'function') {
+        var v = headers.get('x-request-id');
+        return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+    }
+    if (typeof headers === 'object' && !Array.isArray(headers)) {
+        for (var _i = 0, _b = Object.keys(headers); _i < _b.length; _i++) {
+            var k = _b[_i];
+            if (String(k).toLowerCase() !== 'x-request-id') {
+                continue;
+            }
+            var v = headers[k];
+            return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+        }
+    }
+    return undefined;
+}
+function isRetryableHttpStatus(status) {
+    if (typeof status !== 'number') {
+        return true;
+    }
+    if (status === 408 || status === 409 || status === 429) {
+        return true;
+    }
+    if (status >= 500) {
+        return true;
+    }
+    return false;
+}
+function isAbortError(error) {
+    var _a, _b;
+    if (!error) {
+        return false;
+    }
+    // Most fetch implementations:
+    //  - error.name === 'AbortError'
+    //  - or error.code === 'ABORT_ERR'
+    if (error instanceof Error) {
+        var name_3 = String((_a = error.name) !== null && _a !== void 0 ? _a : '').toLowerCase();
+        if (name_3 === 'aborterror') {
+            return true;
+        }
+        var msg = String((_b = error.message) !== null && _b !== void 0 ? _b : '').toLowerCase();
+        // Keep this conservative; don't treat every "abort" substring as abort.
+        if (msg === 'aborted' || msg === 'request aborted') {
+            return true;
+        }
+    }
+    if (typeof error === 'object') {
+        var rec = error;
+        var code = rec.code;
+        if (typeof code === 'string' && code.toUpperCase() === 'ABORT_ERR') {
+            return true;
+        }
+    }
+    return false;
+}
+function safeErrorSummary(error) {
+    if (!error) {
+        return { message: 'Unknown error' };
+    }
+    var status = extractHttpStatus(error);
+    var requestId = extractRequestId(error);
+    if (error instanceof OpenAiResponsesError) {
+        return {
+            name: error.name,
+            message: error.message,
+            code: error.code,
+            details: error.details,
+            status: typeof status === 'number' ? status : undefined,
+            request_id: requestId,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            status: typeof status === 'number' ? status : undefined,
+            request_id: requestId,
+        };
+    }
+    return {
+        message: String(error),
+        status: typeof status === 'number' ? status : undefined,
+        request_id: requestId,
+    };
+}
+//# sourceMappingURL=OpenAiResponses.js.map