@proteinjs/conversation 2.7.2 → 3.0.0

package/dist/src/Conversation.js

@@ -46,16 +46,24 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 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++) {
@@ -67,54 +75,332 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeConversationHistoryFunction = exports.summarizeConversationHistoryFunctionName = exports.Conversation = void 0;
-var OpenAi_1 = require("./OpenAi");
-var MessageHistory_1 = require("./history/MessageHistory");
+exports.Conversation = void 0;
+var ai_1 = require("ai");
 var logger_1 = require("@proteinjs/logger");
-var util_node_1 = require("@proteinjs/util-node");
-var tiktoken_1 = require("tiktoken");
-var PackageFunctions_1 = require("./fs/package/PackageFunctions");
+var MessageHistory_1 = require("./history/MessageHistory");
 var UsageData_1 = require("./UsageData");
-var ai_1 = require("ai");
+var resolveModel_1 = require("./resolveModel");
+// ────────────────────────────────────────────────────────────────
+// Default constants
+// ────────────────────────────────────────────────────────────────
+var DEFAULT_MODEL = 'gpt-4o';
+var DEFAULT_TOKEN_LIMIT = 50000;
+// ────────────────────────────────────────────────────────────────
+// Conversation class
+// ────────────────────────────────────────────────────────────────
 var Conversation = /** @class */ (function () {
     function Conversation(params) {
         var _a, _b, _c, _d;
-        this.tokenLimit = 50000;
         this.systemMessages = [];
         this.functions = [];
         this.messageModerators = [];
-        this.generatedCode = false;
-        this.generatedList = false;
         this.modulesProcessed = false;
         this.processingModulesPromise = null;
         this.params = params;
+        this.tokenLimit = (_b = (_a = params.limits) === null || _a === void 0 ? void 0 : _a.tokenLimit) !== null && _b !== void 0 ? _b : DEFAULT_TOKEN_LIMIT;
         this.history = new MessageHistory_1.MessageHistory({
-            maxMessages: (_a = params.limits) === null || _a === void 0 ? void 0 : _a.maxMessagesInHistory,
-            enforceMessageLimit: (_b = params.limits) === null || _b === void 0 ? void 0 : _b.enforceLimits,
+            maxMessages: (_c = params.limits) === null || _c === void 0 ? void 0 : _c.maxMessagesInHistory,
+            enforceMessageLimit: (_d = params.limits) === null || _d === void 0 ? void 0 : _d.enforceLimits,
         });
         this.logger = new logger_1.Logger({ name: params.name, logLevel: params.logLevel });
-        if ((_c = params === null || params === void 0 ? void 0 : params.limits) === null || _c === void 0 ? void 0 : _c.enforceLimits) {
-            this.addFunctions('Conversation', [(0, exports.summarizeConversationHistoryFunction)(this)]);
+    }
+    // ────────────────────────────────────────────────────────────
+    // Public API
+    // ────────────────────────────────────────────────────────────
+    /**
+     * Stream a text response from the model.
+     *
+     * Returns a `StreamResult` with async iterables for text and reasoning chunks,
+     * plus promises that resolve when generation completes.
+     *
+     * For OpenAI models with high reasoning effort or pro models, this may
+     * fall back to background/polling mode via `OpenAiResponses` and return
+     * the full result as a single-chunk stream.
+     */
+    Conversation.prototype.generateStream = function (params) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var model, modelString, provider, messages, system, nonSystem, allFunctions, tools, providerOptions, result, usagePromise, toolInvocationsPromise, safeText, safeReasoning, safeSources, safeUsage, safeToolInvocations;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+                    case 1:
+                        _e.sent();
+                        model = this.resolveModelInstance(params.model);
+                        modelString = this.getModelString(params.model);
+                        provider = (0, resolveModel_1.inferProvider)((_b = (_a = params.model) !== null && _a !== void 0 ? _a : this.params.defaultModel) !== null && _b !== void 0 ? _b : DEFAULT_MODEL);
+                        this.logger.info({
+                            message: "generateStream",
+                            obj: { model: modelString, provider: provider, reasoningEffort: params.reasoningEffort, webSearch: params.webSearch },
+                        });
+                        // Check if we should use background/polling mode (OpenAI-specific)
+                        if (provider === 'openai' && this.shouldUseBackgroundMode(modelString, params)) {
+                            return [2 /*return*/, this.generateStreamViaPolling(params, modelString)];
+                        }
+                        messages = this.buildAiSdkMessages(params.messages);
+                        // Google requires all system messages at the beginning of the conversation.
+                        // Reorder so system messages come first, preserving relative order within
+                        // each group.
+                        if (provider === 'google') {
+                            system = messages.filter(function (m) { return m.role === 'system'; });
+                            nonSystem = messages.filter(function (m) { return m.role !== 'system'; });
+                            messages = __spreadArray(__spreadArray([], system, true), nonSystem, true);
+                        }
+                        allFunctions = __spreadArray(__spreadArray([], this.functions, true), ((_c = params.tools) !== null && _c !== void 0 ? _c : []), true);
+                        tools = this.buildAiSdkTools(allFunctions);
+                        providerOptions = this.buildProviderOptions(provider, params, modelString);
+                        result = (0, ai_1.streamText)(__assign({ model: model, messages: messages, tools: Object.keys(tools).length > 0 ? tools : undefined, stopWhen: (0, ai_1.stepCountIs)((_d = params.maxToolCalls) !== null && _d !== void 0 ? _d : 50), abortSignal: params.abortSignal, providerOptions: providerOptions }, (params.webSearch && provider === 'openai' ? { toolChoice: 'auto' } : {})));
+                        usagePromise = this.buildUsagePromise(result, modelString, params);
+                        toolInvocationsPromise = this.buildToolInvocationsPromise(result);
+                        safeText = Promise.resolve(result.text).catch(function () { return ''; });
+                        safeReasoning = Promise.resolve(result.reasoning)
+                            .then(function (parts) {
+                            return parts
+                                ? parts
+                                    .filter(function (part) { return part.type === 'reasoning'; })
+                                    .map(function (part) { return part.text; })
+                                    .join('')
+                                : '';
+                        })
+                            .catch(function () { return ''; });
+                        safeSources = Promise.resolve(result.sources)
+                            .then(function (s) {
+                            return (s !== null && s !== void 0 ? s : []).map(function (source) { return ({
+                                url: source.sourceType === 'url' ? source.url : undefined,
+                                title: source.sourceType === 'url' ? source.title : undefined,
+                            }); });
+                        })
+                            .catch(function () { return []; });
+                        safeUsage = usagePromise.catch(function () {
+                            return ({
+                                model: modelString,
+                                initialRequestTokenUsage: {
+                                    inputTokens: 0,
+                                    cachedInputTokens: 0,
+                                    reasoningTokens: 0,
+                                    outputTokens: 0,
+                                    totalTokens: 0,
+                                },
+                                initialRequestCostUsd: { inputUsd: 0, cachedInputUsd: 0, reasoningUsd: 0, outputUsd: 0, totalUsd: 0 },
+                                totalTokenUsage: {
+                                    inputTokens: 0,
+                                    cachedInputTokens: 0,
+                                    reasoningTokens: 0,
+                                    outputTokens: 0,
+                                    totalTokens: 0,
+                                },
+                                totalCostUsd: { inputUsd: 0, cachedInputUsd: 0, reasoningUsd: 0, outputUsd: 0, totalUsd: 0 },
+                                totalRequestsToAssistant: 0,
+                                callsPerTool: {},
+                                totalToolCalls: 0,
+                            });
+                        });
+                        safeToolInvocations = toolInvocationsPromise.catch(function () { return []; });
+                        // Catch remaining AI SDK promises that are rejected by NoOutputGeneratedError
+                        // on flush when the stream is aborted before any output. The AI SDK's internal
+                        // flush rejects _finishReason, _rawFinishReason, _totalUsage, and _steps.
+                        // We already catch totalUsage and steps above; these catch the rest so the
+                        // unhandled rejections don't crash the Node process.
+                        Promise.resolve(result.finishReason).catch(function () { });
+                        Promise.resolve(result.rawFinishReason).catch(function () { });
+                        Promise.resolve(result.response).catch(function () { });
+                        return [2 /*return*/, {
+                                textStream: result.textStream,
+                                reasoningStream: (function () {
+                                    return __asyncGenerator(this, arguments, function () {
+                                        return __generator(this, function (_a) {
+                                            return [2 /*return*/];
+                                        });
+                                    });
+                                })(),
+                                fullStream: this.mapFullStream(result.fullStream),
+                                text: safeText,
+                                reasoning: safeReasoning,
+                                sources: safeSources,
+                                usage: safeUsage,
+                                toolInvocations: safeToolInvocations,
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Generate a strongly-typed structured object from the model.
+     *
+     * This is promise-based (not streaming-first) to guarantee the
+     * type contract. Reasoning is available on the result after completion.
+     *
+     * For OpenAI models with high reasoning or pro models, this uses
+     * `OpenAiResponses` with background/polling mode.
+     */
+    Conversation.prototype.generateObject = function (params) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var model, modelString, provider, messages, system, nonSystem, isZod, normalizedSchema, result, toRecord, usage, reasoning;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+                    case 1:
+                        _d.sent();
+                        model = this.resolveModelInstance(params.model);
+                        modelString = this.getModelString(params.model);
+                        provider = (0, resolveModel_1.inferProvider)((_b = (_a = params.model) !== null && _a !== void 0 ? _a : this.params.defaultModel) !== null && _b !== void 0 ? _b : DEFAULT_MODEL);
+                        // Check if we should use background/polling mode (OpenAI-specific)
+                        if (provider === 'openai' && this.shouldUseBackgroundMode(modelString, params)) {
+                            return [2 /*return*/, this.generateObjectViaPolling(params, modelString)];
+                        }
+                        messages = this.buildAiSdkMessages(params.messages);
+                        // Google requires all system messages at the beginning
+                        if (provider === 'google') {
+                            system = messages.filter(function (m) { return m.role === 'system'; });
+                            nonSystem = messages.filter(function (m) { return m.role !== 'system'; });
+                            messages = __spreadArray(__spreadArray([], system, true), nonSystem, true);
+                        }
+                        isZod = this.isZodSchema(params.schema);
+                        normalizedSchema = isZod ? params.schema : (0, ai_1.jsonSchema)(this.strictifyJsonSchema(params.schema));
+                        return [4 /*yield*/, (0, ai_1.generateObject)({
+                                model: model,
+                                messages: messages,
+                                schema: normalizedSchema,
+                                abortSignal: params.abortSignal,
+                                maxOutputTokens: params.maxTokens,
+                                temperature: params.temperature,
+                                topP: params.topP,
+                                providerOptions: this.buildProviderOptions(provider, params, modelString),
+                                experimental_repairText: (function (_a) {
+                                    var text = _a.text;
+                                    return __awaiter(_this, void 0, void 0, function () {
+                                        var cleaned;
+                                        return __generator(this, function (_b) {
+                                            cleaned = String(text !== null && text !== void 0 ? text : '')
+                                                .trim()
+                                                .replace(/^```(?:json)?/i, '')
+                                                .replace(/```$/, '');
+                                            try {
+                                                JSON.parse(cleaned);
+                                                return [2 /*return*/, cleaned];
+                                            }
+                                            catch (_c) {
+                                                return [2 /*return*/, null];
+                                            }
+                                            return [2 /*return*/];
+                                        });
+                                    });
+                                }),
+                            })];
+                    case 2:
+                        result = _d.sent();
+                        // Record in history
+                        if (params.recordInHistory !== false) {
+                            try {
+                                toRecord = typeof (result === null || result === void 0 ? void 0 : result.object) === 'object' ? JSON.stringify(result.object) : '';
+                                if (toRecord) {
+                                    this.addAssistantMessagesToHistory([toRecord]);
+                                }
+                            }
+                            catch (_e) {
+                                /* ignore */
+                            }
+                        }
+                        usage = this.processAiSdkUsage(result, modelString);
+                        if (!params.onUsageData) return [3 /*break*/, 4];
+                        return [4 /*yield*/, params.onUsageData(usage)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        reasoning = this.extractReasoningFromResult(result);
+                        return [2 /*return*/, {
+                                object: ((_c = result === null || result === void 0 ? void 0 : result.object) !== null && _c !== void 0 ? _c : {}),
+                                usage: usage,
+                                reasoning: reasoning || undefined,
+                                toolInvocations: [],
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Non-streaming convenience: generates a text response and waits for completion.
+     */
+    Conversation.prototype.generateResponse = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stream, _a, text, reasoning, sources, usage, toolInvocations;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.generateStream(params)];
+                    case 1:
+                        stream = _b.sent();
+                        return [4 /*yield*/, Promise.all([
+                                stream.text,
+                                stream.reasoning,
+                                stream.sources,
+                                stream.usage,
+                                stream.toolInvocations,
+                            ])];
+                    case 2:
+                        _a = _b.sent(), text = _a[0], reasoning = _a[1], sources = _a[2], usage = _a[3], toolInvocations = _a[4];
+                        return [2 /*return*/, { text: text, reasoning: reasoning || undefined, sources: sources, usage: usage, toolInvocations: toolInvocations }];
+                }
+            });
+        });
+    };
+    // ────────────────────────────────────────────────────────────
+    // History management (public, for callers like ThoughtConversation)
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.addSystemMessagesToHistory = function (messages, unshift) {
+        if (unshift === void 0) { unshift = false; }
+        var formatted = messages.map(function (m) { return ({ role: 'system', content: m }); });
+        this.addMessagesToHistory(formatted, unshift);
+    };
+    Conversation.prototype.addAssistantMessagesToHistory = function (messages, unshift) {
+        if (unshift === void 0) { unshift = false; }
+        var formatted = messages.map(function (m) { return ({ role: 'assistant', content: m }); });
+        this.addMessagesToHistory(formatted, unshift);
+    };
+    Conversation.prototype.addUserMessagesToHistory = function (messages, unshift) {
+        if (unshift === void 0) { unshift = false; }
+        var formatted = messages.map(function (m) { return ({ role: 'user', content: m }); });
+        this.addMessagesToHistory(formatted, unshift);
+    };
+    Conversation.prototype.addMessagesToHistory = function (messages, unshift) {
+        var _a, _b, _c;
+        if (unshift === void 0) { unshift = false; }
+        // Convert to the format MessageHistory expects (ChatCompletionMessageParam-like)
+        var historyMessages = messages.map(function (m) {
+            if (typeof m === 'string') {
+                return { role: 'user', content: m };
+            }
+            return m;
+        });
+        var systemMsgs = historyMessages.filter(function (m) { return m.role === 'system'; });
+        if (unshift) {
+            (_a = this.history.getMessages()).unshift.apply(_a, historyMessages);
+            this.history.prune();
+            (_b = this.systemMessages).unshift.apply(_b, systemMsgs);
         }
-        if ((_d = params.limits) === null || _d === void 0 ? void 0 : _d.tokenLimit) {
-            this.tokenLimit = params.limits.tokenLimit;
+        else {
+            this.history.push(historyMessages);
+            (_c = this.systemMessages).push.apply(_c, systemMsgs);
         }
-    }
+    };
+    // ────────────────────────────────────────────────────────────
+    // Module system
+    // ────────────────────────────────────────────────────────────
     Conversation.prototype.ensureModulesProcessed = function () {
         return __awaiter(this, void 0, void 0, function () {
             var error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        // If modules are already processed, return immediately
                         if (this.modulesProcessed) {
                             return [2 /*return*/];
                         }
-                        // If modules are currently being processed, wait for that to complete
                         if (this.processingModulesPromise) {
                             return [2 /*return*/, this.processingModulesPromise];
                         }
-                        // Start processing modules and keep a reference to the promise
                         this.processingModulesPromise = this.processModules();
                         _a.label = 1;
                     case 1:
@@ -127,7 +413,6 @@ var Conversation = /** @class */ (function () {
                     case 3:
                         error_1 = _a.sent();
                         this.logger.error({ message: 'Error processing modules', obj: { error: error_1 } });
-                        // Reset the promise so we can try again
                         this.processingModulesPromise = null;
                         throw error_1;
                     case 4: return [2 /*return*/];
@@ -137,339 +422,658 @@ var Conversation = /** @class */ (function () {
     };
     Conversation.prototype.processModules = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, module_1, moduleSystemMessagesResult, moduleSystemMessages, formattedSystemMessages;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _i, _a, module_1, moduleName, rawSystem, sysArr, trimmed, formatted, moduleFunctions, functionInstructions, hasInstructions, _b, moduleFunctions_1, f, paragraph;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         if (!this.params.modules || this.params.modules.length === 0) {
                             return [2 /*return*/];
                         }
                         _i = 0, _a = this.params.modules;
-                        _b.label = 1;
+                        _e.label = 1;
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
                         module_1 = _a[_i];
-                        moduleSystemMessagesResult = module_1.getSystemMessages();
-                        moduleSystemMessages = void 0;
-                        if (!(moduleSystemMessagesResult instanceof Promise)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, moduleSystemMessagesResult];
+                        moduleName = module_1.getName();
+                        return [4 /*yield*/, Promise.resolve(module_1.getSystemMessages())];
                     case 2:
-                        moduleSystemMessages = _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        moduleSystemMessages = moduleSystemMessagesResult;
-                        _b.label = 4;
-                    case 4:
-                        if (!moduleSystemMessages || (Array.isArray(moduleSystemMessages) && moduleSystemMessages.length < 1)) {
-                            return [3 /*break*/, 5];
+                        rawSystem = _e.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.addSystemMessagesToHistory([
+                                "The following are instructions from the ".concat(moduleName, " module:\n").concat(formatted),
+                            ]);
                         }
-                        formattedSystemMessages = Array.isArray(moduleSystemMessages)
-                            ? moduleSystemMessages.join('. ')
-                            : moduleSystemMessages;
-                        this.addSystemMessagesToHistory([
-                            "The following are instructions from the ".concat(module_1.getName(), " module:\n").concat(formattedSystemMessages),
-                        ]);
-                        this.addFunctions(module_1.getName(), module_1.getFunctions());
-                        this.addMessageModerators(module_1.getMessageModerators());
-                        _b.label = 5;
-                    case 5:
+                        moduleFunctions = module_1.getFunctions();
+                        (_c = this.functions).push.apply(_c, moduleFunctions);
+                        functionInstructions = "The following are instructions from functions in the ".concat(moduleName, " module:");
+                        hasInstructions = false;
+                        for (_b = 0, moduleFunctions_1 = moduleFunctions; _b < moduleFunctions_1.length; _b++) {
+                            f = moduleFunctions_1[_b];
+                            if (f.instructions && f.instructions.length > 0) {
+                                hasInstructions = true;
+                                paragraph = f.instructions.join('. ');
+                                functionInstructions += " ".concat(f.definition.name, ": ").concat(paragraph, ".");
+                            }
+                        }
+                        if (hasInstructions) {
+                            this.addSystemMessagesToHistory([functionInstructions]);
+                        }
+                        // Message moderators
+                        (_d = this.messageModerators).push.apply(_d, module_1.getMessageModerators());
+                        _e.label = 3;
+                    case 3:
                         _i++;
                         return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
     };
-    Conversation.prototype.addFunctions = function (moduleName, functions) {
-        var _a;
-        (_a = this.functions).push.apply(_a, functions);
-        var functionInstructions = "The following are instructions from functions in the ".concat(moduleName, " module:");
-        var functionInstructionsAdded = false;
-        for (var _i = 0, functions_1 = functions; _i < functions_1.length; _i++) {
-            var f = functions_1[_i];
-            if (f.instructions) {
-                if (!f.instructions || f.instructions.length < 1) {
-                    continue;
+    // ────────────────────────────────────────────────────────────
+    // AI SDK message building
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.buildAiSdkMessages = function (callMessages) {
+        var _a, _b;
+        var result = [];
+        // Add history messages
+        for (var _i = 0, _c = this.history.getMessages(); _i < _c.length; _i++) {
+            var msg = _c[_i];
+            var m = msg;
+            var rawRole = String((_a = m.role) !== null && _a !== void 0 ? _a : 'user');
+            // Map non-standard roles to the closest AI SDK role
+            var role = (rawRole === 'system' ? 'system' : rawRole === 'assistant' ? 'assistant' : 'user');
+            var content = typeof m.content === 'string' ? m.content : this.extractTextFromContent(m.content);
+            if (content.trim()) {
+                result.push({ role: role, content: content });
+            }
+        }
+        // Add call messages
+        for (var _d = 0, callMessages_1 = callMessages; _d < callMessages_1.length; _d++) {
+            var msg = callMessages_1[_d];
+            if (typeof msg === 'string') {
+                result.push({ role: 'user', content: msg });
+            }
+            else {
+                var rawRole = String((_b = msg.role) !== null && _b !== void 0 ? _b : 'user');
+                var role = (rawRole === 'system' ? 'system' : rawRole === 'assistant' ? 'assistant' : 'user');
+                result.push({ role: role, content: typeof msg.content === 'string' ? msg.content : '' });
+            }
+        }
+        return result;
+    };
+    Conversation.prototype.extractTextFromContent = function (content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .map(function (p) {
+                if (typeof p === 'string') {
+                    return p;
                 }
-                functionInstructionsAdded = true;
-                var instructionsParagraph = f.instructions.join('. ');
-                functionInstructions += " ".concat(f.definition.name, ": ").concat(instructionsParagraph, ".");
+                if ((p === null || p === void 0 ? void 0 : p.type) === 'text') {
+                    return p.text;
+                }
+                return '';
+            })
+                .join('\n');
+        }
+        return '';
+    };
+    // ────────────────────────────────────────────────────────────
+    // AI SDK tool building
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.buildAiSdkTools = function (functions) {
+        var _this = this;
+        var tools = {};
+        var _loop_1 = function (f) {
+            var def = f.definition;
+            if (!(def === null || def === void 0 ? void 0 : def.name)) {
+                return "continue";
             }
+            tools[def.name] = {
+                description: def.description,
+                inputSchema: (0, ai_1.jsonSchema)(this_1.normalizeToolParameters(def.parameters)),
+                execute: function (args) { return __awaiter(_this, void 0, void 0, function () {
+                    var result;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, f.call(args)];
+                            case 1:
+                                result = _a.sent();
+                                if (typeof result === 'undefined') {
+                                    return [2 /*return*/, { result: 'Function executed successfully' }];
+                                }
+                                return [2 /*return*/, result];
+                        }
+                    });
+                }); },
+            };
+        };
+        var this_1 = this;
+        for (var _i = 0, functions_1 = functions; _i < functions_1.length; _i++) {
+            var f = functions_1[_i];
+            _loop_1(f);
+        }
+        return tools;
+    };
+    /**
+     * Normalize tool parameter schemas to ensure they are valid JSON Schema
+     * with `type: "object"`. Handles missing, null, or invalid schemas
+     * (e.g. `type: "None"` which some functions produce).
+     */
+    Conversation.prototype.normalizeToolParameters = function (parameters) {
+        var emptySchema = { type: 'object', properties: {} };
+        if (!parameters || typeof parameters !== 'object') {
+            return emptySchema;
         }
-        if (!functionInstructionsAdded) {
-            return;
+        // If type is missing, not a string, or not a valid JSON Schema type, default to object
+        var validTypes = ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'];
+        if (!parameters.type ||
+            typeof parameters.type !== 'string' ||
+            !validTypes.includes(parameters.type.toLowerCase())) {
+            return __assign(__assign(__assign({}, emptySchema), parameters), { type: 'object' });
         }
-        this.addSystemMessagesToHistory([functionInstructions]);
+        return parameters;
     };
-    Conversation.prototype.addMessageModerators = function (messageModerators) {
+    // ────────────────────────────────────────────────────────────
+    // Provider options
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.buildProviderOptions = function (provider, params, modelString) {
         var _a;
-        (_a = this.messageModerators).push.apply(_a, messageModerators);
+        var options = {};
+        var effort = params.reasoningEffort;
+        if (provider === 'openai') {
+            var openaiOpts = {};
+            if (effort) {
+                // OpenAI accepts: none | low | medium | high | xhigh
+                // 'max' → 'xhigh' (OpenAI's highest)
+                openaiOpts.reasoningEffort = effort === 'max' ? 'xhigh' : effort;
+            }
+            if (params.serviceTier) {
+                openaiOpts.serviceTier = params.serviceTier;
+            }
+            options.openai = openaiOpts;
+        }
+        if (provider === 'anthropic') {
+            var anthropicOpts = {};
+            if (effort && effort !== 'none') {
+                // Use adaptive thinking (Sonnet 4.6+, Opus 4.6+) with effort level.
+                // Anthropic accepts effort: low | medium | high | max
+                // 'xhigh' has no Anthropic equivalent → map to 'max'
+                anthropicOpts.thinking = { type: 'adaptive' };
+                anthropicOpts.effort = effort === 'xhigh' ? 'max' : effort;
+            }
+            options.anthropic = anthropicOpts;
+        }
+        if (provider === 'google') {
+            var googleOpts = {};
+            if (effort && effort !== 'none') {
+                // Google accepts thinkingLevel: minimal | low | medium | high
+                // Our 'max'/'xhigh' have no Google equivalent → map to 'high'
+                var levelMap = {
+                    low: 'low',
+                    medium: 'medium',
+                    high: 'high',
+                    xhigh: 'high',
+                    max: 'high',
+                };
+                googleOpts.thinkingConfig = {
+                    thinkingLevel: (_a = levelMap[effort]) !== null && _a !== void 0 ? _a : 'medium',
+                };
+            }
+            options.google = googleOpts;
+        }
+        if (provider === 'xai') {
+            var xaiOpts = {};
+            // Only models with reasoning support accept the reasoningEffort parameter.
+            // Models like grok-4 (no "-fast" suffix) reject it with a 400 error.
+            var xaiSupportsReasoning = modelString ? /fast/i.test(modelString) : false;
+            if (effort && effort !== 'none' && xaiSupportsReasoning) {
+                // xAI accepts: low | high
+                // Map everything to the closest valid value
+                var xaiEffort = effort === 'low' ? 'low' : 'high';
+                xaiOpts.reasoningEffort = xaiEffort;
+            }
+            options.xai = xaiOpts;
+        }
+        return options;
     };
-    Conversation.prototype.enforceTokenLimit = function (messages, model) {
-        var _a;
+    // ────────────────────────────────────────────────────────────
+    // Background/polling escape hatch (OpenAI-specific)
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.shouldUseBackgroundMode = function (modelString, params) {
+        if (typeof params.backgroundMode === 'boolean') {
+            return params.backgroundMode;
+        }
+        if (this.isProModel(modelString)) {
+            return true;
+        }
+        if (this.isHighReasoningEffort(params.reasoningEffort)) {
+            return true;
+        }
+        return false;
+    };
+    Conversation.prototype.isProModel = function (model) {
+        return /(^|[-_.])pro($|[-_.])/.test(String(model !== null && model !== void 0 ? model : '').toLowerCase());
+    };
+    Conversation.prototype.isHighReasoningEffort = function (effort) {
+        return effort === 'high' || effort === 'xhigh' || effort === 'max';
+    };
+    /**
+     * Map our ReasoningEffort to OpenAI's accepted values.
+     * OpenAI accepts: none | low | medium | high | xhigh
+     * 'max' → 'xhigh' (OpenAI's highest).
+     */
+    Conversation.prototype.mapReasoningEffortForOpenAi = function (effort) {
+        if (!effort) {
+            return undefined;
+        }
+        if (effort === 'max') {
+            return 'xhigh';
+        }
+        return effort;
+    };
+    /**
+     * Fall back to OpenAiResponses for background/polling mode.
+     * Returns a StreamResult where the text arrives as a single chunk after polling completes.
+     */
+    Conversation.prototype.generateStreamViaPolling = function (params, modelString) {
         return __awaiter(this, void 0, void 0, function () {
-            var resolvedModel, encoder, conversation, encoded, summarizeConversationRequest, referenceSummaryRequest;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var responses, messages, result, text, usage, toolInvocations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        if (!((_a = this.params.limits) === null || _a === void 0 ? void 0 : _a.enforceLimits)) {
-                            return [2 /*return*/];
-                        }
-                        resolvedModel = model ? model : OpenAi_1.DEFAULT_MODEL;
-                        encoder = (0, tiktoken_1.encoding_for_model)(resolvedModel);
-                        conversation = this.history.toString() +
-                            messages
-                                .map(function (message) {
-                                if (typeof message === 'string') {
-                                    return message;
-                                }
-                                else {
-                                    // Extract content from ChatCompletionMessageParam
-                                    var contentParts = Array.isArray(message.content) ? message.content : [message.content];
-                                    return contentParts
-                                        .map(function (part) {
-                                        if (typeof part === 'string') {
-                                            return part;
-                                        }
-                                        else if ((part === null || part === void 0 ? void 0 : part.type) === 'text') {
-                                            return part.text;
-                                        }
-                                        else {
-                                            return ''; // Handle non-text content types as empty string
-                                        }
-                                    })
-                                        .join(' ');
-                                }
-                            })
-                                .join('. ');
-                        encoded = encoder.encode(conversation);
-                        console.log("current tokens: ".concat(encoded.length));
-                        if (encoded.length < this.tokenLimit) {
-                            return [2 /*return*/];
-                        }
-                        summarizeConversationRequest = "First, call the ".concat(exports.summarizeConversationHistoryFunctionName, " function");
-                        return [4 /*yield*/, new OpenAi_1.OpenAi({
-                                history: this.history,
-                                functions: this.functions,
-                                messageModerators: this.messageModerators,
-                                logLevel: this.params.logLevel,
-                            }).generateResponse({ messages: [summarizeConversationRequest], model: model })];
+                        responses = this.createOpenAiResponses(params);
+                        messages = this.convertToOpenAiMessages(params.messages);
+                        return [4 /*yield*/, responses.generateText({
+                                messages: messages,
+                                model: modelString,
+                                abortSignal: params.abortSignal,
+                                onToolInvocation: params.onToolInvocation,
+                                onUsageData: params.onUsageData,
+                                reasoningEffort: this.mapReasoningEffortForOpenAi(params.reasoningEffort),
+                                maxToolCalls: params.maxToolCalls,
+                                backgroundMode: params.backgroundMode,
+                                maxBackgroundWaitMs: params.maxBackgroundWaitMs,
+                                serviceTier: params.serviceTier,
+                            })];
                     case 1:
-                        _b.sent();
-                        referenceSummaryRequest = "If there's a file mentioned in the conversation summary, find and read the file to better respond to my next request. If that doesn't find anything, call the ".concat(PackageFunctions_1.searchLibrariesFunctionName, " function on other keywords in the conversation summary to find a file to read");
-                        return [4 /*yield*/, new OpenAi_1.OpenAi({
-                                history: this.history,
-                                functions: this.functions,
-                                messageModerators: this.messageModerators,
-                                logLevel: this.params.logLevel,
-                            }).generateResponse({ messages: [referenceSummaryRequest], model: model })];
-                    case 2:
-                        _b.sent();
-                        return [2 /*return*/];
+                        result = _a.sent();
+                        text = result.message;
+                        usage = result.usagedata;
+                        toolInvocations = result.toolInvocations;
+                        return [2 /*return*/, {
+                                textStream: (function () {
+                                    return __asyncGenerator(this, arguments, function () {
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, __await(text)];
+                                                case 1: return [4 /*yield*/, _a.sent()];
+                                                case 2:
+                                                    _a.sent();
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    });
+                                })(),
+                                reasoningStream: (function () {
+                                    return __asyncGenerator(this, arguments, function () {
+                                        return __generator(this, function (_a) {
+                                            return [2 /*return*/];
+                                        });
+                                    });
+                                })(),
+                                fullStream: (function () {
+                                    return __asyncGenerator(this, arguments, function () {
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, __await({ type: 'text-delta', textDelta: text })];
+                                                case 1: return [4 /*yield*/, _a.sent()];
+                                                case 2:
+                                                    _a.sent();
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    });
+                                })(),
+                                text: Promise.resolve(text),
+                                reasoning: Promise.resolve(''),
+                                sources: Promise.resolve([]),
+                                usage: Promise.resolve(usage),
+                                toolInvocations: Promise.resolve(toolInvocations),
+                            }];
                 }
             });
         });
     };
-    Conversation.prototype.summarizeConversationHistory = function (summary) {
-        this.clearHistory();
-        this.history.push([{ role: 'assistant', content: "Previous conversation summary: ".concat(summary) }]);
-    };
-    Conversation.prototype.clearHistory = function () {
-        this.history = new MessageHistory_1.MessageHistory();
-        this.history.push(this.systemMessages);
-    };
-    Conversation.prototype.addSystemMessagesToHistory = function (messages, unshift) {
-        if (unshift === void 0) { unshift = false; }
-        var chatCompletions = messages.map(function (message) {
-            return { role: 'system', content: message };
+    /**
+     * Fall back to OpenAiResponses for generateObject with background/polling.
+     */
+    Conversation.prototype.generateObjectViaPolling = function (params, modelString) {
+        return __awaiter(this, void 0, void 0, function () {
+            var responses, messages, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        responses = this.createOpenAiResponses(params);
+                        messages = this.convertToOpenAiMessages(params.messages);
+                        return [4 /*yield*/, responses.generateObject({
+                                messages: messages,
+                                model: modelString,
+                                schema: params.schema,
+                                abortSignal: params.abortSignal,
+                                onUsageData: params.onUsageData,
+                                reasoningEffort: this.mapReasoningEffortForOpenAi(params.reasoningEffort),
+                                temperature: params.temperature,
+                                topP: params.topP,
+                                maxTokens: params.maxTokens,
+                                backgroundMode: params.backgroundMode,
+                                maxBackgroundWaitMs: params.maxBackgroundWaitMs,
+                                serviceTier: params.serviceTier,
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                object: result.object,
+                                usage: result.usageData,
+                                reasoning: undefined,
+                                toolInvocations: [],
+                            }];
+                }
+            });
         });
-        this.addMessagesToHistory(chatCompletions, unshift);
     };
-    Conversation.prototype.addAssistantMessagesToHistory = function (messages, unshift) {
-        if (unshift === void 0) { unshift = false; }
-        var chatCompletions = messages.map(function (message) {
-            return { role: 'assistant', content: message };
+    Conversation.prototype.createOpenAiResponses = function (params) {
+        // Lazy require to avoid circular dependency and keep OpenAiResponses optional
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        var OAIResponses = require('./OpenAiResponses').OpenAiResponses;
+        return new OAIResponses({
+            modules: this.params.modules,
+            logLevel: this.params.logLevel,
+            defaultModel: this.getModelString(this.params.defaultModel),
         });
-        this.addMessagesToHistory(chatCompletions, unshift);
     };
-    Conversation.prototype.addUserMessagesToHistory = function (messages, unshift) {
-        if (unshift === void 0) { unshift = false; }
-        var chatCompletions = messages.map(function (message) {
-            return { role: 'user', content: message };
-        });
-        this.addMessagesToHistory(chatCompletions, unshift);
+    Conversation.prototype.convertToOpenAiMessages = function (messages) {
+        var result = [];
+        // Include history
+        for (var _i = 0, _a = this.history.getMessages(); _i < _a.length; _i++) {
+            var msg = _a[_i];
+            var m = msg;
+            result.push({
+                role: m.role,
+                content: typeof m.content === 'string' ? m.content : this.extractTextFromContent(m.content),
+            });
+        }
+        // Include call messages
+        for (var _b = 0, messages_1 = messages; _b < messages_1.length; _b++) {
+            var msg = messages_1[_b];
+            if (typeof msg === 'string') {
+                result.push(msg);
+            }
+            else {
+                result.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+        }
+        return result;
     };
-    Conversation.prototype.addMessagesToHistory = function (messages, unshift) {
-        var _a, _b, _c;
-        if (unshift === void 0) { unshift = false; }
-        var systemMessages = messages.filter(function (message) { return message.role === 'system'; });
-        if (unshift) {
-            (_a = this.history.getMessages()).unshift.apply(_a, messages);
-            this.history.prune();
-            (_b = this.systemMessages).unshift.apply(_b, systemMessages);
+    // ────────────────────────────────────────────────────────────
+    // Model resolution
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.resolveModelInstance = function (model) {
+        var _a;
+        var m = (_a = model !== null && model !== void 0 ? model : this.params.defaultModel) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
+        return (0, resolveModel_1.resolveModel)(m);
+    };
+    Conversation.prototype.getModelString = function (model) {
+        var _a, _b;
+        if (!model) {
+            var def = this.params.defaultModel;
+            if (!def) {
+                return DEFAULT_MODEL;
+            }
+            if (typeof def === 'string') {
+                return def;
+            }
+            return (_a = def.modelId) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
         }
-        else {
-            this.history.push(messages);
-            (_c = this.systemMessages).push.apply(_c, systemMessages);
+        if (typeof model === 'string') {
+            return model;
         }
+        return (_b = model.modelId) !== null && _b !== void 0 ? _b : 'unknown';
     };
-    Conversation.prototype.generateResponse = function (_a) {
-        var messages = _a.messages, model = _a.model, maxToolCalls = _a.maxToolCalls, rest = __rest(_a, ["messages", "model", "maxToolCalls"]);
+    // ────────────────────────────────────────────────────────────
+    // Usage processing
+    // ────────────────────────────────────────────────────────────
+    /**
+     * Build a usage promise from a streaming result.
+     * Uses `totalUsage` (accumulated across all steps in a tool-call loop)
+     * and populates tool call stats from the steps.
+     */
+    Conversation.prototype.buildUsagePromise = function (result, modelString, params) {
         return __awaiter(this, void 0, void 0, function () {
+            var _a, sdkUsage, steps, usage;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+                    case 0: return [4 /*yield*/, Promise.all([result.totalUsage, result.steps])];
                     case 1:
-                        _b.sent();
-                        return [4 /*yield*/, this.enforceTokenLimit(messages, model)];
+                        _a = _b.sent(), sdkUsage = _a[0], steps = _a[1];
+                        usage = this.mapSdkUsage(sdkUsage, modelString, steps);
+                        if (!params.onUsageData) return [3 /*break*/, 3];
+                        return [4 /*yield*/, params.onUsageData(usage)];
                     case 2:
                         _b.sent();
-                        this.logger.debug({ message: "=============== Conversation.generateResponse (start) ===============" });
-                        this.logger.debug({ message: "Message history", obj: { history: this.history.getMessages(), messages: messages } });
-                        this.logger.debug({ message: "=============== Conversation.generateResponse (end) ===============" });
-                        return [4 /*yield*/, new OpenAi_1.OpenAi(__assign({ history: this.history, functions: this.functions, messageModerators: this.messageModerators, logLevel: this.params.logLevel }, (typeof maxToolCalls !== 'undefined' ? { maxFunctionCalls: maxToolCalls } : {}))).generateResponse(__assign({ messages: messages, model: model }, rest))];
-                    case 3: return [2 /*return*/, _b.sent()];
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, usage];
                 }
             });
         });
     };
-    Conversation.prototype.generateStreamingResponse = function (_a) {
-        var messages = _a.messages, model = _a.model, maxToolCalls = _a.maxToolCalls, rest = __rest(_a, ["messages", "model", "maxToolCalls"]);
+    Conversation.prototype.buildToolInvocationsPromise = function (result) {
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
+            var steps, invocations, _i, _f, step, _loop_2, _g, _h, toolCall;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0: return [4 /*yield*/, result.steps];
                     case 1:
-                        _b.sent();
-                        return [4 /*yield*/, this.enforceTokenLimit(messages, model)];
-                    case 2:
-                        _b.sent();
-                        return [4 /*yield*/, new OpenAi_1.OpenAi(__assign({ history: this.history, functions: this.functions, messageModerators: this.messageModerators, logLevel: this.params.logLevel }, (typeof maxToolCalls !== 'undefined' ? { maxFunctionCalls: maxToolCalls } : {}))).generateStreamingResponse(__assign({ messages: messages, model: model }, rest))];
-                    case 3: return [2 /*return*/, _b.sent()];
+                        steps = _j.sent();
+                        invocations = [];
+                        for (_i = 0, _f = steps !== null && steps !== void 0 ? steps : []; _i < _f.length; _i++) {
+                            step = _f[_i];
+                            _loop_2 = function (toolCall) {
+                                invocations.push({
+                                    id: (_b = toolCall.toolCallId) !== null && _b !== void 0 ? _b : '',
+                                    name: (_c = toolCall.toolName) !== null && _c !== void 0 ? _c : '',
+                                    startedAt: new Date(),
+                                    finishedAt: new Date(),
+                                    input: toolCall.args,
+                                    ok: true,
+                                    data: (_e = ((_d = step.toolResults) !== null && _d !== void 0 ? _d : []).find(function (r) { return r.toolCallId === toolCall.toolCallId; })) === null || _e === void 0 ? void 0 : _e.result,
+                                });
+                            };
+                            for (_g = 0, _h = (_a = step.toolCalls) !== null && _a !== void 0 ? _a : []; _g < _h.length; _g++) {
+                                toolCall = _h[_g];
+                                _loop_2(toolCall);
+                            }
+                        }
+                        return [2 /*return*/, invocations];
                 }
             });
         });
     };
     /**
-     * Generate a validated JSON object (no tools in this run).
-     * Uses AI SDK `generateObject` which leverages provider-native structured outputs when available.
+     * Map AI SDK's `LanguageModelUsage` to our `UsageData`.
+     *
+     * The AI SDK v6 provides cached/reasoning token breakdowns directly in
+     * `LanguageModelUsage.inputTokenDetails` and `outputTokenDetails`, so we
+     * use those first and only fall back to provider metadata for older providers.
      */
-    Conversation.prototype.generateObject = function (_a) {
-        var _b;
-        var messages = _a.messages, model = _a.model, abortSignal = _a.abortSignal, schema = _a.schema, temperature = _a.temperature, topP = _a.topP, maxTokens = _a.maxTokens, onUsageData = _a.onUsageData, _c = _a.recordInHistory, recordInHistory = _c === void 0 ? true : _c, reasoningEffort = _a.reasoningEffort;
-        return __awaiter(this, void 0, void 0, function () {
-            var combined, isZod, normalizedSchema, result, chatCompletions, toRecord, usageData;
-            var _this = this;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
-                    case 1:
-                        _d.sent();
-                        combined = __spreadArray(__spreadArray([], this.toModelMessages(this.history.getMessages()), true), this.toModelMessages(messages), true);
-                        isZod = schema &&
-                            (typeof schema.safeParse === 'function' ||
-                                (!!schema._def && typeof schema._def.typeName === 'string'));
-                        normalizedSchema = isZod ? schema : (0, ai_1.jsonSchema)(this.strictifyJsonSchema(schema));
-                        this.logger.debug({ message: "=============== Conversation.generateObject (start) ===============" });
-                        this.logger.debug({ message: "Message history", obj: { messages: combined } });
-                        this.logger.debug({ message: "=============== Conversation.generateObject (end) ===============" });
-                        return [4 /*yield*/, (0, ai_1.generateObject)({
-                                model: model,
-                                abortSignal: abortSignal,
-                                messages: combined,
-                                schema: normalizedSchema,
-                                providerOptions: {
-                                    openai: {
-                                        strictJsonSchema: true,
-                                        reasoningEffort: reasoningEffort,
-                                    },
-                                },
-                                maxOutputTokens: maxTokens,
-                                temperature: temperature,
-                                topP: topP,
-                                experimental_repairText: function (_a) {
-                                    var text = _a.text;
-                                    return __awaiter(_this, void 0, void 0, function () {
-                                        var cleaned;
-                                        return __generator(this, function (_b) {
-                                            cleaned = String(text !== null && text !== void 0 ? text : '')
-                                                .trim()
-                                                .replace(/^```(?:json)?/i, '')
-                                                .replace(/```$/, '');
-                                            try {
-                                                JSON.parse(cleaned);
-                                                return [2 /*return*/, cleaned];
-                                            }
-                                            catch (_c) {
-                                                return [2 /*return*/, null];
-                                            }
-                                            return [2 /*return*/];
-                                        });
-                                    });
-                                },
-                            })];
-                    case 2:
-                        result = _d.sent();
-                        chatCompletions = messages.map(function (m) {
-                            return typeof m === 'string' ? { role: 'user', content: m } : m;
-                        });
-                        this.addMessagesToHistory(chatCompletions);
-                        // Optionally persist the final JSON in history
-                        if (recordInHistory) {
-                            try {
-                                toRecord = typeof (result === null || result === void 0 ? void 0 : result.object) === 'object' ? JSON.stringify(result.object) : '';
-                                if (toRecord) {
-                                    this.addAssistantMessagesToHistory([toRecord]);
-                                }
-                            }
-                            catch (_e) {
-                                /* ignore */
-                            }
+    Conversation.prototype.mapSdkUsage = function (sdkUsage, modelString, steps) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var inputTokens = (_a = sdkUsage === null || sdkUsage === void 0 ? void 0 : sdkUsage.inputTokens) !== null && _a !== void 0 ? _a : 0;
+        var outputTokens = (_b = sdkUsage === null || sdkUsage === void 0 ? void 0 : sdkUsage.outputTokens) !== null && _b !== void 0 ? _b : 0;
+        var totalTokens = (_c = sdkUsage === null || sdkUsage === void 0 ? void 0 : sdkUsage.totalTokens) !== null && _c !== void 0 ? _c : inputTokens + outputTokens;
+        // AI SDK v6 provides structured token details
+        var cachedInputTokens = (_e = (_d = sdkUsage === null || sdkUsage === void 0 ? void 0 : sdkUsage.inputTokenDetails) === null || _d === void 0 ? void 0 : _d.cacheReadTokens) !== null && _e !== void 0 ? _e : 0;
+        var reasoningTokens = (_g = (_f = sdkUsage === null || sdkUsage === void 0 ? void 0 : sdkUsage.outputTokenDetails) === null || _f === void 0 ? void 0 : _f.reasoningTokens) !== null && _g !== void 0 ? _g : 0;
+        var tokenUsage = {
+            inputTokens: inputTokens,
+            cachedInputTokens: cachedInputTokens,
+            reasoningTokens: reasoningTokens,
+            outputTokens: outputTokens,
+            totalTokens: totalTokens,
+        };
+        // Count steps as individual requests to the assistant
+        var stepCount = (_h = steps === null || steps === void 0 ? void 0 : steps.length) !== null && _h !== void 0 ? _h : 1;
+        var acc = new UsageData_1.UsageDataAccumulator({ model: modelString });
+        acc.addTokenUsage(tokenUsage);
+        // Populate tool call stats from steps
+        var callsPerTool = {};
+        var totalToolCalls = 0;
+        for (var _i = 0, _m = steps !== null && steps !== void 0 ? steps : []; _i < _m.length; _i++) {
+            var step = _m[_i];
+            for (var _o = 0, _p = (_j = step.toolCalls) !== null && _j !== void 0 ? _j : []; _o < _p.length; _o++) {
+                var toolCall = _p[_o];
+                var name_1 = (_k = toolCall.toolName) !== null && _k !== void 0 ? _k : 'unknown';
+                callsPerTool[name_1] = ((_l = callsPerTool[name_1]) !== null && _l !== void 0 ? _l : 0) + 1;
+                totalToolCalls++;
+            }
+        }
+        return __assign(__assign({}, acc.usageData), { totalRequestsToAssistant: stepCount, callsPerTool: callsPerTool, totalToolCalls: totalToolCalls });
+    };
+    /**
+     * Process usage from a generateObject result (single-step, no tool calls).
+     */
+    Conversation.prototype.processAiSdkUsage = function (result, modelString) {
+        return this.mapSdkUsage(result.usage, modelString);
+    };
+    // ────────────────────────────────────────────────────────────
+    // Full stream mapping
+    // ────────────────────────────────────────────────────────────
+    /**
+     * Maps the AI SDK's `fullStream` (which emits all event types) into our
+     * `StreamPart` union. This is the primary way to consume streaming output
+     * in real-time, since it yields text, reasoning, and source events in the
+     * order the model produces them.
+     */
+    Conversation.prototype.mapFullStream = function (aiSdkFullStream) {
+        var _a;
+        return _a = {},
+            _a[Symbol.asyncIterator] = function () {
+                return __asyncGenerator(this, arguments, function _a() {
+                    var _b, aiSdkFullStream_1, aiSdkFullStream_1_1, part, e_1_1;
+                    var _c, e_1, _d, _e;
+                    return __generator(this, function (_f) {
+                        switch (_f.label) {
+                            case 0:
+                                _f.trys.push([0, 13, 14, 19]);
+                                _b = true, aiSdkFullStream_1 = __asyncValues(aiSdkFullStream);
+                                _f.label = 1;
+                            case 1: return [4 /*yield*/, __await(aiSdkFullStream_1.next())];
+                            case 2:
+                                if (!(aiSdkFullStream_1_1 = _f.sent(), _c = aiSdkFullStream_1_1.done, !_c)) return [3 /*break*/, 12];
+                                _e = aiSdkFullStream_1_1.value;
+                                _b = false;
+                                part = _e;
+                                if (!(part.type === 'text-delta' && part.textDelta)) return [3 /*break*/, 5];
+                                return [4 /*yield*/, __await({ type: 'text-delta', textDelta: part.textDelta })];
+                            case 3: return [4 /*yield*/, _f.sent()];
+                            case 4:
+                                _f.sent();
+                                return [3 /*break*/, 11];
+                            case 5:
+                                if (!(part.type === 'reasoning' && part.textDelta)) return [3 /*break*/, 8];
+                                return [4 /*yield*/, __await({ type: 'reasoning-delta', textDelta: part.textDelta })];
+                            case 6: return [4 /*yield*/, _f.sent()];
+                            case 7:
+                                _f.sent();
+                                return [3 /*break*/, 11];
+                            case 8:
+                                if (!(part.type === 'source')) return [3 /*break*/, 11];
+                                return [4 /*yield*/, __await({
+                                        type: 'source',
+                                        source: {
+                                            url: part.sourceType === 'url' ? part.url : undefined,
+                                            title: part.sourceType === 'url' ? part.title : undefined,
+                                        },
+                                    })];
+                            case 9: return [4 /*yield*/, _f.sent()];
+                            case 10:
+                                _f.sent();
+                                _f.label = 11;
+                            case 11:
+                                _b = true;
+                                return [3 /*break*/, 1];
+                            case 12: return [3 /*break*/, 19];
+                            case 13:
+                                e_1_1 = _f.sent();
+                                e_1 = { error: e_1_1 };
+                                return [3 /*break*/, 19];
+                            case 14:
+                                _f.trys.push([14, , 17, 18]);
+                                if (!(!_b && !_c && (_d = aiSdkFullStream_1.return))) return [3 /*break*/, 16];
+                                return [4 /*yield*/, __await(_d.call(aiSdkFullStream_1))];
+                            case 15:
+                                _f.sent();
+                                _f.label = 16;
+                            case 16: return [3 /*break*/, 18];
+                            case 17:
+                                if (e_1) throw e_1.error;
+                                return [7 /*endfinally*/];
+                            case 18: return [7 /*endfinally*/];
+                            case 19: return [2 /*return*/];
                         }
-                        usageData = this.processUsageData({
-                            result: result,
-                            model: model,
-                        });
-                        if (!onUsageData) return [3 /*break*/, 4];
-                        return [4 /*yield*/, onUsageData(usageData)];
-                    case 3:
-                        _d.sent();
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, {
-                            object: ((_b = result === null || result === void 0 ? void 0 : result.object) !== null && _b !== void 0 ? _b : {}),
-                            usageData: usageData,
-                        }];
-                }
-            });
-        });
+                    });
+                });
+            },
+            _a;
     };
-    /** Convert (string | ChatCompletionMessageParam)[] -> AI SDK ModelMessage[] */
-    Conversation.prototype.toModelMessages = function (input) {
-        return input.map(function (m) {
-            var _a;
-            if (typeof m === 'string') {
-                return { role: 'user', content: m };
+    Conversation.prototype.extractReasoningFromResult = function (result) {
+        try {
+            // Try to get reasoning from provider metadata or response
+            var reasoning = result === null || result === void 0 ? void 0 : result.reasoning;
+            if (typeof reasoning === 'string') {
+                return reasoning;
             }
-            var text = Array.isArray(m.content)
-                ? m.content.map(function (p) { var _a; return (typeof p === 'string' ? p : (_a = p === null || p === void 0 ? void 0 : p.text) !== null && _a !== void 0 ? _a : ''); }).join('\n')
-                : (_a = m.content) !== null && _a !== void 0 ? _a : '';
-            var role = m.role === 'system' || m.role === 'user' || m.role === 'assistant' ? m.role : 'user';
-            return { role: role, content: text };
-        });
+            if (Array.isArray(reasoning)) {
+                return reasoning
+                    .filter(function (r) { return r.type === 'reasoning'; })
+                    .map(function (r) { return r.text; })
+                    .join('');
+            }
+        }
+        catch (_a) {
+            // ignore
+        }
+        return '';
+    };
+    // ────────────────────────────────────────────────────────────
+    // Schema utilities
+    // ────────────────────────────────────────────────────────────
+    Conversation.prototype.isZodSchema = function (schema) {
+        if (!schema || (typeof schema !== 'object' && typeof schema !== 'function')) {
+            return false;
+        }
+        return (typeof schema.safeParse === 'function' ||
+            (!!schema._def && typeof schema._def.typeName === 'string'));
     };
     /**
-     * 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
+     * Strictifies a JSON Schema for OpenAI Structured Outputs (strict mode).
      */
     Conversation.prototype.strictifyJsonSchema = function (schema) {
-        var root = JSON.parse(JSON.stringify(schema));
+        var root = JSON.parse(JSON.stringify(schema !== null && schema !== void 0 ? schema : {}));
         var visit = function (node) {
             if (!node || typeof node !== 'object') {
                 return;
             }
-            // If keywords imply a type but it's missing, add it (helps downstream validators)
             if (!node.type) {
                 if (node.properties || node.additionalProperties || node.patternProperties) {
                     node.type = 'object';
@@ -479,32 +1083,25 @@ var Conversation = /** @class */ (function () {
                 }
             }
             var types = Array.isArray(node.type) ? node.type : node.type ? [node.type] : [];
-            // Objects: enforce strict requirements
             if (types.includes('object')) {
-                // 1) additionalProperties: false
                 if (node.additionalProperties !== false) {
                     node.additionalProperties = false;
                 }
-                // 2) required must exist and include every key in properties
                 if (node.properties && typeof node.properties === 'object') {
                     var propKeys = Object.keys(node.properties);
                     var currentReq = Array.isArray(node.required) ? node.required.slice() : [];
-                    var union = Array.from(new Set(__spreadArray(__spreadArray([], currentReq, true), propKeys, true)));
-                    node.required = union;
-                    // Recurse into each property schema
+                    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]);
                     }
                 }
-                // Recurse into patternProperties
                 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]);
                     }
                 }
-                // Recurse into $defs / definitions
                 for (var _c = 0, _d = ['$defs', 'definitions']; _c < _d.length; _c++) {
                     var defsKey = _d[_c];
                     if (node[defsKey] && typeof node[defsKey] === 'object') {
@@ -515,7 +1112,6 @@ var Conversation = /** @class */ (function () {
                     }
                 }
             }
-            // Arrays: recurse into items/prefixItems
             if (types.includes('array')) {
                 if (node.items) {
                     if (Array.isArray(node.items)) {
@@ -529,14 +1125,12 @@ var Conversation = /** @class */ (function () {
                     node.prefixItems.forEach(visit);
                 }
             }
-            // Combinators
             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);
                 }
             }
-            // Negation
             if (node.not) {
                 visit(node.not);
             }
@@ -544,200 +1138,7 @@ var Conversation = /** @class */ (function () {
         visit(root);
         return root;
     };
-    // ---- Usage + provider metadata normalization ----
-    Conversation.prototype.processUsageData = function (args) {
-        var _a, _b;
-        var result = args.result, model = args.model, toolCounts = args.toolCounts, toolLedgerLen = args.toolLedgerLen;
-        var u = result === null || result === void 0 ? void 0 : result.usage;
-        // Provider-specific extras (OpenAI Responses variants)
-        var _c = (_b = (_a = this.extractOpenAiUsageDetails) === null || _a === void 0 ? void 0 : _a.call(this, result)) !== null && _b !== void 0 ? _b : {}, cachedInputTokens = _c.cachedInputTokens, reasoningTokens = _c.reasoningTokens;
-        var input = Number.isFinite(u === null || u === void 0 ? void 0 : u.inputTokens) ? Number(u.inputTokens) : 0;
-        var reasoning = Number.isFinite(reasoningTokens) ? Number(reasoningTokens) : 0;
-        var output = Number.isFinite(u === null || u === void 0 ? void 0 : u.outputTokens) ? Number(u.outputTokens) : 0;
-        var total = Number.isFinite(u === null || u === void 0 ? void 0 : u.totalTokens) ? Number(u.totalTokens) : input + output;
-        var cached = Number.isFinite(cachedInputTokens) ? Number(cachedInputTokens) : 0;
-        // Resolve model id for pricing/telemetry
-        var modelId = model === null || model === void 0 ? void 0 : model.toString();
-        var resolvedModel = typeof modelId === 'string' && modelId.trim().length > 0 ? modelId : 'unknown';
-        var tokenUsage = {
-            inputTokens: input,
-            reasoningTokens: reasoning,
-            cachedInputTokens: cached,
-            outputTokens: output,
-            totalTokens: total,
-        };
-        var uda = new UsageData_1.UsageDataAccumulator({ model: modelId });
-        uda.addTokenUsage(tokenUsage);
-        var callsPerTool = toolCounts ? Object.fromEntries(toolCounts) : {};
-        var totalToolCalls = typeof toolLedgerLen === 'number' ? toolLedgerLen : Object.values(callsPerTool).reduce(function (a, b) { return a + (b || 0); }, 0);
-        return __assign(__assign({}, uda.usageData), { totalRequestsToAssistant: 1, totalToolCalls: totalToolCalls, callsPerTool: callsPerTool });
-    };
-    // Pull OpenAI-specific cached/extra usage from provider metadata or raw usage.
-    // Safe across providers; returns undefined if not available.
-    Conversation.prototype.extractOpenAiUsageDetails = function (result) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-        try {
-            var md = (_b = (_a = result === null || result === void 0 ? void 0 : result.providerMetadata) === null || _a === void 0 ? void 0 : _a.openai) !== null && _b !== void 0 ? _b : (_d = (_c = result === null || result === void 0 ? void 0 : result.response) === null || _c === void 0 ? void 0 : _c.providerMetadata) === null || _d === void 0 ? void 0 : _d.openai;
-            var usage = (_g = (_e = md === null || md === void 0 ? void 0 : md.usage) !== null && _e !== void 0 ? _e : (_f = result === null || result === void 0 ? void 0 : result.response) === null || _f === void 0 ? void 0 : _f.usage) !== null && _g !== void 0 ? _g : result === null || result === void 0 ? void 0 : result.usage;
-            // OpenAI Responses API has used different shapes over time; try both:
-            var cachedInputTokens = (_l = (_j = (_h = usage === null || usage === void 0 ? void 0 : usage.input_tokens_details) === null || _h === void 0 ? void 0 : _h.cached_tokens) !== null && _j !== void 0 ? _j : (_k = usage === null || usage === void 0 ? void 0 : usage.prompt_tokens_details) === null || _k === void 0 ? void 0 : _k.cached_tokens) !== null && _l !== void 0 ? _l : usage === null || usage === void 0 ? void 0 : usage.cached_input_tokens;
-            // Reasoning tokens (when available on reasoning models)
-            var reasoningTokens = (_q = (_o = (_m = usage === null || usage === void 0 ? void 0 : usage.output_tokens_details) === null || _m === void 0 ? void 0 : _m.reasoning_tokens) !== null && _o !== void 0 ? _o : (_p = usage === null || usage === void 0 ? void 0 : usage.completion_tokens_details) === null || _p === void 0 ? void 0 : _p.reasoning_tokens) !== null && _q !== void 0 ? _q : usage === null || usage === void 0 ? void 0 : usage.reasoning_tokens;
-            return {
-                cachedInputTokens: typeof cachedInputTokens === 'number' ? cachedInputTokens : undefined,
-                reasoningTokens: typeof reasoningTokens === 'number' ? reasoningTokens : undefined,
-            };
-        }
-        catch (_r) {
-            return {};
-        }
-    };
-    Conversation.prototype.generateCode = function (_a) {
-        var description = _a.description, model = _a.model;
-        return __awaiter(this, void 0, void 0, function () {
-            var code;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.logger.debug({ message: "Generating code", obj: { description: description } });
-                        return [4 /*yield*/, this.ensureModulesProcessed()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, new OpenAi_1.OpenAi({
-                                history: this.history,
-                                functions: this.functions,
-                                messageModerators: this.messageModerators,
-                                logLevel: this.params.logLevel,
-                            }).generateCode({
-                                messages: description,
-                                model: model,
-                                includeSystemMessages: !this.generatedCode,
-                            })];
-                    case 2:
-                        code = _b.sent();
-                        this.logger.debug({ message: "Generated code", obj: { code: code } });
-                        this.generatedCode = true;
-                        return [2 /*return*/, code];
-                }
-            });
-        });
-    };
-    Conversation.prototype.updateCodeFromFile = function (_a) {
-        var codeToUpdateFilePath = _a.codeToUpdateFilePath, dependencyCodeFilePaths = _a.dependencyCodeFilePaths, description = _a.description, model = _a.model;
-        return __awaiter(this, void 0, void 0, function () {
-            var codeToUpdate, dependencyDescription, _i, dependencyCodeFilePaths_1, dependencyCodeFilePath, dependencCode;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, util_node_1.Fs.readFile(codeToUpdateFilePath)];
-                    case 2:
-                        codeToUpdate = _b.sent();
-                        dependencyDescription = "Assume the following exists:\n";
-                        _i = 0, dependencyCodeFilePaths_1 = dependencyCodeFilePaths;
-                        _b.label = 3;
-                    case 3:
-                        if (!(_i < dependencyCodeFilePaths_1.length)) return [3 /*break*/, 6];
-                        dependencyCodeFilePath = dependencyCodeFilePaths_1[_i];
-                        return [4 /*yield*/, util_node_1.Fs.readFile(dependencyCodeFilePath)];
-                    case 4:
-                        dependencCode = _b.sent();
-                        dependencyDescription += dependencCode + '\n\n';
-                        _b.label = 5;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 3];
-                    case 6:
-                        this.logger.debug({ message: "Updating code from file", obj: { codeToUpdateFilePath: codeToUpdateFilePath } });
-                        return [4 /*yield*/, this.updateCode({ code: codeToUpdate, description: dependencyDescription + description, model: model })];
-                    case 7: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    Conversation.prototype.updateCode = function (_a) {
-        var code = _a.code, description = _a.description, model = _a.model;
-        return __awaiter(this, void 0, void 0, function () {
-            var updatedCode;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.logger.debug({ message: "Updating code", obj: { description: description, code: code } });
-                        return [4 /*yield*/, this.ensureModulesProcessed()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, new OpenAi_1.OpenAi({
-                                history: this.history,
-                                functions: this.functions,
-                                messageModerators: this.messageModerators,
-                                logLevel: this.params.logLevel,
-                            }).updateCode({
-                                code: code,
-                                description: description,
-                                model: model,
-                                includeSystemMessages: !this.generatedCode,
-                            })];
-                    case 2:
-                        updatedCode = _b.sent();
-                        this.logger.debug({ message: "Updated code", obj: { updatedCode: updatedCode } });
-                        this.generatedCode = true;
-                        return [2 /*return*/, updatedCode];
-                }
-            });
-        });
-    };
-    Conversation.prototype.generateList = function (_a) {
-        var description = _a.description, model = _a.model;
-        return __awaiter(this, void 0, void 0, function () {
-            var list;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.ensureModulesProcessed()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, new OpenAi_1.OpenAi({
-                                history: this.history,
-                                functions: this.functions,
-                                messageModerators: this.messageModerators,
-                                logLevel: this.params.logLevel,
-                            }).generateList({
-                                messages: description,
-                                model: model,
-                                includeSystemMessages: !this.generatedList,
-                            })];
-                    case 2:
-                        list = _b.sent();
-                        this.generatedList = true;
-                        return [2 /*return*/, list];
-                }
-            });
-        });
-    };
     return Conversation;
 }());
 exports.Conversation = Conversation;
-exports.summarizeConversationHistoryFunctionName = 'summarizeConversationHistory';
-var summarizeConversationHistoryFunction = function (conversation) {
-    return {
-        definition: {
-            name: exports.summarizeConversationHistoryFunctionName,
-            description: 'Clear the conversation history and summarize what was in it',
-            parameters: {
-                type: 'object',
-                properties: {
-                    summary: {
-                        type: 'string',
-                        description: 'A 1-3 sentence summary of the current chat history',
-                    },
-                },
-                required: ['summary'],
-            },
-        },
-        call: function (params) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, conversation.summarizeConversationHistory(params.summary)];
-        }); }); },
-    };
-};
-exports.summarizeConversationHistoryFunction = summarizeConversationHistoryFunction;
 //# sourceMappingURL=Conversation.js.map