@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/dist/src/ai/AgentRunner.js

@@ -0,0 +1,760 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+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 __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 = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    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 __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.AgentRunner = void 0;
+var uuid_1 = require("uuid");
+var FlinkLogFactory_1 = require("../FlinkLogFactory");
+var FlinkLog_1 = require("../FlinkLog");
+var observerLog = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.ai.observer");
+var AgentRunner = /** @class */ (function () {
+    function AgentRunner(agentProps, tools, llmAdapters, agentName, // Optional agent name for logging
+    ctx, // FlinkContext for instruction callbacks (any for flexibility)
+    observer) {
+        var _a, _b, _c, _d, _e;
+        this.agentProps = agentProps;
+        this.tools = tools;
+        this.agentName = agentName;
+        this.ctx = ctx;
+        this.observer = observer;
+        // Get appropriate LLM adapter based on adapterId
+        var adapterId = ((_a = agentProps.model) === null || _a === void 0 ? void 0 : _a.adapterId) || "default";
+        var adapter = llmAdapters.get(adapterId);
+        if (!adapter) {
+            throw new Error("LLM adapter \"".concat(adapterId, "\" not configured - register it in FlinkOptions.ai.llms"));
+        }
+        this.llmAdapter = adapter;
+        this.maxTokens = ((_b = agentProps.model) === null || _b === void 0 ? void 0 : _b.maxTokens) || 4096;
+        this.temperature = ((_c = agentProps.model) === null || _c === void 0 ? void 0 : _c.temperature) || 0.7;
+        this.maxSteps = ((_d = agentProps.limits) === null || _d === void 0 ? void 0 : _d.maxSteps) || 10;
+        this.timeoutMs = ((_e = agentProps.limits) === null || _e === void 0 ? void 0 : _e.timeoutMs) || 60000;
+    }
+    AgentRunner.prototype.streamGenerator = function (input) {
+        return __asyncGenerator(this, arguments, function streamGenerator_1() {
+            var maxSteps, toolCalls, runId, runStartedAt, agentId, modelInfo, declaredToolNames, execContext, resolvedInstructions, _a, err_1, messages, step, finalMessage, stoppedEarly, totalInputTokens, totalOutputTokens, totalCachedInputTokens, totalCacheCreationInputTokens, finalProviderMetadata, buildResult, _loop_1, this_1, state_1, result_1, finishContext, err_2;
+            var _this = this;
+            var _b, e_1, _c, _d;
+            var _e, _f, _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        maxSteps = ((_e = input.options) === null || _e === void 0 ? void 0 : _e.maxSteps) || this.maxSteps;
+                        toolCalls = [];
+                        runId = (0, uuid_1.v4)();
+                        runStartedAt = Date.now();
+                        agentId = this.agentName || "unknown";
+                        modelInfo = {
+                            adapterId: (_f = this.agentProps.model) === null || _f === void 0 ? void 0 : _f.adapterId,
+                            maxTokens: this.maxTokens,
+                            temperature: this.temperature,
+                        };
+                        declaredToolNames = Array.from(this.tools.keys());
+                        execContext = {
+                            agentId: agentId,
+                            conversationId: input.conversationId,
+                            user: input.user,
+                            metadata: input.metadata,
+                            conversationContext: input.conversationContext,
+                        };
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 5, , 6]);
+                        if (!(typeof this.agentProps.instructions === "function")) return [3 /*break*/, 3];
+                        return [4 /*yield*/, __await(this.agentProps.instructions(this.ctx, execContext))];
+                    case 2:
+                        _a = _j.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = this.agentProps.instructions;
+                        _j.label = 4;
+                    case 4:
+                        resolvedInstructions = _a;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _j.sent();
+                        throw new Error("Failed to resolve instructions for agent ".concat(this.agentName, ": ").concat(err_1.message));
+                    case 6:
+                        if (input.history && input.history.length > 0) {
+                            // Start with history
+                            messages = this.convertMessages(input.history);
+                        }
+                        else {
+                            messages = [];
+                        }
+                        // Add new user message
+                        if (typeof input.message === "string") {
+                            messages.push({ role: "user", content: input.message });
+                        }
+                        else if (Array.isArray(input.message) && input.message.length > 0 && "type" in input.message[0]) {
+                            // LLMContentBlock[] — multimodal content (e.g. text + images)
+                            messages.push({ role: "user", content: input.message });
+                        }
+                        else {
+                            messages.push.apply(messages, this.convertMessages(input.message));
+                        }
+                        // Dispatch observer onRun (pre-loop, before compaction / tool filtering)
+                        this.safeDispatch("onRun", function () {
+                            var _a, _b;
+                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onRun) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                runId: runId,
+                                agentId: agentId,
+                                instructions: resolvedInstructions,
+                                input: input,
+                                messages: __spreadArray([], messages, true),
+                                tools: declaredToolNames,
+                                model: modelInfo,
+                                context: execContext,
+                            });
+                        });
+                        step = 0;
+                        finalMessage = "";
+                        stoppedEarly = false;
+                        totalInputTokens = 0;
+                        totalOutputTokens = 0;
+                        totalCachedInputTokens = 0;
+                        totalCacheCreationInputTokens = 0;
+                        finalProviderMetadata = {};
+                        buildResult = function () { return ({
+                            runId: runId,
+                            message: finalMessage,
+                            toolCalls: toolCalls,
+                            stepsUsed: step,
+                            stoppedEarly: stoppedEarly,
+                            usage: __assign(__assign({ inputTokens: totalInputTokens, outputTokens: totalOutputTokens }, (totalCachedInputTokens > 0 && { cachedInputTokens: totalCachedInputTokens })), (totalCacheCreationInputTokens > 0 && { cacheCreationInputTokens: totalCacheCreationInputTokens })),
+                            providerMetadata: Object.keys(finalProviderMetadata).length > 0 ? finalProviderMetadata : undefined,
+                        }); };
+                        _j.label = 7;
+                    case 7:
+                        _j.trys.push([7, 16, , 17]);
+                        _loop_1 = function () {
+                            var availableTools, needsCompaction, beforeCount, originalMessages, compactedMessages, error_1, toolCallsBeforeStep, llmStream, textContent, toolCallsFromStream, usage, stopReason, providerMetadata, _k, llmStream_1, llmStream_1_1, chunk, _l, e_1_1, llmResponse, assistantContent, _i, _m, toolCall, stepContext, toolResults, _o, _p, toolCall, toolExecutor, toolOutput, toolError, toolResult, formattedResult, err_3, stepContext;
+                            return __generator(this, function (_q) {
+                                switch (_q.label) {
+                                    case 0:
+                                        step++;
+                                        return [4 /*yield*/, __await(this_1.filterToolsByPermissions(input.user, input.userPermissions, input.conversationContext))];
+                                    case 1:
+                                        availableTools = _q.sent();
+                                        if (!this_1.agentProps.shouldCompact) return [3 /*break*/, 9];
+                                        _q.label = 2;
+                                    case 2:
+                                        _q.trys.push([2, 8, , 9]);
+                                        return [4 /*yield*/, __await(this_1.agentProps.shouldCompact(messages, step))];
+                                    case 3:
+                                        needsCompaction = _q.sent();
+                                        if (!needsCompaction) return [3 /*break*/, 7];
+                                        beforeCount = messages.length;
+                                        originalMessages = messages;
+                                        compactedMessages = void 0;
+                                        if (!this_1.agentProps.compactHistory) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, __await(this_1.agentProps.compactHistory(messages, step))];
+                                    case 4:
+                                        compactedMessages = _q.sent();
+                                        return [3 /*break*/, 6];
+                                    case 5:
+                                        // Default strategy: sliding window keeping last 10 messages
+                                        compactedMessages = messages.slice(-10);
+                                        _q.label = 6;
+                                    case 6:
+                                        // Validation: ensure compacted array is not empty
+                                        if (!compactedMessages || compactedMessages.length === 0) {
+                                            throw new Error("compactHistory must return at least one message");
+                                        }
+                                        // Apply compaction
+                                        messages = compactedMessages;
+                                        // Log compaction for debugging
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Step ").concat(step, ": Compacted ").concat(beforeCount, " messages \u2192 ").concat(messages.length));
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Compacted messages:"), {
+                                            messageCount: messages.length,
+                                            messages: messages.map(function (m) { return ({
+                                                role: m.role,
+                                                contentPreview: typeof m.content === "string"
+                                                    ? m.content.substring(0, 100) + (m.content.length > 100 ? "..." : "")
+                                                    : "".concat(m.content.length, " blocks"),
+                                            }); }),
+                                        });
+                                        _q.label = 7;
+                                    case 7: return [3 /*break*/, 9];
+                                    case 8:
+                                        error_1 = _q.sent();
+                                        // Log error but don't fail execution - compaction is optional optimization
+                                        FlinkLog_1.log.error("[Agent:".concat(this_1.agentName, "] Context compaction failed:"), error_1.message);
+                                        return [3 /*break*/, 9];
+                                    case 9:
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Step ").concat(step, "/").concat(maxSteps, " - Calling LLM with:"), {
+                                            instructionsType: typeof this_1.agentProps.instructions === "function" ? "dynamic-callback" : "static",
+                                            messageCount: messages.length,
+                                            messages: messages.map(function (m) { return ({
+                                                role: m.role,
+                                                contentPreview: typeof m.content === "string"
+                                                    ? m.content.substring(0, 100) + (m.content.length > 100 ? "..." : "")
+                                                    : "".concat(m.content.length, " blocks"),
+                                            }); }),
+                                            toolCount: availableTools.length,
+                                            tools: availableTools.map(function (t) { return t.name; }),
+                                            maxTokens: this_1.maxTokens,
+                                            temperature: this_1.temperature,
+                                        });
+                                        // Dispatch observer onLlmCall — messages reflect post-compaction state;
+                                        // tools reflect per-step permission filtering
+                                        this_1.safeDispatch("onLlmCall", function () {
+                                            var _a, _b;
+                                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onLlmCall) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                                runId: runId,
+                                                agentId: agentId,
+                                                step: step,
+                                                maxSteps: maxSteps,
+                                                instructions: resolvedInstructions,
+                                                messages: __spreadArray([], messages, true),
+                                                tools: availableTools.map(function (t) { return t.name; }),
+                                                model: modelInfo,
+                                                context: execContext,
+                                            });
+                                        });
+                                        toolCallsBeforeStep = toolCalls.length;
+                                        llmStream = this_1.llmAdapter.stream({
+                                            instructions: resolvedInstructions,
+                                            messages: messages,
+                                            tools: availableTools,
+                                            maxTokens: this_1.maxTokens,
+                                            temperature: this_1.temperature,
+                                            providerMetadata: input.providerMetadata,
+                                        });
+                                        textContent = "";
+                                        toolCallsFromStream = [];
+                                        usage = { inputTokens: 0, outputTokens: 0 };
+                                        stopReason = "end_turn";
+                                        providerMetadata = {};
+                                        _q.label = 10;
+                                    case 10:
+                                        _q.trys.push([10, 22, 23, 28]);
+                                        _k = true, llmStream_1 = (e_1 = void 0, __asyncValues(llmStream));
+                                        _q.label = 11;
+                                    case 11: return [4 /*yield*/, __await(llmStream_1.next())];
+                                    case 12:
+                                        if (!(llmStream_1_1 = _q.sent(), _b = llmStream_1_1.done, !_b)) return [3 /*break*/, 21];
+                                        _d = llmStream_1_1.value;
+                                        _k = false;
+                                        chunk = _d;
+                                        _l = chunk.type;
+                                        switch (_l) {
+                                            case "text": return [3 /*break*/, 13];
+                                            case "tool_call": return [3 /*break*/, 16];
+                                            case "usage": return [3 /*break*/, 17];
+                                            case "metadata": return [3 /*break*/, 18];
+                                            case "done": return [3 /*break*/, 19];
+                                        }
+                                        return [3 /*break*/, 20];
+                                    case 13:
+                                        textContent += chunk.delta;
+                                        return [4 /*yield*/, __await({ type: "text_delta", delta: chunk.delta })];
+                                    case 14: 
+                                    // Yield text_delta event in real-time
+                                    return [4 /*yield*/, _q.sent()];
+                                    case 15:
+                                        // Yield text_delta event in real-time
+                                        _q.sent();
+                                        return [3 /*break*/, 20];
+                                    case 16:
+                                        toolCallsFromStream.push(chunk.toolCall);
+                                        return [3 /*break*/, 20];
+                                    case 17:
+                                        usage = chunk.usage;
+                                        totalInputTokens += chunk.usage.inputTokens;
+                                        totalOutputTokens += chunk.usage.outputTokens;
+                                        totalCachedInputTokens += chunk.usage.cachedInputTokens || 0;
+                                        totalCacheCreationInputTokens += chunk.usage.cacheCreationInputTokens || 0;
+                                        return [3 /*break*/, 20];
+                                    case 18:
+                                        // Merge provider metadata (e.g., responseId for continuation)
+                                        providerMetadata = __assign(__assign({}, providerMetadata), chunk.metadata);
+                                        finalProviderMetadata = __assign(__assign({}, finalProviderMetadata), chunk.metadata);
+                                        return [3 /*break*/, 20];
+                                    case 19:
+                                        stopReason = chunk.stopReason;
+                                        return [3 /*break*/, 20];
+                                    case 20:
+                                        _k = true;
+                                        return [3 /*break*/, 11];
+                                    case 21: return [3 /*break*/, 28];
+                                    case 22:
+                                        e_1_1 = _q.sent();
+                                        e_1 = { error: e_1_1 };
+                                        return [3 /*break*/, 28];
+                                    case 23:
+                                        _q.trys.push([23, , 26, 27]);
+                                        if (!(!_k && !_b && (_c = llmStream_1.return))) return [3 /*break*/, 25];
+                                        return [4 /*yield*/, __await(_c.call(llmStream_1))];
+                                    case 24:
+                                        _q.sent();
+                                        _q.label = 25;
+                                    case 25: return [3 /*break*/, 27];
+                                    case 26:
+                                        if (e_1) throw e_1.error;
+                                        return [7 /*endfinally*/];
+                                    case 27: return [7 /*endfinally*/];
+                                    case 28:
+                                        llmResponse = {
+                                            textContent: textContent || undefined,
+                                            toolCalls: toolCallsFromStream,
+                                            usage: usage,
+                                            stopReason: stopReason,
+                                        };
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Step ").concat(step, " - LLM Response:"), {
+                                            textLength: ((_g = llmResponse.textContent) === null || _g === void 0 ? void 0 : _g.length) || 0,
+                                            textPreview: ((_h = llmResponse.textContent) === null || _h === void 0 ? void 0 : _h.substring(0, 200)) + (llmResponse.textContent && llmResponse.textContent.length > 200 ? "..." : ""),
+                                            toolCallsCount: llmResponse.toolCalls.length,
+                                            toolCalls: llmResponse.toolCalls.map(function (tc) { return ({
+                                                name: tc.name,
+                                                inputKeys: Object.keys(tc.input),
+                                                input: tc.input,
+                                            }); }),
+                                            stopReason: llmResponse.stopReason,
+                                            usage: llmResponse.usage,
+                                        });
+                                        // Extract text response
+                                        if (llmResponse.textContent) {
+                                            finalMessage = llmResponse.textContent;
+                                        }
+                                        assistantContent = [];
+                                        if (llmResponse.textContent) {
+                                            assistantContent.push({
+                                                type: "text",
+                                                text: llmResponse.textContent,
+                                            });
+                                        }
+                                        for (_i = 0, _m = llmResponse.toolCalls; _i < _m.length; _i++) {
+                                            toolCall = _m[_i];
+                                            assistantContent.push({
+                                                type: "tool_use",
+                                                id: toolCall.id,
+                                                name: toolCall.name,
+                                                input: toolCall.input,
+                                            });
+                                        }
+                                        messages.push({
+                                            role: "assistant",
+                                            content: assistantContent,
+                                        });
+                                        if (!(llmResponse.toolCalls.length === 0)) return [3 /*break*/, 31];
+                                        if (!this_1.agentProps.onStep) return [3 /*break*/, 30];
+                                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                                        return [4 /*yield*/, __await(this_1.agentProps.onStep(stepContext))];
+                                    case 29:
+                                        _q.sent();
+                                        _q.label = 30;
+                                    case 30:
+                                        // Dispatch observer onStep (no tool calls executed this step)
+                                        this_1.safeDispatch("onStep", function () {
+                                            var _a, _b;
+                                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onStep) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                                runId: runId,
+                                                agentId: agentId,
+                                                step: step,
+                                                maxSteps: maxSteps,
+                                                messages: __spreadArray([], messages, true),
+                                                assistantText: llmResponse.textContent,
+                                                toolCalls: toolCalls.slice(toolCallsBeforeStep),
+                                                usage: usage,
+                                                context: execContext,
+                                            });
+                                        });
+                                        return [2 /*return*/, "break"];
+                                    case 31:
+                                        toolResults = [];
+                                        _o = 0, _p = llmResponse.toolCalls;
+                                        _q.label = 32;
+                                    case 32:
+                                        if (!(_o < _p.length)) return [3 /*break*/, 43];
+                                        toolCall = _p[_o];
+                                        toolExecutor = this_1.tools.get(toolCall.name);
+                                        toolOutput = void 0;
+                                        toolError = void 0;
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Executing tool '").concat(toolCall.name, "':"), {
+                                            input: toolCall.input,
+                                            inputSize: JSON.stringify(toolCall.input).length,
+                                        });
+                                        _q.label = 33;
+                                    case 33:
+                                        _q.trys.push([33, 39, , 42]);
+                                        if (!toolExecutor) {
+                                            throw new Error("Tool ".concat(toolCall.name, " not found"));
+                                        }
+                                        return [4 /*yield*/, __await({
+                                                type: "tool_call_start",
+                                                toolCall: {
+                                                    id: toolCall.id,
+                                                    name: toolCall.name,
+                                                    input: toolCall.input,
+                                                },
+                                            })];
+                                    case 34: 
+                                    // Yield tool_call_start event
+                                    return [4 /*yield*/, _q.sent()];
+                                    case 35:
+                                        // Yield tool_call_start event
+                                        _q.sent();
+                                        return [4 /*yield*/, __await(toolExecutor.execute(toolCall.input, {
+                                                user: input.user,
+                                                permissions: input.userPermissions,
+                                                conversationContext: input.conversationContext,
+                                            }))];
+                                    case 36:
+                                        toolResult = _q.sent();
+                                        formattedResult = toolExecutor.formatResultForAI(toolResult);
+                                        toolResults.push({
+                                            type: "tool_result",
+                                            tool_use_id: toolCall.id,
+                                            content: formattedResult,
+                                            is_error: !toolResult.success,
+                                        });
+                                        return [4 /*yield*/, __await({
+                                                type: "tool_call_result",
+                                                toolCall: {
+                                                    id: toolCall.id,
+                                                    name: toolCall.name,
+                                                    input: toolCall.input,
+                                                },
+                                                output: toolResult.success ? toolResult.data : null,
+                                                error: toolResult.success ? undefined : toolResult.error,
+                                            })];
+                                    case 37: 
+                                    // Yield tool_call_result event
+                                    return [4 /*yield*/, _q.sent()];
+                                    case 38:
+                                        // Yield tool_call_result event
+                                        _q.sent();
+                                        toolCalls.push({
+                                            name: toolCall.name,
+                                            input: toolCall.input,
+                                            output: toolResult.success ? toolResult.data : null,
+                                            error: toolResult.success ? undefined : toolResult.error,
+                                        });
+                                        FlinkLog_1.log.debug("[Agent:".concat(this_1.agentName, "] Tool '").concat(toolCall.name, "' ").concat(toolResult.success ? "succeeded" : "failed", ":"), {
+                                            success: toolResult.success,
+                                            outputSize: toolResult.success ? JSON.stringify(toolResult.data).length : 0,
+                                            outputPreview: toolResult.success
+                                                ? JSON.stringify(toolResult.data).substring(0, 200) + (JSON.stringify(toolResult.data).length > 200 ? "..." : "")
+                                                : toolResult.error,
+                                            code: toolResult.code,
+                                        });
+                                        if (!toolResult.success) {
+                                            FlinkLog_1.log.warn("Tool ".concat(toolCall.name, " returned error:"), toolResult.error);
+                                        }
+                                        return [3 /*break*/, 42];
+                                    case 39:
+                                        err_3 = _q.sent();
+                                        // Unexpected errors (not from tool itself)
+                                        toolError = err_3.message;
+                                        return [4 /*yield*/, __await({
+                                                type: "tool_call_result",
+                                                toolCall: {
+                                                    id: toolCall.id,
+                                                    name: toolCall.name,
+                                                    input: toolCall.input,
+                                                },
+                                                output: null,
+                                                error: toolError,
+                                            })];
+                                    case 40: 
+                                    // Yield tool_call_result with error
+                                    return [4 /*yield*/, _q.sent()];
+                                    case 41:
+                                        // Yield tool_call_result with error
+                                        _q.sent();
+                                        toolResults.push({
+                                            type: "tool_result",
+                                            tool_use_id: toolCall.id,
+                                            content: "Error: ".concat(err_3.message),
+                                            is_error: true,
+                                        });
+                                        toolCalls.push({
+                                            name: toolCall.name,
+                                            input: toolCall.input,
+                                            output: null,
+                                            error: toolError,
+                                        });
+                                        FlinkLog_1.log.error("Tool ".concat(toolCall.name, " execution failed:"), err_3.message);
+                                        return [3 /*break*/, 42];
+                                    case 42:
+                                        _o++;
+                                        return [3 /*break*/, 32];
+                                    case 43:
+                                        // Add tool results to conversation
+                                        messages.push({
+                                            role: "user",
+                                            content: toolResults,
+                                        });
+                                        if (!this_1.agentProps.onStep) return [3 /*break*/, 45];
+                                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                                        return [4 /*yield*/, __await(this_1.agentProps.onStep(stepContext))];
+                                    case 44:
+                                        _q.sent();
+                                        _q.label = 45;
+                                    case 45:
+                                        // Dispatch observer onStep with per-step tool calls slice
+                                        this_1.safeDispatch("onStep", function () {
+                                            var _a, _b;
+                                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onStep) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                                runId: runId,
+                                                agentId: agentId,
+                                                step: step,
+                                                maxSteps: maxSteps,
+                                                messages: __spreadArray([], messages, true),
+                                                assistantText: llmResponse.textContent,
+                                                toolCalls: toolCalls.slice(toolCallsBeforeStep),
+                                                usage: usage,
+                                                context: execContext,
+                                            });
+                                        });
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _j.label = 8;
+                    case 8:
+                        if (!(step < maxSteps)) return [3 /*break*/, 10];
+                        return [5 /*yield**/, _loop_1()];
+                    case 9:
+                        state_1 = _j.sent();
+                        if (state_1 === "break")
+                            return [3 /*break*/, 10];
+                        return [3 /*break*/, 8];
+                    case 10:
+                        if (step >= maxSteps && toolCalls.length > 0) {
+                            stoppedEarly = true;
+                            FlinkLog_1.log.warn("Agent ".concat(this.agentName || "unknown", " stopped early after ").concat(maxSteps, " steps"));
+                        }
+                        result_1 = buildResult();
+                        if (!this.agentProps.afterRun) return [3 /*break*/, 12];
+                        finishContext = __assign(__assign({}, execContext), { messages: __spreadArray([], messages, true), result: result_1 });
+                        return [4 /*yield*/, __await(this.agentProps.afterRun(result_1, finishContext))];
+                    case 11:
+                        _j.sent();
+                        _j.label = 12;
+                    case 12:
+                        // Dispatch observer onFinish (success path)
+                        this.safeDispatch("onFinish", function () {
+                            var _a, _b;
+                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onFinish) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                runId: runId,
+                                agentId: agentId,
+                                result: result_1,
+                                messages: __spreadArray([], messages, true),
+                                durationMs: Date.now() - runStartedAt,
+                                context: execContext,
+                            });
+                        });
+                        return [4 /*yield*/, __await({ type: "complete", result: result_1 })];
+                    case 13: 
+                    // Phase 1: Yield only complete event
+                    // Phase 2: Will yield text_delta and tool events during loop
+                    return [4 /*yield*/, _j.sent()];
+                    case 14:
+                        // Phase 1: Yield only complete event
+                        // Phase 2: Will yield text_delta and tool events during loop
+                        _j.sent();
+                        return [4 /*yield*/, __await(result_1)];
+                    case 15: return [2 /*return*/, _j.sent()];
+                    case 16:
+                        err_2 = _j.sent();
+                        // Dispatch observer onFinish with error before rethrowing
+                        this.safeDispatch("onFinish", function () {
+                            var _a, _b;
+                            return (_b = (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.onFinish) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                                runId: runId,
+                                agentId: agentId,
+                                result: buildResult(),
+                                messages: __spreadArray([], messages, true),
+                                durationMs: Date.now() - runStartedAt,
+                                error: (err_2 === null || err_2 === void 0 ? void 0 : err_2.message) || String(err_2),
+                                context: execContext,
+                            });
+                        });
+                        throw err_2;
+                    case 17: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Fire-and-forget observer dispatch: catches synchronous throws and
+     * rejected promises so observer failures never break agent execution.
+     */
+    AgentRunner.prototype.safeDispatch = function (eventName, invoke) {
+        try {
+            var maybePromise = invoke();
+            if (maybePromise && typeof maybePromise.then === "function") {
+                maybePromise.catch(function (err) {
+                    observerLog.warn("AgentObserver.".concat(eventName, " threw (async):"), (err === null || err === void 0 ? void 0 : err.message) || err);
+                });
+            }
+        }
+        catch (err) {
+            observerLog.warn("AgentObserver.".concat(eventName, " threw (sync):"), (err === null || err === void 0 ? void 0 : err.message) || err);
+        }
+    };
+    /**
+     * Convert Message[] to LLM message format
+     * Supports multi-turn conversations with history
+     */
+    AgentRunner.prototype.convertMessages = function (messages) {
+        return messages.map(function (m) {
+            if (m.role === "user") {
+                return { role: "user", content: m.content };
+            }
+            else if (m.role === "assistant") {
+                // If assistant message has tool calls, convert to content blocks
+                if (m.toolCalls && m.toolCalls.length > 0) {
+                    var contentBlocks = [];
+                    // Add text content if present
+                    if (m.content) {
+                        contentBlocks.push({ type: "text", text: m.content });
+                    }
+                    // Add tool use blocks
+                    for (var _i = 0, _a = m.toolCalls; _i < _a.length; _i++) {
+                        var toolCall = _a[_i];
+                        contentBlocks.push({
+                            type: "tool_use",
+                            id: toolCall.id,
+                            name: toolCall.name,
+                            input: toolCall.input,
+                        });
+                    }
+                    return { role: "assistant", content: contentBlocks };
+                }
+                // Text-only assistant message
+                return { role: "assistant", content: m.content };
+            }
+            else {
+                // For tool messages, convert to user message with tool_result content block
+                return {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: m.toolCallId,
+                            content: m.result,
+                        },
+                    ],
+                };
+            }
+        });
+    };
+    AgentRunner.prototype.getToolSchemas = function () {
+        return Array.from(this.tools.values()).map(function (t) { return t.getToolSchema(); });
+    };
+    /**
+     * Filter tools based on user permissions
+     * Only returns schemas for tools the user has permission to use
+     *
+     * @param user - User object
+     * @param userPermissions - Optional resolved permissions from auth plugin (preferred)
+     * @param conversationContext - Optional conversation context
+     */
+    AgentRunner.prototype.filterToolsByPermissions = function (user, userPermissions, conversationContext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var allowedTools, toolExecutors, _i, toolExecutors_1, tool, hasPermission;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        allowedTools = [];
+                        toolExecutors = Array.from(this.tools.values());
+                        _i = 0, toolExecutors_1 = toolExecutors;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < toolExecutors_1.length)) return [3 /*break*/, 4];
+                        tool = toolExecutors_1[_i];
+                        return [4 /*yield*/, tool.checkPermissions(user, undefined, userPermissions, conversationContext)];
+                    case 2:
+                        hasPermission = _a.sent();
+                        if (hasPermission) {
+                            allowedTools.push(tool.getToolSchema());
+                        }
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, allowedTools];
+                }
+            });
+        });
+    };
+    return AgentRunner;
+}());
+exports.AgentRunner = AgentRunner;