@proteinjs/conversation 2.4.2 → 2.6.0

package/dist/src/OpenAiResponses.js

@@ -0,0 +1,941 @@
+"use strict";
+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.OpenAiResponses = 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");
+var OpenAi_1 = require("./OpenAi");
+exports.DEFAULT_RESPONSES_MODEL = 'gpt-5.2';
+exports.DEFAULT_MAX_TOOL_CALLS = 50;
+/**
+ * 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).trim();
+        this.defaultMaxToolCalls = typeof opts.maxToolCalls === 'number' ? opts.maxToolCalls : exports.DEFAULT_MAX_TOOL_CALLS;
+    }
+    /** Plain text generation (supports tool calling). */
+    OpenAiResponses.prototype.generateText = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model, backgroundMode, maxToolCalls, 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;
+                        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,
+                                textFormat: undefined,
+                            })];
+                    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, 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;
+                        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,
+                                textFormat: textFormat,
+                            })];
+                    case 2:
+                        result = _a.sent();
+                        object = this.parseAndValidateStructuredOutput(result.message, args.schema);
+                        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: OpenAi_1.DEFAULT_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,
+                            instructions: previousResponseId ? undefined : 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,
+                            abortSignal: args.abortSignal,
+                        })];
+                    case 2:
+                        response = _b.sent();
+                        this.addUsageFromResponse(response, usage);
+                        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 }];
+                        }
+                        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.createResponseAndMaybeWait = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var body, created;
+            return __generator(this, function (_a) {
+                switch (_a.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 (args.backgroundMode) {
+                            body.background = true;
+                            body.store = true;
+                        }
+                        return [4 /*yield*/, this.client.responses.create(body, args.abortSignal ? { signal: args.abortSignal } : undefined)];
+                    case 1:
+                        created = _a.sent();
+                        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)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    OpenAiResponses.prototype.waitForCompletion = function (responseId, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            var delayMs, resp, status_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        delayMs = 500;
+                        _a.label = 1;
+                    case 1:
+                        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                            throw new Error("Request aborted");
+                        }
+                        return [4 /*yield*/, this.client.responses.retrieve(responseId, undefined, abortSignal ? { signal: abortSignal } : undefined)];
+                    case 2:
+                        resp = _a.sent();
+                        status_1 = typeof (resp === null || resp === void 0 ? void 0 : resp.status) === 'string' ? String(resp.status).toLowerCase() : '';
+                        if (status_1 === 'completed' || status_1 === 'failed' || status_1 === 'cancelled' || status_1 === 'incomplete') {
+                            return [2 /*return*/, resp];
+                        }
+                        this.logger.debug({ message: "Polling response", obj: { responseId: responseId, status: status_1, delayMs: delayMs } });
+                        return [4 /*yield*/, sleep(delayMs)];
+                    case 3:
+                        _a.sent();
+                        delayMs = Math.min(5000, Math.floor(delayMs * 1.5));
+                        _a.label = 4;
+                    case 4: return [3 /*break*/, 1];
+                    case 5: 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_1, 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_1 = _m.sent();
+                        finishedAt = new Date();
+                        errMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                        errStack = error_1 instanceof Error ? error_1.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_1;
+                    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) {
+        var u = response.usage;
+        if (!u || typeof u !== 'object') {
+            return;
+        }
+        var rec = u;
+        var input = typeof rec.input_tokens === 'number' ? rec.input_tokens : 0;
+        var output = typeof rec.output_tokens === 'number' ? rec.output_tokens : 0;
+        var total = typeof rec.total_tokens === 'number' ? rec.total_tokens : input + output;
+        var cached = 0;
+        var reasoning = 0;
+        var inputDetails = rec.input_tokens_details;
+        if (inputDetails && typeof inputDetails === 'object') {
+            var id = inputDetails;
+            cached = typeof id.cached_tokens === 'number' ? id.cached_tokens : 0;
+        }
+        var outputDetails = rec.output_tokens_details;
+        if (outputDetails && typeof outputDetails === 'object') {
+            var od = outputDetails;
+            reasoning = typeof od.reasoning_tokens === 'number' ? od.reasoning_tokens : 0;
+        }
+        usage.addTokenUsage({
+            promptTokens: input,
+            cachedPromptTokens: cached,
+            completionTokens: output,
+            reasoningTokens: reasoning,
+            totalTokens: total,
+        });
+    };
+    OpenAiResponses.prototype.extractAssistantText = function (response) {
+        var direct = typeof response.output_text === 'string' ? response.output_text.trim() : '';
+        if (direct) {
+            return direct;
+        }
+        var out = Array.isArray(response.output) ? response.output : [];
+        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) {
+                return joined;
+            }
+        }
+        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) {
+        var parsed = this.parseJson(text);
+        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) {
+        var cleaned = String(text !== null && text !== void 0 ? text : '')
+            .trim()
+            .replace(/^```(?:json)?/i, '')
+            .replace(/```$/i, '')
+            .trim();
+        try {
+            return JSON.parse(cleaned);
+        }
+        catch (_a) {
+            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) {
+                return JSON.parse(s.slice(start, end + 1));
+            }
+            throw new Error("Failed to parse model output as JSON");
+        }
+    };
+    /**
+     * 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_2;
+            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_2 = _a.sent();
+                        this.processingModulesPromise = null;
+                        throw error_2;
+                    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) {
+        var m = (model !== null && model !== void 0 ? model : this.defaultModel).trim();
+        return m.length > 0 ? m : exports.DEFAULT_RESPONSES_MODEL;
+    };
+    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;
+function sleep(ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+}
+//# sourceMappingURL=OpenAiResponses.js.map