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

package/spec/mock-project/dist/src/ai/AgentRunner.js

@@ -0,0 +1,632 @@
+"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 FlinkLog_1 = require("../FlinkLog");
+var AgentRunner = /** @class */ (function () {
+    function AgentRunner(agentProps, tools, llmAdapters, agentName, // Optional agent name for logging
+    ctx // FlinkContext for instruction callbacks (any for flexibility)
+    ) {
+        var _a, _b, _c, _d, _e;
+        this.agentProps = agentProps;
+        this.tools = tools;
+        this.agentName = agentName;
+        this.ctx = ctx;
+        // 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, execContext, resolvedInstructions, _a, err_1, messages, step, finalMessage, stoppedEarly, totalInputTokens, totalOutputTokens, totalCachedInputTokens, totalCacheCreationInputTokens, finalProviderMetadata, availableTools, needsCompaction, beforeCount, originalMessages, compactedMessages, error_1, llmStream, textContent, toolCallsFromStream, usage, stopReason, providerMetadata, _b, llmStream_1, llmStream_1_1, chunk, _c, e_1_1, llmResponse, assistantContent, _i, _d, toolCall, stepContext, toolResults, _e, _f, toolCall, toolExecutor, toolOutput, toolError, toolResult, formattedResult, err_2, stepContext, result, finishContext;
+            var _g, e_1, _h, _j;
+            var _k, _l, _m;
+            return __generator(this, function (_o) {
+                switch (_o.label) {
+                    case 0:
+                        maxSteps = ((_k = input.options) === null || _k === void 0 ? void 0 : _k.maxSteps) || this.maxSteps;
+                        toolCalls = [];
+                        execContext = {
+                            agentId: this.agentName || "unknown",
+                            conversationId: input.conversationId,
+                            user: input.user,
+                            metadata: input.metadata,
+                            conversationContext: input.conversationContext,
+                        };
+                        _o.label = 1;
+                    case 1:
+                        _o.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 = _o.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = this.agentProps.instructions;
+                        _o.label = 4;
+                    case 4:
+                        resolvedInstructions = _a;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _o.sent();
+                        throw new Error("Failed to resolve dynamic 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));
+                        }
+                        step = 0;
+                        finalMessage = "";
+                        stoppedEarly = false;
+                        totalInputTokens = 0;
+                        totalOutputTokens = 0;
+                        totalCachedInputTokens = 0;
+                        totalCacheCreationInputTokens = 0;
+                        finalProviderMetadata = {};
+                        _o.label = 7;
+                    case 7:
+                        if (!(step < maxSteps)) return [3 /*break*/, 53];
+                        step++;
+                        return [4 /*yield*/, __await(this.filterToolsByPermissions(input.user, input.userPermissions, input.conversationContext))];
+                    case 8:
+                        availableTools = _o.sent();
+                        if (!this.agentProps.shouldCompact) return [3 /*break*/, 16];
+                        _o.label = 9;
+                    case 9:
+                        _o.trys.push([9, 15, , 16]);
+                        return [4 /*yield*/, __await(this.agentProps.shouldCompact(messages, step))];
+                    case 10:
+                        needsCompaction = _o.sent();
+                        if (!needsCompaction) return [3 /*break*/, 14];
+                        beforeCount = messages.length;
+                        originalMessages = messages;
+                        compactedMessages = void 0;
+                        if (!this.agentProps.compactHistory) return [3 /*break*/, 12];
+                        return [4 /*yield*/, __await(this.agentProps.compactHistory(messages, step))];
+                    case 11:
+                        compactedMessages = _o.sent();
+                        return [3 /*break*/, 13];
+                    case 12:
+                        // Default strategy: sliding window keeping last 10 messages
+                        compactedMessages = messages.slice(-10);
+                        _o.label = 13;
+                    case 13:
+                        // 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.agentName, "] Step ").concat(step, ": Compacted ").concat(beforeCount, " messages \u2192 ").concat(messages.length));
+                        // Debug logging: Show compacted messages if debug enabled
+                        if (this.agentProps.debug) {
+                            FlinkLog_1.log.debug("[Agent:".concat(this.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"),
+                                }); }),
+                            });
+                        }
+                        _o.label = 14;
+                    case 14: return [3 /*break*/, 16];
+                    case 15:
+                        error_1 = _o.sent();
+                        // Log error but don't fail execution - compaction is optional optimization
+                        FlinkLog_1.log.error("[Agent:".concat(this.agentName, "] Context compaction failed:"), error_1.message);
+                        return [3 /*break*/, 16];
+                    case 16:
+                        // 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: resolvedInstructions,
+                                instructionsType: typeof this.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.maxTokens,
+                                temperature: this.temperature,
+                            });
+                        }
+                        llmStream = this.llmAdapter.stream({
+                            instructions: resolvedInstructions,
+                            messages: messages,
+                            tools: availableTools,
+                            maxTokens: this.maxTokens,
+                            temperature: this.temperature,
+                            providerMetadata: input.providerMetadata,
+                        });
+                        textContent = "";
+                        toolCallsFromStream = [];
+                        usage = { inputTokens: 0, outputTokens: 0 };
+                        stopReason = "end_turn";
+                        providerMetadata = {};
+                        _o.label = 17;
+                    case 17:
+                        _o.trys.push([17, 29, 30, 35]);
+                        _b = true, llmStream_1 = (e_1 = void 0, __asyncValues(llmStream));
+                        _o.label = 18;
+                    case 18: return [4 /*yield*/, __await(llmStream_1.next())];
+                    case 19:
+                        if (!(llmStream_1_1 = _o.sent(), _g = llmStream_1_1.done, !_g)) return [3 /*break*/, 28];
+                        _j = llmStream_1_1.value;
+                        _b = false;
+                        chunk = _j;
+                        _c = chunk.type;
+                        switch (_c) {
+                            case "text": return [3 /*break*/, 20];
+                            case "tool_call": return [3 /*break*/, 23];
+                            case "usage": return [3 /*break*/, 24];
+                            case "metadata": return [3 /*break*/, 25];
+                            case "done": return [3 /*break*/, 26];
+                        }
+                        return [3 /*break*/, 27];
+                    case 20:
+                        textContent += chunk.delta;
+                        return [4 /*yield*/, __await({ type: "text_delta", delta: chunk.delta })];
+                    case 21: 
+                    // Yield text_delta event in real-time
+                    return [4 /*yield*/, _o.sent()];
+                    case 22:
+                        // Yield text_delta event in real-time
+                        _o.sent();
+                        return [3 /*break*/, 27];
+                    case 23:
+                        toolCallsFromStream.push(chunk.toolCall);
+                        return [3 /*break*/, 27];
+                    case 24:
+                        usage = chunk.usage;
+                        totalInputTokens += chunk.usage.inputTokens;
+                        totalOutputTokens += chunk.usage.outputTokens;
+                        totalCachedInputTokens += chunk.usage.cachedInputTokens || 0;
+                        totalCacheCreationInputTokens += chunk.usage.cacheCreationInputTokens || 0;
+                        return [3 /*break*/, 27];
+                    case 25:
+                        // Merge provider metadata (e.g., responseId for continuation)
+                        providerMetadata = __assign(__assign({}, providerMetadata), chunk.metadata);
+                        finalProviderMetadata = __assign(__assign({}, finalProviderMetadata), chunk.metadata);
+                        return [3 /*break*/, 27];
+                    case 26:
+                        stopReason = chunk.stopReason;
+                        return [3 /*break*/, 27];
+                    case 27:
+                        _b = true;
+                        return [3 /*break*/, 18];
+                    case 28: return [3 /*break*/, 35];
+                    case 29:
+                        e_1_1 = _o.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 35];
+                    case 30:
+                        _o.trys.push([30, , 33, 34]);
+                        if (!(!_b && !_g && (_h = llmStream_1.return))) return [3 /*break*/, 32];
+                        return [4 /*yield*/, __await(_h.call(llmStream_1))];
+                    case 31:
+                        _o.sent();
+                        _o.label = 32;
+                    case 32: return [3 /*break*/, 34];
+                    case 33:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 34: return [7 /*endfinally*/];
+                    case 35:
+                        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: ((_l = llmResponse.textContent) === null || _l === void 0 ? void 0 : _l.length) || 0,
+                                textPreview: ((_m = llmResponse.textContent) === null || _m === void 0 ? void 0 : _m.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, _d = llmResponse.toolCalls; _i < _d.length; _i++) {
+                            toolCall = _d[_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*/, 38];
+                        if (!this.agentProps.onStep) return [3 /*break*/, 37];
+                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                        return [4 /*yield*/, __await(this.agentProps.onStep(stepContext))];
+                    case 36:
+                        _o.sent();
+                        _o.label = 37;
+                    case 37: return [3 /*break*/, 53]; // No more tool calls - done
+                    case 38:
+                        toolResults = [];
+                        _e = 0, _f = llmResponse.toolCalls;
+                        _o.label = 39;
+                    case 39:
+                        if (!(_e < _f.length)) return [3 /*break*/, 50];
+                        toolCall = _f[_e];
+                        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,
+                            });
+                        }
+                        _o.label = 40;
+                    case 40:
+                        _o.trys.push([40, 46, , 49]);
+                        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 41: 
+                    // Yield tool_call_start event
+                    return [4 /*yield*/, _o.sent()];
+                    case 42:
+                        // Yield tool_call_start event
+                        _o.sent();
+                        return [4 /*yield*/, __await(toolExecutor.execute(toolCall.input, {
+                                user: input.user,
+                                permissions: input.userPermissions,
+                                conversationContext: input.conversationContext,
+                            }))];
+                    case 43:
+                        toolResult = _o.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 44: 
+                    // Yield tool_call_result event
+                    return [4 /*yield*/, _o.sent()];
+                    case 45:
+                        // Yield tool_call_result event
+                        _o.sent();
+                        toolCalls.push({
+                            name: toolCall.name,
+                            input: toolCall.input,
+                            output: toolResult.success ? toolResult.data : null,
+                            error: toolResult.success ? undefined : toolResult.error,
+                        });
+                        // 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*/, 49];
+                    case 46:
+                        err_2 = _o.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 47: 
+                    // Yield tool_call_result with error
+                    return [4 /*yield*/, _o.sent()];
+                    case 48:
+                        // Yield tool_call_result with error
+                        _o.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*/, 49];
+                    case 49:
+                        _e++;
+                        return [3 /*break*/, 39];
+                    case 50:
+                        // Add tool results to conversation
+                        messages.push({
+                            role: "user",
+                            content: toolResults,
+                        });
+                        if (!this.agentProps.onStep) return [3 /*break*/, 52];
+                        stepContext = __assign(__assign({}, execContext), { step: step, maxSteps: maxSteps, messages: __spreadArray([], messages, true) });
+                        return [4 /*yield*/, __await(this.agentProps.onStep(stepContext))];
+                    case 51:
+                        _o.sent();
+                        _o.label = 52;
+                    case 52: return [3 /*break*/, 7];
+                    case 53:
+                        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: __assign(__assign({ inputTokens: totalInputTokens, outputTokens: totalOutputTokens }, (totalCachedInputTokens > 0 && { cachedInputTokens: totalCachedInputTokens })), (totalCacheCreationInputTokens > 0 && { cacheCreationInputTokens: totalCacheCreationInputTokens })),
+                            providerMetadata: Object.keys(finalProviderMetadata).length > 0 ? finalProviderMetadata : undefined,
+                        };
+                        if (!this.agentProps.afterRun) return [3 /*break*/, 55];
+                        finishContext = __assign(__assign({}, execContext), { messages: __spreadArray([], messages, true), result: result });
+                        return [4 /*yield*/, __await(this.agentProps.afterRun(result, finishContext))];
+                    case 54:
+                        _o.sent();
+                        _o.label = 55;
+                    case 55: return [4 /*yield*/, __await({ type: "complete", result: result })];
+                    case 56: 
+                    // Phase 1: Yield only complete event
+                    // Phase 2: Will yield text_delta and tool events during loop
+                    return [4 /*yield*/, _o.sent()];
+                    case 57:
+                        // Phase 1: Yield only complete event
+                        // Phase 2: Will yield text_delta and tool events during loop
+                        _o.sent();
+                        return [4 /*yield*/, __await(result)];
+                    case 58: return [2 /*return*/, _o.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") {
+                // 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;