@ai.ntellect/core 1.0.0 → 1.1.0

package/dist/agent/generic-executor.js

@@ -0,0 +1,620 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericExecutor = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const zod_1 = require("zod");
+const executor_1 = require("./base/executor");
+const llm_factory_1 = require("./llm-factory");
+const prompt_builder_1 = require("./prompt-builder");
+const logger_1 = require("./tools/logger");
+const handlers_1 = require("./handlers");
+class GenericExecutor extends executor_1.AgentExecutor {
+    constructor(agent, graphs, config, logger, options) {
+        var _a, _b, _c;
+        super(agent, graphs);
+        this.entityIndex = null;
+        this.verbose = (_a = config.verbose) !== null && _a !== void 0 ? _a : true;
+        this.llm = llm_factory_1.LLMFactory.createLLM(config.llmConfig);
+        this.logger = logger || new logger_1.AgentLogger(this.verbose);
+        this.cognitiveHandler = new handlers_1.CognitiveHandler(this.llm, this.logger, {
+            dynamicGoal: options === null || options === void 0 ? void 0 : options.dynamicGoal,
+            goalPrompt: options === null || options === void 0 ? void 0 : options.dynamicGoalPrompt,
+            initialGoal: agent.getGoal(),
+            dynamicNext: options === null || options === void 0 ? void 0 : options.dynamicNext,
+            nextPrompt: options === null || options === void 0 ? void 0 : options.dynamicNextPrompt,
+        });
+        this.enableSchedule = (_b = options === null || options === void 0 ? void 0 : options.enableSchedule) !== null && _b !== void 0 ? _b : false;
+        this.enableReflection = (_c = options === null || options === void 0 ? void 0 : options.enableReflection) !== null && _c !== void 0 ? _c : false;
+        this.agenda = options === null || options === void 0 ? void 0 : options.agenda;
+    }
+    setDynamicGoal(enabled, customPrompt) {
+        this.cognitiveHandler.setEnabled({ dynamicGoal: enabled, dynamicNext: undefined });
+        if (customPrompt) {
+            this.cognitiveHandler.goalPromptTemplate = customPrompt;
+        }
+    }
+    getCurrentGoal() {
+        return this.cognitiveHandler.getCurrentGoal();
+    }
+    getCurrentState() {
+        return this.cognitiveHandler.getCurrentState();
+    }
+    setCurrentState(state) {
+        this.cognitiveHandler.setCurrentState(state);
+    }
+    getAvailableNodes() {
+        return this.cognitiveHandler.getAvailableNodes();
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    setEntityIndex(index) {
+        this.entityIndex = index;
+    }
+    computeNextState(context, currentState, iteration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cognitiveHandler.computeNext(context, currentState, iteration);
+        });
+    }
+    scheduleTask(cronExpression, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enableSchedule || !this.agenda) {
+                this.log("warning", chalk_1.default.yellow("Schedule not enabled or Agenda not configured"));
+                return null;
+            }
+            try {
+                const id = yield this.agenda.scheduleRequest({
+                    originalRequest: request,
+                    cronExpression,
+                });
+                this.log("success", chalk_1.default.green(`Scheduled task: ${id} (${cronExpression})`));
+                return id;
+            }
+            catch (error) {
+                this.log("error", chalk_1.default.red(`Failed to schedule task: ${error}`));
+                return null;
+            }
+        });
+    }
+    log(type, message) {
+        if (!this.verbose)
+            return;
+        const levelMap = {
+            info: "info",
+            success: "info",
+            warning: "warn",
+            error: "error",
+            thinking: "info",
+        };
+        this.logger.log(levelMap[type], "executor", message);
+    }
+    /**
+     * Generates a string representation of the available action schemas
+     * @private
+     * @returns {string} Formatted string containing all available actions and their parameters
+     */
+    generateActionSchema() {
+        const HIDDEN_FIELDS = new Set([
+            "path", "success", "entries",
+            "stdout", "stderr", "exitCode", "isolationMethod",
+            "result", "error",
+        ]);
+        return Array.from(this.availableGraphs.values())
+            .map((graph) => {
+            const schema = graph.getSchema();
+            const schemaDescription = Object.entries(schema.shape)
+                .filter(([key, value]) => {
+                const zodValue = value;
+                return !key.endsWith("_result") && !key.includes("Result") && !HIDDEN_FIELDS.has(key);
+            })
+                .map(([key, value]) => {
+                var _a, _b, _c, _d;
+                const zodValue = value;
+                let desc = zodValue.description || "";
+                if (zodValue instanceof zod_1.z.ZodEnum) {
+                    const options = (_a = zodValue.options) !== null && _a !== void 0 ? _a : [];
+                    desc = desc ? `${desc} (Options: ${options.join(", ")})` : `Options: ${options.join(", ")}`;
+                }
+                const typeName = (_d = (_c = (_b = zodValue._def) === null || _b === void 0 ? void 0 : _b.typeName) !== null && _c !== void 0 ? _c : zodValue.constructor.name) !== null && _d !== void 0 ? _d : "unknown";
+                return `    - ${key}: ${desc || typeName}`;
+            })
+                .join("\n");
+            return `${graph.name}:
+  Parameters (INPUT only):
+${schemaDescription}
+  Output: stored as \$${graph.name}_result`;
+        })
+            .join("\n\n");
+    }
+    buildSystemPrompt(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const executedTools = context.executedActions.map(a => a.name);
+            const alreadyExecuted = executedTools.length > 0
+                ? `ALREADY DONE (DO NOT RE-EXECUTE THESE): ${executedTools.join(", ")}`
+                : "No tools executed yet.";
+            const availableToolNames = Array.from(this.availableGraphs.keys()).join(", ");
+            const cwd = context.cwd || process.cwd();
+            let variables = "";
+            if (executedTools.length > 0) {
+                variables = "IMPORTANT - Use these exact variable names for READ-ONLY reference:\n";
+                for (const action of context.executedActions) {
+                    const resultVal = typeof action.result === 'object' && action.result !== null
+                        ? JSON.stringify(action.result)
+                        : String(action.result);
+                    variables += `  \$${action.name}_result = ${resultVal}\n`;
+                }
+            }
+            else {
+                variables = "No variables yet. Execute a tool first.";
+            }
+            let conversationHistory = "";
+            const msgs = context.messages || [];
+            if (msgs.length > 0) {
+                conversationHistory = "CONVERSATION HISTORY (most recent first):\n";
+                const recent = msgs.slice(-6).reverse();
+                for (const msg of recent) {
+                    conversationHistory += `  [${msg.role === "user" ? "USER" : "YOU"}]: ${msg.content}\n`;
+                }
+            }
+            else {
+                conversationHistory = "No previous conversation.";
+            }
+            let scratchpadSection = "No prior reasoning recorded.";
+            const pad = context.scratchpad || [];
+            if (pad.length > 0) {
+                scratchpadSection = "YOUR REASONING JOURNAL (most recent first):\n";
+                const recent = pad.slice(-4).reverse();
+                for (const entry of recent) {
+                    scratchpadSection += `  [Turn ${entry.turn}] Thought: ${entry.thought}\n  → Action: ${entry.action}\n  → Observation: ${entry.observation}\n`;
+                }
+            }
+            let memoriesSection = "No relevant past memories.";
+            const mems = context.memories || [];
+            if (mems.length > 0) {
+                memoriesSection = "RECOLLECTED MEMORIES FROM PAST INTERACTIONS:\n";
+                for (const m of mems.slice(-5)) {
+                    memoriesSection += `  - ${(_a = m.content) === null || _a === void 0 ? void 0 : _a.substring(0, 300)}\n`;
+                }
+            }
+            let entitySection = "";
+            const es = context.entityState;
+            const cs = context.conversationState;
+            const handles = es === null || es === void 0 ? void 0 : es.handles;
+            if (handles && Object.keys(handles).length > 0) {
+                entitySection = "AVAILABLE ENTITY HANDLES (use entityId in tool calls):\n";
+                for (const [eid, h] of Object.entries(handles)) {
+                    entitySection += `  [${eid}] ${h.label} (${h.category})\n`;
+                }
+                entitySection += "\nIMPORTANT: Use ONLY the entityId from the list above. Do NOT write paths or filenames directly.\n";
+                entitySection += "Example: file_reader({ entityId: \"ent_0\" })\n";
+                const stillAmbiguous = ((_b = es.pendingResolutions) === null || _b === void 0 ? void 0 : _b.length) > 0 &&
+                    es.pendingResolutions.some((r) => { var _a; return r.resolved === null && ((_a = r.candidates) === null || _a === void 0 ? void 0 : _a.length) > 0; });
+                if (stillAmbiguous) {
+                    entitySection += "\nSome references are still ambiguous. Choose the entityId that best matches the user's intent.\n";
+                }
+            }
+            let pendingSection = "";
+            if ((cs === null || cs === void 0 ? void 0 : cs.pendingIntent) && cs.pendingIntent.failed) {
+                pendingSection = `PENDING INTENT (carried over from previous turn):\n`;
+                pendingSection += `  Original request: "${cs.pendingIntent.originalInput}"\n`;
+                if (cs.pendingIntent.unresolvedEntity) {
+                    pendingSection += `  Unresolved entity: "${cs.pendingIntent.unresolvedEntity}"\n`;
+                }
+                pendingSection += `  This intent was NOT satisfied. Address it if the user continues the topic.\n`;
+            }
+            return new prompt_builder_1.PromptBuilder()
+                .addSection("ROLE", this.agent.getRole())
+                .addSection("GOAL", this.getCurrentGoal())
+                .addSection("BACKSTORY", this.agent.getBackstory())
+                .addSection("ENVIRONMENT", `Current directory: ${cwd}`)
+                .addSection("CONVERSATION", conversationHistory)
+                .addSection("MEMORIES", memoriesSection)
+                .addSection("SCRATCHPAD", scratchpadSection)
+                .addSection("TOOLS", availableToolNames)
+                .addSection("SCHEMAS", this.generateActionSchema())
+                .addSection("VARIABLES", variables)
+                .addSection("STATUS", alreadyExecuted)
+                .addSection("ENTITY_REFERENCES", entitySection || "No entity references detected.")
+                .addSection("PENDING_INTENT", pendingSection || "No pending intent from previous turns.")
+                .addSection("RULES", `JSON format EXACT: {"thought":"your reasoning","actions":[{"name":"TOOL_NAME","parameters":{"param1":"value1"}}],"response":"votre réponse"}
+
+        RÈGLES STRICTES - Sortie JSON uniquement, pas de texte avant/après:
+- **"actions"**: tableau d'actions à exécuter. []
+  si aucune action **non déjà exécutée** n'est nécessaire.
+- **"response"**: réponse directe et naturelle à l'utilisateur (1-2 phrases, dans la langue de l'utilisateur).
+- **NE JAMAIS remettre une action déjà listée dans ALREADY DONE**. Les outils exécutés ont déjà produit un résultat.
+- **RÈGLE CRITIQUE**: Ta réponse dans le champ "response" est lue AVANT l'exécution des outils.
+  Ne JAMAIS annoncer un résultat ("Voici...", "Le fichier contient...").
+  Dis seulement ton INTENTION ("Je vais lister...", "Je vérifie...").
+  Le vrai résultat sera généré APRÈS exécution dans un second appel.
+- **QUAND DES OUTILS ONT DÉJÀ ÉTÉ EXÉCUTÉS** (ALREADY DONE non vide): ta réponse DOIT inclure les RÉSULTATS basés sur les VARIABLES.
+  Ne dis PAS ce que tu vas faire — dis ce que tu as trouvé.
+- **QUAND L'UTILISATEUR CORRIGE** ("non", "pas ça"): annule l'intention précédente et réanalyse.
+- **ENTITY IDs**: Utilise UNIQUEMENT les entityId listés dans ENTITY_REFERENCES. Ne JAMAIS écrire de path ou filename directement.
+  Exemple correct: file_reader({ entityId: "ent_0" })
+  Exemple INCORRECT: file_reader({ path: "agent" }) ou file_reader({ target: "agent" })
+- **QUAND ENTITY_REFERENCES EST DISPONIBLE**: ignore toute connaissance antérieure des chemins. Utilise UNIQUEMENT les entityId fournis.
+- **SANS ENTITY_REFERENCES**: utilise path avec parcimonie. Préfère lister d'abord pour découvrir les entités.
+- **ENCODING**: utilise TOUJOURS "utf-8" (avec le tiret). Jamais "utf8", "utf-8".
+
+EXEMPLE appel initial (aucun outil exécuté):
+  Input: "hello"
+  Output: {"actions":[],"response":"Bonjour ! Comment puis-je vous aider aujourd'hui ?"}
+
+  Input: "liste les fichiers"
+  Output: {"actions":[{"name":"directory_lister","parameters":{"path":"."}}],"response":"Je liste le dossier..."}
+
+EXEMPLE après exécution d'un outil (ALREADY DONE contient directory_lister):
+  Input: "liste les fichiers"
+  Output: {"actions":[],"response":"Voici les fichiers : fichier1.txt, dossier/ (36 entrées)"}
+
+EXEMPLE correction utilisateur:
+  User: "liste les fichiers"
+  → directory_lister(".")
+  User: "non, lis AGENTS.md"
+  → file_reader(path="AGENTS.md")
+
+NE PAS inclure de reasoning, pas de texte hors JSON.`)
+                .build(context);
+        });
+    }
+    updateDynamicGoal(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cognitiveHandler.computeGoal(context);
+        });
+    }
+    reflect(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.enableReflection) {
+                return { learning: "Reflection disabled." };
+            }
+            this.log("thinking", chalk_1.default.dim("Reflecting on last action..."));
+            const lastActions = (context.executedActions || []).slice(-3);
+            const prompt = `Analyze the just-completed action(s):
+
+Actions executed:
+${JSON.stringify(lastActions.map(a => ({ name: a.name, parameters: a.parameters, result: a.result })), null, 2)}
+
+Current goal: ${this.getCurrentGoal()}
+
+Answer in JSON only:
+{
+  "learning": "What did you learn? What insight helps future steps?",
+  "adjustedGoal": "(optional) improved goal if the original needs refinement"
+}`;
+            const schema = zod_1.z.object({
+                learning: zod_1.z.string(),
+                adjustedGoal: zod_1.z.string().optional(),
+            });
+            try {
+                const result = yield this.llm.generate({ system: "You reflect on actions to extract learnings.", user: prompt }, schema);
+                const learning = ((_a = result.object) === null || _a === void 0 ? void 0 : _a.learning) || "No specific learning extracted.";
+                const adjustedGoal = (_b = result.object) === null || _b === void 0 ? void 0 : _b.adjustedGoal;
+                if (adjustedGoal) {
+                    this.cognitiveHandler.setGoal(adjustedGoal);
+                }
+                this.log("info", chalk_1.default.cyan(`Reflection: ${learning.substring(0, 100)}...`));
+                return { learning, adjustedGoal };
+            }
+            catch (_c) {
+                this.log("warning", chalk_1.default.yellow("Reflection LLM call failed"));
+                return { learning: "Reflection unavailable." };
+            }
+        });
+    }
+    /**
+     * Makes a decision based on the current context using the LLM
+     * @param {AgentContext} context - The context to base the decision on
+     * @returns {Promise<DecisionOutput>} The decision output containing actions and response
+     */
+    makeDecision(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            var _e;
+            this.log("thinking", chalk_1.default.dim("Analyzing context and available actions..."));
+            const systemPrompt = yield this.buildSystemPrompt(context);
+            this.log("info", chalk_1.default.dim("Generating response..."));
+            const t0 = performance.now();
+            const result = yield this.llm.generate({
+                system: systemPrompt,
+                user: `User message: ${context.input.raw}`,
+            }, zod_1.z.object({
+                thought: zod_1.z.string().catch("").default(""),
+                actions: zod_1.z.array(zod_1.z.object({
+                    name: zod_1.z.string().optional().catch(() => ""),
+                    parameters: zod_1.z.union([
+                        zod_1.z.array(zod_1.z.object({
+                            name: zod_1.z.string(),
+                            value: zod_1.z.any(),
+                        })),
+                        zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+                    ]).optional().catch(() => ({})),
+                }).passthrough().catch(() => ({ name: "", parameters: {} }))).default([]),
+                response: zod_1.z.string().catch("D'accord, compris.").default("D'accord, compris."),
+            }));
+            const llmDuration = performance.now() - t0;
+            const llmCalls = ((_e = context).llmCalls || (_e.llmCalls = []));
+            llmCalls.push({
+                promptTokens: (_b = (_a = result.usage) === null || _a === void 0 ? void 0 : _a.promptTokens) !== null && _b !== void 0 ? _b : 0,
+                completionTokens: (_d = (_c = result.usage) === null || _c === void 0 ? void 0 : _c.completionTokens) !== null && _d !== void 0 ? _d : 0,
+                duration: llmDuration,
+                timestamp: new Date().toISOString(),
+            });
+            const validActions = result.object.actions
+                .filter((a) => a && a.name && typeof a.name === 'string' && a.name.length > 0)
+                .map((action) => {
+                const p = action.parameters || {};
+                if (!Array.isArray(p)) {
+                    action.parameters = Object.entries(p).map(([name, value]) => ({
+                        name,
+                        value,
+                    }));
+                }
+                return action;
+            });
+            if (validActions.length > 0) {
+                this.log("success", chalk_1.default.green("Decided to take actions:"));
+                validActions.forEach((action) => {
+                    const params = action.parameters || {};
+                    if (Array.isArray(params)) {
+                        params.forEach((param) => {
+                            this.log("info", chalk_1.default.cyan(`  → ${action.name}(${param.name}=${JSON.stringify(param.value)})`));
+                        });
+                    }
+                    else {
+                        Object.entries(params).forEach(([key, value]) => {
+                            this.log("info", chalk_1.default.cyan(`  → ${action.name}(${key}=${JSON.stringify(value)})`));
+                        });
+                    }
+                });
+            }
+            else {
+                this.log("info", chalk_1.default.yellow("No actions needed"));
+            }
+            this.log("info", chalk_1.default.dim(`LLM Response: ${result.object.response}`));
+            if (this.verbose) {
+                this.logger.log("info", "executor", `Raw LLM result: ${JSON.stringify(result.object)}`);
+            }
+            return {
+                actions: validActions,
+                response: result.object.response,
+                thought: result.object.thought || "",
+            };
+        });
+    }
+    decomposeTask(actions, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (actions.length <= 1) {
+                return { groups: [actions], response: "Single action, no decomposition needed." };
+            }
+            const toolNames = actions.map(a => a.name).join(", ");
+            const prompt = `Analyze these ${actions.length} tool calls and group them for PARALLEL execution.
+Actions: ${JSON.stringify(actions.map(a => ({ name: a.name, params: a.parameters })))}
+Rules:
+- Group actions that are INDEPENDENT (no data dependency between them)
+- Each group runs sequentially within itself
+- Groups run in parallel with each other
+- Return the minimal number of groups
+Respond with JSON: { "groups": [[action1, action2], [action3]], "reasoning": "..." }`;
+            const schema = zod_1.z.object({
+                groups: zod_1.z.array(zod_1.z.array(zod_1.z.object({
+                    name: zod_1.z.string(),
+                    parameters: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string(), value: zod_1.z.any() })).optional(),
+                }).passthrough())),
+                reasoning: zod_1.z.string().optional(),
+            });
+            let result;
+            try {
+                result = yield this.llm.generate({ system: "You are a task decomposition expert. Group actions for optimal parallel execution.", user: prompt }, schema);
+            }
+            catch (_b) {
+                this.log("warning", chalk_1.default.yellow("Decomposition LLM call failed, running sequentially"));
+                return { groups: [actions], response: "Sequential fallback." };
+            }
+            const groups = ((_a = result.object) === null || _a === void 0 ? void 0 : _a.groups) || [actions];
+            if (!Array.isArray(groups) || groups.length === 0) {
+                return { groups: [actions], response: "No parallelization possible." };
+            }
+            const validGroups = groups.filter((g) => Array.isArray(g) && g.length > 0);
+            if (validGroups.length === 0) {
+                return { groups: [actions], response: "No parallelization possible." };
+            }
+            this.log("info", chalk_1.default.cyan(`Decomposed into ${validGroups.length} parallel groups: ${validGroups.map((g) => g.map((a) => a.name).join(", ")).join(" | ")}`));
+            return { groups: validGroups, response: `Split into ${validGroups.length} groups` };
+        });
+    }
+    /**
+     * Executes multiple workflows with their respective inputs
+     * @protected
+     * @param {GraphFlow<any>[]} workflows - Array of workflows to execute
+     * @param {string[]} startNodes - Array of starting node names for each workflow
+     * @param {any[]} inputs - Array of inputs for each workflow
+     * @param {AgentContext} context - The context in which to execute the workflows
+     * @returns {Promise<void>}
+     */
+    executeWorkflows(workflows, startNodes, inputs, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.log("info", chalk_1.default.cyan("Executing workflows:"));
+            for (let i = 0; i < workflows.length; i++) {
+                const workflow = workflows[i];
+                const startNode = startNodes[i];
+                const input = inputs[i];
+                this.log("info", chalk_1.default.dim(`Executing workflow ${workflow.name} starting at node ${startNode}`));
+                if (input.entityId && !input.path) {
+                    const handles = (_a = context === null || context === void 0 ? void 0 : context.entityState) === null || _a === void 0 ? void 0 : _a.handles;
+                    const handle = handles === null || handles === void 0 ? void 0 : handles[input.entityId];
+                    if (handle) {
+                        this.log("info", chalk_1.default.dim(`Resolved entityId "${input.entityId}" → ${handle.label}`));
+                        input.path = handle.path;
+                        delete input.entityId;
+                    }
+                    else {
+                        throw new Error(`entityId "${input.entityId}" not found in available handles. ` +
+                            `Available: ${handles ? Object.keys(handles).join(", ") : "none"}`);
+                    }
+                }
+                if (input.entityId && !input.path) {
+                    throw new Error(`Tool "${workflow.name}" called with entityId="${input.entityId}" but no path resolved. ` +
+                        `Provide a valid entityId from ENTITY REFERENCES.`);
+                }
+                if (input.target && !input.path && this.entityIndex) {
+                    const index = this.entityIndex;
+                    const resolved = index.resolveByTarget ? index.resolveByTarget(input.target) : null;
+                    if (resolved) {
+                        this.log("info", chalk_1.default.dim(`Resolved target "${input.target}" → ${resolved.filename}`));
+                        input.path = resolved.path;
+                        input.entityId = resolved.id;
+                    }
+                    delete input.target;
+                }
+                const resolvedInput = {};
+                for (const [key, value] of Object.entries(input)) {
+                    if (typeof value === 'string' && value.startsWith('$')) {
+                        let varPath = value.substring(1);
+                        let varValue = undefined;
+                        if (varPath.includes('.')) {
+                            const [varName, ...rest] = varPath.split('.');
+                            varValue = context[varName];
+                            if (varValue !== undefined) {
+                                for (const prop of rest) {
+                                    varValue = varValue === null || varValue === void 0 ? void 0 : varValue[prop];
+                                }
+                            }
+                            else {
+                                const fallback = context.executedActions.find(a => `${a.name}_result` === varName);
+                                if (fallback) {
+                                    varValue = fallback.result;
+                                    for (const prop of rest) {
+                                        varValue = varValue === null || varValue === void 0 ? void 0 : varValue[prop];
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            varValue = context[varPath];
+                            if (varValue === undefined) {
+                                const fallback = context.executedActions.find(a => `${a.name}_result` === varPath);
+                                if (fallback)
+                                    varValue = fallback.result;
+                            }
+                            if (varValue === undefined) {
+                                const lastResult = (_b = context.executedActions[context.executedActions.length - 1]) === null || _b === void 0 ? void 0 : _b.result;
+                                if (lastResult !== undefined)
+                                    varValue = lastResult;
+                            }
+                        }
+                        if (varValue !== undefined) {
+                            const extracted = typeof varValue === 'object' && (varValue === null || varValue === void 0 ? void 0 : varValue.result) !== undefined && !varPath.includes('.result')
+                                ? varValue.result
+                                : varValue;
+                            this.log("info", chalk_1.default.dim(`  Resolved \$${varPath} = ${JSON.stringify(extracted)}`));
+                            resolvedInput[key] = extracted;
+                            continue;
+                        }
+                    }
+                    resolvedInput[key] = value;
+                }
+                this.log("info", chalk_1.default.dim(`Input parameters: ${JSON.stringify(resolvedInput, null, 2)}`));
+                const coercedInput = {};
+                const schema = workflow.getSchema();
+                for (const [key, value] of Object.entries(resolvedInput)) {
+                    const fieldSchema = schema.shape[key];
+                    if (fieldSchema) {
+                        const typeName = fieldSchema._def.typeName;
+                        if (typeName === 'ZodOptional') {
+                            const inner = fieldSchema._def.innerType;
+                            const innerType = (_c = inner === null || inner === void 0 ? void 0 : inner._def) === null || _c === void 0 ? void 0 : _c.typeName;
+                            if (innerType === 'ZodNumber') {
+                                coercedInput[key] = typeof value === 'string' ? parseFloat(value) : value;
+                                continue;
+                            }
+                            if (innerType === 'ZodString') {
+                                if (typeof value === 'object' && value !== null) {
+                                    coercedInput[key] = JSON.stringify(value);
+                                }
+                                else {
+                                    coercedInput[key] = String(value);
+                                }
+                                continue;
+                            }
+                            if (innerType === 'ZodEnum') {
+                                const options = inner._def.values || [];
+                                const lowerOptions = options.map((o) => o.toLowerCase());
+                                const matchIdx = lowerOptions.indexOf(String(value).toLowerCase());
+                                coercedInput[key] = matchIdx >= 0 ? options[matchIdx] : value;
+                                continue;
+                            }
+                        }
+                        if (typeName === 'ZodNumber') {
+                            coercedInput[key] = typeof value === 'string' ? parseFloat(value) : value;
+                            continue;
+                        }
+                        if (typeName === 'ZodString') {
+                            if (typeof value === 'object' && value !== null) {
+                                coercedInput[key] = JSON.stringify(value);
+                            }
+                            else {
+                                coercedInput[key] = String(value);
+                            }
+                            continue;
+                        }
+                        if (typeName === 'ZodBoolean') {
+                            if (typeof value === 'string') {
+                                coercedInput[key] = value.toLowerCase() === 'true' || value === '1' || value === 'yes';
+                            }
+                            else {
+                                coercedInput[key] = Boolean(value) && value !== null && value !== undefined;
+                            }
+                            continue;
+                        }
+                        if (typeName === 'ZodEnum') {
+                            const options = fieldSchema._def.values || [];
+                            const lowerOptions = options.map((o) => o.toLowerCase());
+                            const matchIdx = lowerOptions.indexOf(String(value).toLowerCase());
+                            coercedInput[key] = matchIdx >= 0 ? options[matchIdx] : value;
+                            continue;
+                        }
+                    }
+                    coercedInput[key] = value;
+                }
+                const workflowContext = Object.assign(Object.assign({}, workflow.getContext()), coercedInput);
+                // Execute with merged context
+                const result = yield workflow.execute(startNode, workflowContext);
+                this.log("success", chalk_1.default.green(`Workflow ${workflow.name} completed`));
+                this.log("info", chalk_1.default.dim(`Result: ${JSON.stringify(result, null, 2)}`));
+                if (context.executedActions) {
+                    context.executedActions.push({
+                        name: workflow.name,
+                        parameters: resolvedInput,
+                        result: result,
+                        timestamp: new Date().toISOString(),
+                        isExecuted: true,
+                    });
+                }
+                const resultVarName = `${workflow.name}_result`;
+                context[resultVarName] = result;
+                if (result && typeof result === 'object' && result._handoff) {
+                    context._handoff = result._handoff;
+                }
+            }
+        });
+    }
+}
+exports.GenericExecutor = GenericExecutor;
+//# sourceMappingURL=generic-executor.js.map