@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-planning/services/planning-service.js

@@ -0,0 +1,875 @@
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../../../logger.js";
+import { asUUID, ModelType, Service, } from "../../../types/index.js";
+import { parseKeyValueXml } from "../../../utils.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeActionParameters(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(value);
+            if (isRecord(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {};
+}
+function normalizeDependencyStrings(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((entry) => String(entry).trim())
+                    .filter((entry) => entry.length > 0);
+            }
+        }
+        catch {
+            return [value.trim()];
+        }
+    }
+    return [];
+}
+class PlanWorkingMemory {
+    memory = new Map();
+    set(key, value) {
+        this.memory.set(key, value);
+    }
+    get(key) {
+        return this.memory.get(key);
+    }
+    has(key) {
+        return this.memory.has(key);
+    }
+    delete(key) {
+        return this.memory.delete(key);
+    }
+    clear() {
+        this.memory.clear();
+    }
+    entries() {
+        return this.memory.entries();
+    }
+    serialize() {
+        return Object.fromEntries(this.memory);
+    }
+}
+export class PlanningService extends Service {
+    static serviceType = "planning";
+    serviceType = "planning";
+    capabilityDescription = "Planning and action coordination";
+    activePlans = new Map();
+    planExecutions = new Map();
+    static async start(runtime) {
+        const service = new PlanningService(runtime);
+        logger.info("PlanningService started successfully");
+        return service;
+    }
+    async createSimplePlan(_runtime, message, _state, responseContent) {
+        try {
+            let actions = [];
+            if (responseContent?.actions && responseContent.actions.length > 0) {
+                actions = responseContent.actions;
+            }
+            else {
+                const text = message.content.text?.toLowerCase() || "";
+                if (text.includes("email")) {
+                    actions = ["SEND_EMAIL"];
+                }
+                else if (text.includes("research") &&
+                    (text.includes("send") || text.includes("summary"))) {
+                    actions = ["SEARCH", "REPLY"];
+                }
+                else if (text.includes("search") ||
+                    text.includes("find") ||
+                    text.includes("research")) {
+                    actions = ["SEARCH"];
+                }
+                else if (text.includes("analyze")) {
+                    actions = ["THINK", "REPLY"];
+                }
+                else {
+                    actions = ["REPLY"];
+                }
+            }
+            if (actions.length === 0) {
+                return null;
+            }
+            const planId = asUUID(uuidv4());
+            const stepIds = [];
+            const steps = actions.map((actionName, index) => {
+                const stepId = asUUID(uuidv4());
+                stepIds.push(stepId);
+                return {
+                    id: stepId,
+                    actionName,
+                    parameters: {
+                        message: responseContent?.text || message.content.text || "",
+                        thought: responseContent?.thought || "",
+                        providers: responseContent?.providers || [],
+                    },
+                    dependencies: index > 0 ? [stepIds[index - 1]] : [],
+                };
+            });
+            const plan = {
+                id: planId,
+                goal: responseContent?.text || `Execute actions: ${actions.join(", ")}`,
+                thought: responseContent?.thought || `Executing ${actions.length} action(s)`,
+                totalSteps: steps.length,
+                currentStep: 0,
+                steps,
+                executionModel: "sequential",
+                state: { status: "pending" },
+                metadata: {
+                    createdAt: Date.now(),
+                    estimatedDuration: steps.length * 5000,
+                    priority: 1,
+                    tags: ["simple", "message-handling"],
+                },
+            };
+            this.activePlans.set(planId, plan);
+            return plan;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error.message : String(error);
+            logger.error({ src: "service:planning", err }, "Error creating simple plan");
+            return null;
+        }
+    }
+    async createComprehensivePlan(runtime, context, message, state) {
+        if (!context.goal || context.goal.trim() === "") {
+            throw new Error("Planning context must have a non-empty goal");
+        }
+        if (!Array.isArray(context.constraints)) {
+            throw new Error("Planning context constraints must be an array");
+        }
+        if (!Array.isArray(context.availableActions)) {
+            throw new Error("Planning context availableActions must be an array");
+        }
+        if (!context.preferences || typeof context.preferences !== "object") {
+            throw new Error("Planning context preferences must be an object");
+        }
+        const planningPrompt = this.buildPlanningPrompt(context, message, state);
+        const planningResponse = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt: planningPrompt,
+            temperature: 0.3,
+            maxTokens: 2000,
+        });
+        const parsedPlan = this.parsePlanningResponse(String(planningResponse), context);
+        const enhancedPlan = await this.enhancePlan(runtime, parsedPlan);
+        if (!enhancedPlan.id) {
+            throw new Error("Enhanced plan missing id");
+        }
+        this.activePlans.set(enhancedPlan.id, enhancedPlan);
+        return enhancedPlan;
+    }
+    async executePlan(runtime, plan, message, callback) {
+        const startTime = Date.now();
+        const workingMemory = new PlanWorkingMemory();
+        const results = [];
+        const errors = [];
+        const abortController = new AbortController();
+        const executionState = {
+            status: "running",
+            startTime,
+            currentStepIndex: 0,
+        };
+        if (!plan.id) {
+            throw new Error("Plan missing id");
+        }
+        this.planExecutions.set(plan.id, {
+            state: executionState,
+            workingMemory: workingMemory.serialize(),
+            results,
+            abortController,
+        });
+        const actionByName = this.buildActionLookup(runtime);
+        try {
+            if (plan.executionModel === "sequential") {
+                await this.executeSequential(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortController.signal);
+            }
+            else if (plan.executionModel === "parallel") {
+                await this.executeParallel(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortController.signal);
+            }
+            else if (plan.executionModel === "dag") {
+                await this.executeDAG(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortController.signal);
+            }
+            else {
+                throw new Error(`Unsupported execution model: ${plan.executionModel}`);
+            }
+            executionState.status = errors.length > 0 ? "failed" : "completed";
+            executionState.endTime = Date.now();
+            return {
+                planId: plan.id,
+                success: errors.length === 0,
+                completedSteps: results.length,
+                totalSteps: plan.steps.length,
+                results,
+                errors: errors.length > 0 ? errors : undefined,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            executionState.status = "failed";
+            executionState.endTime = Date.now();
+            executionState.error =
+                error instanceof Error ? error.message : String(error);
+            const err = error instanceof Error ? error : new Error(String(error));
+            return {
+                planId: plan.id,
+                success: false,
+                completedSteps: results.length,
+                totalSteps: plan.steps.length,
+                results,
+                errors: [err, ...errors],
+                duration: Date.now() - startTime,
+            };
+        }
+        finally {
+            this.planExecutions.delete(plan.id);
+        }
+    }
+    async validatePlan(runtime, plan) {
+        const issues = [];
+        const actionByName = this.buildActionLookup(runtime);
+        if (!plan.id || !plan.goal || !plan.steps) {
+            issues.push("Plan missing required fields (id, goal, or steps)");
+        }
+        if (plan.steps.length === 0) {
+            issues.push("Plan has no steps");
+        }
+        for (const step of plan.steps) {
+            if (!step.id || !step.actionName) {
+                issues.push("Step missing required fields (id or actionName)");
+                continue;
+            }
+            if (!actionByName.has(step.actionName)) {
+                issues.push(`Action '${step.actionName}' not found in runtime`);
+            }
+        }
+        const stepIds = new Set(plan.steps.map((s) => s.id).filter((id) => Boolean(id)));
+        for (const step of plan.steps) {
+            if (step.dependencies) {
+                for (const depId of step.dependencies) {
+                    if (!stepIds.has(depId)) {
+                        issues.push(`Step '${String(step.id)}' has invalid dependency '${String(depId)}'`);
+                    }
+                }
+            }
+        }
+        if (plan.executionModel === "dag") {
+            const hasCycle = this.detectCycles(plan.steps);
+            if (hasCycle) {
+                issues.push("Plan has circular dependencies");
+            }
+        }
+        return {
+            valid: issues.length === 0,
+            errors: issues,
+            warnings: [],
+        };
+    }
+    async adaptPlan(runtime, plan, currentStepIndex, results, error) {
+        const adaptationPrompt = this.buildAdaptationPrompt(plan, currentStepIndex, results, error);
+        const adaptationResponse = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt: adaptationPrompt,
+            temperature: 0.4,
+            maxTokens: 1500,
+        });
+        const adaptedPlan = this.parseAdaptationResponse(String(adaptationResponse), plan, currentStepIndex);
+        if (plan.id) {
+            this.activePlans.set(plan.id, adaptedPlan);
+        }
+        return adaptedPlan;
+    }
+    async getPlanStatus(planId) {
+        const execution = this.planExecutions.get(planId);
+        return execution?.state || null;
+    }
+    async cancelPlan(planId) {
+        const execution = this.planExecutions.get(planId);
+        if (!execution) {
+            return false;
+        }
+        execution.abortController?.abort();
+        execution.state.status = "cancelled";
+        execution.state.endTime = Date.now();
+        return true;
+    }
+    async stop() {
+        for (const [, execution] of this.planExecutions) {
+            execution.abortController?.abort();
+            execution.state.status = "cancelled";
+            execution.state.endTime = Date.now();
+        }
+        this.planExecutions.clear();
+        this.activePlans.clear();
+    }
+    buildPlanningPrompt(context, message, state) {
+        const availableActions = (context.availableActions || []).join(", ");
+        const constraints = (context.constraints || [])
+            .map((c) => `${c.type}: ${c.description || c.value}`)
+            .join(", ");
+        return `You are an expert AI planning system. Create a comprehensive action plan to achieve the following goal.
+
+GOAL: ${context.goal}
+
+AVAILABLE ACTIONS: ${availableActions}
+CONSTRAINTS: ${constraints}
+
+EXECUTION MODEL: ${context.preferences?.executionModel || "sequential"}
+MAX STEPS: ${context.preferences?.maxSteps || 10}
+
+${message ? `CONTEXT MESSAGE: ${message.content.text}` : ""}
+${state ? `CURRENT STATE: ${JSON.stringify(state.values)}` : ""}
+
+Create a detailed plan with the following TOON structure:
+goal: ${context.goal}
+execution_model: ${context.preferences?.executionModel || "sequential"}
+steps[0]:
+  id: step_1
+  action: ACTION_NAME
+  parameters:
+    key: value
+  dependencies[0]: step_0
+  description: What this step accomplishes
+estimated_duration: Total estimated time in milliseconds
+
+Focus on:
+1. Breaking down the goal into logical, executable steps
+2. Ensuring each step uses available actions
+3. Managing dependencies between steps
+4. Providing realistic time estimates
+5. Including error handling considerations`;
+    }
+    parsePlanningResponse(response, context) {
+        try {
+            const parsedResponse = parseKeyValueXml(response);
+            const planId = asUUID(uuidv4());
+            const steps = [];
+            const goal = (typeof parsedResponse?.goal === "string"
+                ? parsedResponse.goal
+                : null) || context.goal;
+            const executionModel = (typeof parsedResponse?.execution_model === "string"
+                ? parsedResponse.execution_model
+                : null) ||
+                context.preferences?.executionModel ||
+                "sequential";
+            const estimatedDurationRaw = parsedResponse?.estimated_duration;
+            const estimatedDuration = typeof estimatedDurationRaw === "number"
+                ? estimatedDurationRaw
+                : Number.parseInt(String(estimatedDurationRaw ?? "30000"), 10) ||
+                    30000;
+            const stepIdMap = new Map();
+            const toonSteps = Array.isArray(parsedResponse?.steps)
+                ? parsedResponse.steps.filter(isRecord)
+                : [];
+            if (toonSteps.length > 0) {
+                for (const step of toonSteps) {
+                    const actionName = typeof step.action === "string"
+                        ? step.action.trim()
+                        : typeof step.actionName === "string"
+                            ? step.actionName.trim()
+                            : "";
+                    if (!actionName) {
+                        continue;
+                    }
+                    const originalId = typeof step.id === "string" && step.id.trim().length > 0
+                        ? step.id.trim()
+                        : `step_${steps.length + 1}`;
+                    const actualId = asUUID(uuidv4());
+                    stepIdMap.set(originalId, actualId);
+                    steps.push({
+                        id: actualId,
+                        actionName,
+                        parameters: normalizeActionParameters(step.parameters),
+                        dependencies: [],
+                        _dependencyStrings: normalizeDependencyStrings(step.dependencies),
+                    });
+                }
+            }
+            else {
+                const stepMatches = response.match(/<step>(.*?)<\/step>/gs) || [];
+                for (const stepMatch of stepMatches) {
+                    const idMatch = stepMatch.match(/<id>(.*?)<\/id>/);
+                    const actionMatch = stepMatch.match(/<action>(.*?)<\/action>/);
+                    const parametersMatch = stepMatch.match(/<parameters>(.*?)<\/parameters>/);
+                    const dependenciesMatch = stepMatch.match(/<dependencies>(.*?)<\/dependencies>/);
+                    if (!actionMatch || !idMatch) {
+                        continue;
+                    }
+                    const originalId = idMatch[1].trim();
+                    const actualId = asUUID(uuidv4());
+                    stepIdMap.set(originalId, actualId);
+                    steps.push({
+                        id: actualId,
+                        actionName: actionMatch[1].trim(),
+                        parameters: normalizeActionParameters(parametersMatch?.[1]),
+                        dependencies: [],
+                        _dependencyStrings: normalizeDependencyStrings(dependenciesMatch?.[1]),
+                    });
+                }
+            }
+            for (const step of steps) {
+                const dependencyStrings = step._dependencyStrings || [];
+                const dependencies = [];
+                for (const depString of dependencyStrings) {
+                    const resolvedId = stepIdMap.get(depString);
+                    if (resolvedId) {
+                        dependencies.push(resolvedId);
+                    }
+                }
+                step.dependencies = dependencies;
+                delete step._dependencyStrings;
+            }
+            if (steps.length === 0 && response.includes("<step>")) {
+                const firstId = asUUID(uuidv4());
+                steps.push({
+                    id: firstId,
+                    actionName: "ANALYZE_INPUT",
+                    parameters: { goal: context.goal },
+                    dependencies: [],
+                });
+                if (context.goal.toLowerCase().includes("plan") ||
+                    context.goal.toLowerCase().includes("strategy")) {
+                    const secondId = asUUID(uuidv4());
+                    steps.push({
+                        id: secondId,
+                        actionName: "PROCESS_ANALYSIS",
+                        parameters: { type: "strategic_planning" },
+                        dependencies: [firstId],
+                    });
+                    steps.push({
+                        id: asUUID(uuidv4()),
+                        actionName: "EXECUTE_FINAL",
+                        parameters: { deliverable: "strategy_document" },
+                        dependencies: [secondId],
+                    });
+                }
+            }
+            return {
+                id: planId,
+                goal,
+                thought: `Plan to achieve: ${goal}`,
+                totalSteps: steps.length,
+                currentStep: 0,
+                steps,
+                executionModel: executionModel,
+                state: { status: "pending" },
+                metadata: {
+                    createdAt: Date.now(),
+                    estimatedDuration,
+                    priority: 1,
+                    tags: ["comprehensive"],
+                },
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to build action plan: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async enhancePlan(runtime, plan) {
+        for (const step of plan.steps) {
+            const normalize = (s) => s.toLowerCase().replace(/_/g, "");
+            const stepName = step.actionName ?? "";
+            const stepNorm = normalize(stepName);
+            const action = runtime.actions.find((a) => {
+                const nameMatch = normalize(a.name) === stepNorm;
+                const simileMatch = (a.similes ?? []).some((s) => normalize(s) === stepNorm);
+                return nameMatch || simileMatch;
+            });
+            if (!action) {
+                const missing = step.actionName ?? "";
+                step.actionName = "REPLY";
+                step.parameters = { text: `Unable to find action: ${missing}` };
+            }
+        }
+        for (const step of plan.steps) {
+            if (!step.retryPolicy) {
+                step.retryPolicy = {
+                    maxRetries: 2,
+                    backoffMs: 1000,
+                    backoffMultiplier: 2,
+                    onError: "abort",
+                };
+            }
+        }
+        return plan;
+    }
+    async executeSequential(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortSignal) {
+        for (let i = 0; i < plan.steps.length; i++) {
+            if (abortSignal?.aborted) {
+                throw new Error("Plan execution aborted");
+            }
+            const step = plan.steps[i];
+            try {
+                const result = await this.executeStep(runtime, actionByName, step, message, workingMemory, results, callback, abortSignal);
+                results.push(result);
+                if (plan.id) {
+                    const execution = this.planExecutions.get(plan.id);
+                    if (execution) {
+                        execution.state.currentStepIndex = i + 1;
+                    }
+                }
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                errors.push(err);
+                const onError = step.onError ?? step.retryPolicy?.onError ?? "abort";
+                if (onError === "abort") {
+                    throw err;
+                }
+            }
+        }
+    }
+    async executeParallel(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortSignal) {
+        const promises = plan.steps.map(async (step) => {
+            try {
+                const result = await this.executeStep(runtime, actionByName, step, message, workingMemory, results, callback, abortSignal);
+                return { result, error: null };
+            }
+            catch (e) {
+                return {
+                    result: null,
+                    error: e instanceof Error ? e : new Error(String(e)),
+                };
+            }
+        });
+        const stepResults = await Promise.all(promises);
+        for (const { result, error } of stepResults) {
+            if (error) {
+                errors.push(error);
+            }
+            else if (result) {
+                results.push(result);
+            }
+        }
+    }
+    async executeDAG(runtime, actionByName, plan, message, workingMemory, results, errors, callback, abortSignal) {
+        const order = this.buildDagExecutionOrder(plan.steps);
+        const stepById = new Map();
+        for (const step of plan.steps) {
+            if (step.id) {
+                stepById.set(step.id, step);
+            }
+        }
+        for (const stepId of order) {
+            if (abortSignal?.aborted) {
+                throw new Error("Plan execution aborted");
+            }
+            const step = stepById.get(stepId);
+            if (!step)
+                continue;
+            try {
+                const result = await this.executeStep(runtime, actionByName, step, message, workingMemory, results, callback, abortSignal);
+                results.push(result);
+            }
+            catch (e) {
+                errors.push(e instanceof Error ? e : new Error(String(e)));
+            }
+        }
+    }
+    async executeStep(runtime, actionByName, step, message, workingMemory, previousResults, callback, abortSignal) {
+        if (!step.actionName) {
+            throw new Error("Step missing actionName");
+        }
+        const action = actionByName.get(step.actionName);
+        if (!action) {
+            throw new Error(`Action '${step.actionName}' not found`);
+        }
+        const actionContext = {
+            previousResults,
+            getPreviousResult: (actionName) => previousResults.find((r) => {
+                const data = (r.data ?? {});
+                return (data.actionName === actionName ||
+                    data.stepId === (step.id ? String(step.id) : ""));
+            }),
+        };
+        let retries = 0;
+        const maxRetries = step.retryPolicy?.maxRetries ?? 0;
+        while (retries <= maxRetries) {
+            if (abortSignal?.aborted) {
+                throw new Error("Plan execution aborted");
+            }
+            try {
+                const options = {
+                    actionContext,
+                    parameters: step.parameters,
+                    context: {
+                        workingMemory: workingMemory.serialize(),
+                    },
+                    abortSignal,
+                    previousResults,
+                };
+                const result = await action.handler(runtime, message, { values: {}, data: {}, text: "" }, options, callback);
+                const actionResult = typeof result === "object" && result !== null
+                    ? result
+                    : { text: String(result), success: true };
+                if (!actionResult.data) {
+                    actionResult.data = {};
+                }
+                const data = actionResult.data;
+                data.stepId = step.id ? String(step.id) : "";
+                data.actionName = step.actionName;
+                data.executedAt = Date.now();
+                return actionResult;
+            }
+            catch (error) {
+                retries++;
+                if (retries > maxRetries) {
+                    throw error;
+                }
+                const backoffMs = (step.retryPolicy?.backoffMs ?? 1000) *
+                    (step.retryPolicy?.backoffMultiplier ?? 2) ** (retries - 1);
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+            }
+        }
+        throw new Error("Maximum retries exceeded");
+    }
+    detectCycles(steps) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (stepId) => {
+            if (recursionStack.has(stepId))
+                return true;
+            if (visited.has(stepId))
+                return false;
+            visited.add(stepId);
+            recursionStack.add(stepId);
+            const step = steps.find((s) => s.id === stepId);
+            if (step?.dependencies) {
+                for (const depId of step.dependencies) {
+                    if (dfs(depId))
+                        return true;
+                }
+            }
+            recursionStack.delete(stepId);
+            return false;
+        };
+        for (const step of steps) {
+            if (step.id && dfs(step.id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    buildActionLookup(runtime) {
+        const actionByName = new Map();
+        for (const action of runtime.actions) {
+            actionByName.set(action.name, action);
+        }
+        return actionByName;
+    }
+    buildDagExecutionOrder(steps) {
+        const depsRemaining = new Map();
+        const dependents = new Map();
+        const indexById = new Map();
+        for (let i = 0; i < steps.length; i += 1) {
+            const id = steps[i]?.id;
+            if (!id)
+                continue;
+            const dependencies = steps[i].dependencies ?? [];
+            depsRemaining.set(id, dependencies.length);
+            indexById.set(id, i);
+            for (const dep of dependencies) {
+                const list = dependents.get(dep);
+                if (list) {
+                    list.push(id);
+                }
+                else {
+                    dependents.set(dep, [id]);
+                }
+            }
+        }
+        const readyHeap = [];
+        for (const [id, idx] of indexById) {
+            if ((depsRemaining.get(id) ?? 0) === 0) {
+                this.pushReadyStep(readyHeap, idx);
+            }
+        }
+        const order = [];
+        while (readyHeap.length > 0) {
+            const idx = this.popReadyStep(readyHeap);
+            if (idx === undefined)
+                break;
+            const step = steps[idx];
+            if (!step?.id)
+                continue;
+            const stepId = step.id;
+            order.push(stepId);
+            const nextSteps = dependents.get(stepId);
+            if (!nextSteps)
+                continue;
+            for (const nextId of nextSteps) {
+                const remaining = depsRemaining.get(nextId);
+                if (remaining === undefined || remaining <= 0)
+                    continue;
+                const updated = remaining - 1;
+                depsRemaining.set(nextId, updated);
+                if (updated === 0) {
+                    const nextIdx = indexById.get(nextId);
+                    if (nextIdx !== undefined) {
+                        this.pushReadyStep(readyHeap, nextIdx);
+                    }
+                }
+            }
+        }
+        if (order.length !== indexById.size) {
+            throw new Error("No steps ready to execute - possible circular dependency");
+        }
+        return order;
+    }
+    pushReadyStep(heap, value) {
+        heap.push(value);
+        let index = heap.length - 1;
+        while (index > 0) {
+            const parent = Math.floor((index - 1) / 2);
+            if (heap[parent] <= heap[index])
+                break;
+            const tmp = heap[parent];
+            heap[parent] = heap[index];
+            heap[index] = tmp;
+            index = parent;
+        }
+    }
+    popReadyStep(heap) {
+        if (heap.length === 0)
+            return undefined;
+        const result = heap[0];
+        const last = heap.pop();
+        if (last === undefined || heap.length === 0) {
+            return result;
+        }
+        heap[0] = last;
+        let index = 0;
+        const length = heap.length;
+        while (true) {
+            const left = index * 2 + 1;
+            const right = left + 1;
+            if (left >= length)
+                break;
+            let smallest = left;
+            if (right < length && heap[right] < heap[left]) {
+                smallest = right;
+            }
+            if (heap[index] <= heap[smallest])
+                break;
+            const tmp = heap[index];
+            heap[index] = heap[smallest];
+            heap[smallest] = tmp;
+            index = smallest;
+        }
+        return result;
+    }
+    buildAdaptationPrompt(plan, currentStepIndex, results, error) {
+        return `You are an expert AI adaptation system. A plan execution has encountered an issue and needs adaptation.
+
+ORIGINAL PLAN: ${JSON.stringify(plan, null, 2)}
+CURRENT STEP INDEX: ${currentStepIndex}
+COMPLETED RESULTS: ${JSON.stringify(results, null, 2)}
+${error ? `ERROR: ${error.message}` : ""}
+
+Analyze the situation and provide an adapted plan that:
+1. Addresses the current issue
+2. Maintains the original goal
+3. Uses available actions effectively
+4. Considers what has already been completed
+
+Return the adapted plan in the same TOON format as the original planning response.`;
+    }
+    parseAdaptationResponse(response, originalPlan, currentStepIndex) {
+        try {
+            const adaptedSteps = [];
+            const parsedResponse = parseKeyValueXml(response);
+            const toonSteps = Array.isArray(parsedResponse?.steps)
+                ? parsedResponse.steps.filter(isRecord)
+                : [];
+            if (toonSteps.length > 0) {
+                for (const step of toonSteps) {
+                    const actionName = typeof step.action === "string"
+                        ? step.action.trim()
+                        : typeof step.actionName === "string"
+                            ? step.actionName.trim()
+                            : "";
+                    if (!actionName)
+                        continue;
+                    adaptedSteps.push({
+                        id: asUUID(uuidv4()),
+                        actionName,
+                        parameters: normalizeActionParameters(step.parameters),
+                        dependencies: [],
+                    });
+                }
+            }
+            else {
+                const stepMatches = response.match(/<step>(.*?)<\/step>/gs) || [];
+                for (const stepMatch of stepMatches) {
+                    const idMatch = stepMatch.match(/<id>(.*?)<\/id>/);
+                    const actionMatch = stepMatch.match(/<action>(.*?)<\/action>/);
+                    const parametersMatch = stepMatch.match(/<parameters>(.*?)<\/parameters>/);
+                    if (!actionMatch || !idMatch)
+                        continue;
+                    adaptedSteps.push({
+                        id: asUUID(uuidv4()),
+                        actionName: actionMatch[1].trim(),
+                        parameters: normalizeActionParameters(parametersMatch?.[1]),
+                        dependencies: [],
+                    });
+                }
+            }
+            if (adaptedSteps.length === 0) {
+                adaptedSteps.push({
+                    id: asUUID(uuidv4()),
+                    actionName: "REPLY",
+                    parameters: { text: "Plan adaptation completed successfully" },
+                    dependencies: [],
+                });
+            }
+            const prevMeta = originalPlan.metadata ?? {};
+            const prevAdaptations = (prevMeta.adaptations ?? []);
+            const nextAdaptations = Array.isArray(prevAdaptations)
+                ? [...prevAdaptations, `Adapted at step ${currentStepIndex}`]
+                : [`Adapted at step ${currentStepIndex}`];
+            return {
+                ...originalPlan,
+                id: asUUID(uuidv4()),
+                steps: [
+                    ...originalPlan.steps.slice(0, currentStepIndex),
+                    ...adaptedSteps,
+                ],
+                metadata: {
+                    ...prevMeta,
+                    adaptations: nextAdaptations,
+                },
+            };
+        }
+        catch {
+            return {
+                ...originalPlan,
+                id: asUUID(uuidv4()),
+                steps: [
+                    ...originalPlan.steps.slice(0, currentStepIndex),
+                    {
+                        id: asUUID(uuidv4()),
+                        actionName: "REPLY",
+                        parameters: { text: "Plan adaptation completed successfully" },
+                        dependencies: [],
+                    },
+                ],
+            };
+        }
+    }
+}