@flink-app/flink 1.0.0 → 2.0.0-alpha.49

package/dist/src/ai/AgentRunner.d.ts

@@ -0,0 +1,39 @@
+import { FlinkAgentProps, AgentExecuteInput, StreamChunk } from "./FlinkAgent";
+import { ToolExecutor } from "./ToolExecutor";
+import { LLMAdapter } from "./LLMAdapter";
+export declare class AgentRunner {
+    private agentProps;
+    private tools;
+    private agentName?;
+    private llmAdapter;
+    private maxTokens;
+    private temperature;
+    private maxSteps;
+    private timeoutMs;
+    private maxSubAgentDepth;
+    constructor(agentProps: FlinkAgentProps, tools: Map<string, ToolExecutor<any>>, llmAdapters: Map<string, LLMAdapter>, agentName?: string | undefined);
+    /**
+     * Phase 1: Stream generator that yields complete event on finish
+     * Phase 2: Will yield text_delta and tool events during execution
+     */
+    streamGenerator(input: AgentExecuteInput): AsyncGenerator<StreamChunk>;
+    /**
+     * Convert Message[] to LLM message format
+     * Supports multi-turn conversations with history
+     */
+    private convertMessages;
+    private getToolSchemas;
+    /**
+     * 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)
+     */
+    private filterToolsByPermissions;
+    /**
+     * Build delegation chain from metadata for error messages
+     * Extracts parent agent IDs to show the full call stack
+     */
+    private buildDelegationChain;
+}

package/dist/src/ai/AgentRunner.js

@@ -0,0 +1,625 @@
+"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 SubAgentExecutor_1 = require("./SubAgentExecutor");
+var FlinkLog_1 = require("../FlinkLog");
+var AgentRunner = /** @class */ (function () {
+    function AgentRunner(agentProps, tools, llmAdapters, agentName) {
+        var _a, _b, _c, _d, _e, _f;
+        this.agentProps = agentProps;
+        this.tools = tools;
+        this.agentName = agentName;
+        // 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;
+        this.maxSubAgentDepth = ((_f = agentProps.limits) === null || _f === void 0 ? void 0 : _f.maxSubAgentDepth) || 5;
+    }
+    /**
+     * Phase 1: Stream generator that yields complete event on finish
+     * Phase 2: Will yield text_delta and tool events during execution
+     */
+    AgentRunner.prototype.streamGenerator = function (input) {
+        return __asyncGenerator(this, arguments, function streamGenerator_1() {
+            var maxSteps, toolCalls, subAgentCalls, currentDepth, chain, chainStr, execContext, messages, step, finalMessage, stoppedEarly, totalInputTokens, totalOutputTokens, availableTools, llmStream, textContent, toolCallsFromStream, usage, stopReason, _a, llmStream_1, llmStream_1_1, chunk, _b, e_1_1, llmResponse, assistantContent, _i, _c, toolCall, stepContext, toolResults, _d, _e, toolCall, toolExecutor, toolOutput, toolError, isSubAgent, subAgentId, transformedInput, err_1, toolResult, _f, formattedResult, subAgentId, agentResult, err_2, stepContext, result, finishContext;
+            var _g, e_1, _h, _j;
+            var _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+            return __generator(this, function (_w) {
+                switch (_w.label) {
+                    case 0:
+                        maxSteps = ((_k = input.options) === null || _k === void 0 ? void 0 : _k.maxSteps) || this.maxSteps;
+                        toolCalls = [];
+                        subAgentCalls = [];
+                        currentDepth = (_m = (_l = input.metadata) === null || _l === void 0 ? void 0 : _l.subAgentDepth) !== null && _m !== void 0 ? _m : 0;
+                        // Check depth limit before execution
+                        if (currentDepth > this.maxSubAgentDepth) {
+                            chain = this.buildDelegationChain(input.metadata);
+                            chainStr = chain.length > 0 ? " Delegation chain: ".concat(chain.join(" → "), " \u2192 ").concat(this.agentName || "unknown") : "";
+                            throw new Error("Sub-agent recursion depth limit exceeded (max: ".concat(this.maxSubAgentDepth, ", current: ").concat(currentDepth, "). ") +
+                                "This usually indicates a circular delegation loop.".concat(chainStr));
+                        }
+                        execContext = {
+                            agentId: this.agentName || "unknown",
+                            conversationId: input.conversationId,
+                            user: input.user,
+                            isSubAgent: ((_o = input.metadata) === null || _o === void 0 ? void 0 : _o.isSubAgentCall) === true,
+                            parentAgentId: (_p = input.metadata) === null || _p === void 0 ? void 0 : _p.parentAgentId,
+                            subAgentDepth: currentDepth,
+                            metadata: input.metadata,
+                        };
+                        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 {
+                            messages.push.apply(messages, this.convertMessages(input.message));
+                        }
+                        step = 0;
+                        finalMessage = "";
+                        stoppedEarly = false;
+                        totalInputTokens = 0;
+                        totalOutputTokens = 0;
+                        _w.label = 1;
+                    case 1:
+                        if (!(step < maxSteps)) return [3 /*break*/, 57];
+                        step++;
+                        return [4 /*yield*/, __await(this.filterToolsByPermissions(input.user, input.userPermissions))];
+                    case 2:
+                        availableTools = _w.sent();
+                        // Debug logging: Show what we're sending to the LLM
+                        if (this.agentProps.debug) {
+                            FlinkLog_1.log.debug("[Agent:".concat(this.agentName, "] Step ").concat(step, "/").concat(maxSteps, " - Calling LLM with:"), {
+                                instructions: this.agentProps.instructions,
+                                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.maxTokens,
+                                temperature: this.temperature,
+                            });
+                        }
+                        llmStream = this.llmAdapter.stream({
+                            instructions: this.agentProps.instructions,
+                            messages: messages,
+                            tools: availableTools,
+                            maxTokens: this.maxTokens,
+                            temperature: this.temperature,
+                        });
+                        textContent = "";
+                        toolCallsFromStream = [];
+                        usage = { inputTokens: 0, outputTokens: 0 };
+                        stopReason = "end_turn";
+                        _w.label = 3;
+                    case 3:
+                        _w.trys.push([3, 14, 15, 20]);
+                        _a = true, llmStream_1 = (e_1 = void 0, __asyncValues(llmStream));
+                        _w.label = 4;
+                    case 4: return [4 /*yield*/, __await(llmStream_1.next())];
+                    case 5:
+                        if (!(llmStream_1_1 = _w.sent(), _g = llmStream_1_1.done, !_g)) return [3 /*break*/, 13];
+                        _j = llmStream_1_1.value;
+                        _a = false;
+                        chunk = _j;
+                        _b = chunk.type;
+                        switch (_b) {
+                            case "text": return [3 /*break*/, 6];
+                            case "tool_call": return [3 /*break*/, 9];
+                            case "usage": return [3 /*break*/, 10];
+                            case "done": return [3 /*break*/, 11];
+                        }
+                        return [3 /*break*/, 12];
+                    case 6:
+                        textContent += chunk.delta;
+                        return [4 /*yield*/, __await({ type: "text_delta", delta: chunk.delta })];
+                    case 7: 
+                    // Yield text_delta event in real-time
+                    return [4 /*yield*/, _w.sent()];
+                    case 8:
+                        // Yield text_delta event in real-time
+                        _w.sent();
+                        return [3 /*break*/, 12];
+                    case 9:
+                        toolCallsFromStream.push(chunk.toolCall);
+                        return [3 /*break*/, 12];
+                    case 10:
+                        usage = chunk.usage;
+                        totalInputTokens += chunk.usage.inputTokens;
+                        totalOutputTokens += chunk.usage.outputTokens;
+                        return [3 /*break*/, 12];
+                    case 11:
+                        stopReason = chunk.stopReason;
+                        return [3 /*break*/, 12];
+                    case 12:
+                        _a = true;
+                        return [3 /*break*/, 4];
+                    case 13: return [3 /*break*/, 20];
+                    case 14:
+                        e_1_1 = _w.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 20];
+                    case 15:
+                        _w.trys.push([15, , 18, 19]);
+                        if (!(!_a && !_g && (_h = llmStream_1.return))) return [3 /*break*/, 17];
+                        return [4 /*yield*/, __await(_h.call(llmStream_1))];
+                    case 16:
+                        _w.sent();
+                        _w.label = 17;
+                    case 17: return [3 /*break*/, 19];
+                    case 18:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 19: return [7 /*endfinally*/];
+                    case 20:
+                        llmResponse = {
+                            textContent: textContent || undefined,
+                            toolCalls: toolCallsFromStream,
+                            usage: usage,
+                            stopReason: stopReason,
+                        };
+                        // Debug logging: Show what the LLM responded with
+                        if (this.agentProps.debug) {
+                            FlinkLog_1.log.debug("[Agent:".concat(this.agentName, "] Step ").concat(step, " - LLM Response:"), {
+                                textLength: ((_q = llmResponse.textContent) === null || _q === void 0 ? void 0 : _q.length) || 0,
+                                textPreview: ((_r = llmResponse.textContent) === null || _r === void 0 ? void 0 : _r.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, _c = llmResponse.toolCalls; _i < _c.length; _i++) {
+                            toolCall = _c[_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*/, 23];
+                        if (!this.agentProps.onStep) return [3 /*break*/, 22];
+                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                        return [4 /*yield*/, __await(this.agentProps.onStep(stepContext))];
+                    case 21:
+                        _w.sent();
+                        _w.label = 22;
+                    case 22: return [3 /*break*/, 57]; // No more tool calls - done
+                    case 23:
+                        toolResults = [];
+                        _d = 0, _e = llmResponse.toolCalls;
+                        _w.label = 24;
+                    case 24:
+                        if (!(_d < _e.length)) return [3 /*break*/, 54];
+                        toolCall = _e[_d];
+                        toolExecutor = this.tools.get(toolCall.name);
+                        toolOutput = void 0;
+                        toolError = void 0;
+                        // Debug logging: Tool execution start
+                        if (this.agentProps.debug) {
+                            FlinkLog_1.log.debug("[Agent:".concat(this.agentName, "] Executing tool '").concat(toolCall.name, "':"), {
+                                input: toolCall.input,
+                                inputSize: JSON.stringify(toolCall.input).length,
+                            });
+                        }
+                        _w.label = 25;
+                    case 25:
+                        _w.trys.push([25, 50, , 53]);
+                        if (!toolExecutor) {
+                            throw new Error("Tool ".concat(toolCall.name, " not found"));
+                        }
+                        isSubAgent = toolExecutor instanceof SubAgentExecutor_1.SubAgentExecutor ||
+                            ((_t = (_s = toolExecutor).isSubAgentExecutor) === null || _t === void 0 ? void 0 : _t.call(_s));
+                        if (!isSubAgent) return [3 /*break*/, 34];
+                        subAgentId = toolExecutor.getSubAgentId();
+                        transformedInput = toolCall.input;
+                        if (!this.agentProps.transformSubAgentInput) return [3 /*break*/, 29];
+                        _w.label = 26;
+                    case 26:
+                        _w.trys.push([26, 28, , 29]);
+                        return [4 /*yield*/, __await(this.agentProps.transformSubAgentInput(subAgentId, toolCall.input, execContext))];
+                    case 27:
+                        transformedInput = _w.sent();
+                        return [3 /*break*/, 29];
+                    case 28:
+                        err_1 = _w.sent();
+                        FlinkLog_1.log.warn("transformSubAgentInput hook failed for ".concat(subAgentId, ":"), err_1.message);
+                        return [3 /*break*/, 29];
+                    case 29:
+                        // Update the tool call input with transformed version
+                        toolCall.input = transformedInput;
+                        if (!this.agentProps.onSubAgentCall) return [3 /*break*/, 31];
+                        return [4 /*yield*/, __await(this.agentProps.onSubAgentCall(subAgentId, transformedInput, execContext))];
+                    case 30:
+                        _w.sent();
+                        _w.label = 31;
+                    case 31: return [4 /*yield*/, __await({
+                            type: "agent_call_start",
+                            agentId: subAgentId,
+                            input: transformedInput,
+                        })];
+                    case 32: 
+                    // Yield agent_call_start event
+                    return [4 /*yield*/, _w.sent()];
+                    case 33:
+                        // Yield agent_call_start event
+                        _w.sent();
+                        return [3 /*break*/, 37];
+                    case 34: return [4 /*yield*/, __await({
+                            type: "tool_call_start",
+                            toolCall: {
+                                id: toolCall.id,
+                                name: toolCall.name,
+                                input: toolCall.input,
+                            },
+                        })];
+                    case 35: 
+                    // Yield tool_call_start for regular tools
+                    return [4 /*yield*/, _w.sent()];
+                    case 36:
+                        // Yield tool_call_start for regular tools
+                        _w.sent();
+                        _w.label = 37;
+                    case 37:
+                        if (!isSubAgent) return [3 /*break*/, 39];
+                        return [4 /*yield*/, __await(toolExecutor.execute(toolCall.input, input.user, execContext, // Pass parent context to sub-agent
+                            input.userPermissions))];
+                    case 38:
+                        _f = _w.sent();
+                        return [3 /*break*/, 41];
+                    case 39: return [4 /*yield*/, __await(toolExecutor.execute(toolCall.input, input.user, input.userPermissions))];
+                    case 40:
+                        _f = _w.sent();
+                        _w.label = 41;
+                    case 41:
+                        toolResult = _f;
+                        formattedResult = toolExecutor.formatResultForAI(toolResult);
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: toolCall.id,
+                            content: formattedResult,
+                            is_error: !toolResult.success,
+                        });
+                        if (!(isSubAgent && toolResult.success)) return [3 /*break*/, 46];
+                        subAgentId = toolExecutor.getSubAgentId();
+                        agentResult = toolResult.data;
+                        // Merge token usage from sub-agent
+                        totalInputTokens += ((_u = agentResult.usage) === null || _u === void 0 ? void 0 : _u.inputTokens) || 0;
+                        totalOutputTokens += ((_v = agentResult.usage) === null || _v === void 0 ? void 0 : _v.outputTokens) || 0;
+                        subAgentCalls.push({
+                            agentId: subAgentId,
+                            input: toolCall.input,
+                            result: agentResult,
+                        });
+                        if (!this.agentProps.onSubAgentComplete) return [3 /*break*/, 43];
+                        return [4 /*yield*/, __await(this.agentProps.onSubAgentComplete(subAgentId, agentResult, execContext))];
+                    case 42:
+                        _w.sent();
+                        _w.label = 43;
+                    case 43: return [4 /*yield*/, __await({
+                            type: "agent_call_result",
+                            agentId: subAgentId,
+                            result: agentResult,
+                        })];
+                    case 44: 
+                    // Yield agent_call_result event
+                    return [4 /*yield*/, _w.sent()];
+                    case 45:
+                        // Yield agent_call_result event
+                        _w.sent();
+                        return [3 /*break*/, 49];
+                    case 46: 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 47: 
+                    // Yield tool_call_result for regular tools
+                    return [4 /*yield*/, _w.sent()];
+                    case 48:
+                        // Yield tool_call_result for regular tools
+                        _w.sent();
+                        _w.label = 49;
+                    case 49:
+                        toolCalls.push({
+                            name: toolCall.name,
+                            input: toolCall.input,
+                            output: toolResult.success ? toolResult.data : null,
+                            error: toolResult.success ? undefined : toolResult.error,
+                            isAgentCall: isSubAgent,
+                            agentId: isSubAgent ? toolExecutor.getSubAgentId() : undefined,
+                        });
+                        // Debug logging: Tool execution result
+                        if (this.agentProps.debug) {
+                            FlinkLog_1.log.debug("[Agent:".concat(this.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*/, 53];
+                    case 50:
+                        err_2 = _w.sent();
+                        // Unexpected errors (not from tool itself)
+                        toolError = err_2.message;
+                        return [4 /*yield*/, __await({
+                                type: "tool_call_result",
+                                toolCall: {
+                                    id: toolCall.id,
+                                    name: toolCall.name,
+                                    input: toolCall.input,
+                                },
+                                output: null,
+                                error: toolError,
+                            })];
+                    case 51: 
+                    // Yield tool_call_result with error
+                    return [4 /*yield*/, _w.sent()];
+                    case 52:
+                        // Yield tool_call_result with error
+                        _w.sent();
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: toolCall.id,
+                            content: "Error: ".concat(err_2.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_2.message);
+                        return [3 /*break*/, 53];
+                    case 53:
+                        _d++;
+                        return [3 /*break*/, 24];
+                    case 54:
+                        // Add tool results to conversation
+                        messages.push({
+                            role: "user",
+                            content: toolResults,
+                        });
+                        if (!this.agentProps.onStep) return [3 /*break*/, 56];
+                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                        return [4 /*yield*/, __await(this.agentProps.onStep(stepContext))];
+                    case 55:
+                        _w.sent();
+                        _w.label = 56;
+                    case 56: return [3 /*break*/, 1];
+                    case 57:
+                        if (step >= maxSteps && toolCalls.length > 0) {
+                            stoppedEarly = true;
+                            FlinkLog_1.log.warn("Agent ".concat(this.agentName || "unknown", " stopped early after ").concat(maxSteps, " steps"));
+                        }
+                        result = {
+                            message: finalMessage,
+                            toolCalls: toolCalls,
+                            stepsUsed: step,
+                            stoppedEarly: stoppedEarly,
+                            usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+                            subAgentCalls: subAgentCalls.length > 0 ? subAgentCalls : undefined,
+                        };
+                        if (!this.agentProps.afterRun) return [3 /*break*/, 59];
+                        finishContext = __assign(__assign({}, execContext), { messages: __spreadArray([], messages, true), result: result });
+                        return [4 /*yield*/, __await(this.agentProps.afterRun(result, finishContext))];
+                    case 58:
+                        _w.sent();
+                        _w.label = 59;
+                    case 59: return [4 /*yield*/, __await({ type: "complete", result: result })];
+                    case 60: 
+                    // Phase 1: Yield only complete event
+                    // Phase 2: Will yield text_delta and tool events during loop
+                    return [4 /*yield*/, _w.sent()];
+                    case 61:
+                        // Phase 1: Yield only complete event
+                        // Phase 2: Will yield text_delta and tool events during loop
+                        _w.sent();
+                        return [4 /*yield*/, __await(result)];
+                    case 62: return [2 /*return*/, _w.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * 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") {
+                return { role: "assistant", content: m.content };
+            }
+            else {
+                // For tool messages, convert to user message with tool result
+                return { role: "user", 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)
+     */
+    AgentRunner.prototype.filterToolsByPermissions = function (user, userPermissions) {
+        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)];
+                    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];
+                }
+            });
+        });
+    };
+    /**
+     * Build delegation chain from metadata for error messages
+     * Extracts parent agent IDs to show the full call stack
+     */
+    AgentRunner.prototype.buildDelegationChain = function (metadata) {
+        if (!(metadata === null || metadata === void 0 ? void 0 : metadata.parentAgentId)) {
+            return [];
+        }
+        var chain = [];
+        var current = metadata;
+        // Walk up the parent chain
+        while (current === null || current === void 0 ? void 0 : current.parentAgentId) {
+            chain.unshift(current.parentAgentId);
+            // If parent metadata exists, continue walking up
+            current = current.parentMetadata;
+        }
+        return chain;
+    };
+    return AgentRunner;
+}());
+exports.AgentRunner = AgentRunner;