@aigne/agent-library 1.22.4-beta → 1.23.0-beta

package/lib/esm/orchestrator/index.d.ts

@@ -1,50 +1,33 @@
-import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "@aigne/core";
-import { type FullPlanOutput, type StepWithResult } from "./orchestrator-prompts.js";
-/**
- * Re-export orchestrator prompt templates and related types
- */
-export * from "./orchestrator-prompts.js";
-/**
- * Represents a complete plan with execution results
- * @hidden
- */
-export interface FullPlanWithResult {
-    /**
-     * The overall objective
-     */
-    objective: string;
-    /**
-     * The generated complete plan
-     */
-    plan?: FullPlanOutput;
-    /**
-     * List of executed steps with their results
-     */
-    steps: StepWithResult[];
-    /**
-     * Final result
-     */
-    result?: string;
-    /**
-     * Plan completion status
-     */
-    status?: boolean;
-}
+import { type AgentInvokeOptions, type AgentOptions, AIAgent, type AIAgentOptions, type Message, type PromptBuilder } from "@aigne/core";
+import { type Instructions, type NestAgentSchema } from "@aigne/core/loader/agent-yaml.js";
+import { type LoadOptions } from "@aigne/core/loader/index.js";
+import { type StateManagementOptions } from "./type.js";
 /**
  * Configuration options for the Orchestrator Agent
  */
-export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
-    /**
-     * Maximum number of iterations to prevent infinite loops
-     * Default: 30
-     */
-    maxIterations?: number;
+export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends Omit<AIAgentOptions<I, O>, "instructions"> {
+    objective: PromptBuilder;
+    planner?: OrchestratorAgent<I, O>["planner"];
+    worker?: OrchestratorAgent<I, O>["worker"];
+    completer?: OrchestratorAgent<I, O>["completer"];
     /**
-     * Number of concurrent tasks
-     * Default: 5
+     * Configuration for managing execution state
+     * Prevents context overflow during long-running executions
      */
-    tasksConcurrency?: number;
-    inputKey: string;
+    stateManagement?: StateManagementOptions;
+}
+export interface LoadOrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends Omit<AIAgentOptions<I, O>, "instructions"> {
+    objective: string | PromptBuilder | Instructions;
+    planner?: NestAgentSchema | {
+        instructions?: string | PromptBuilder | Instructions;
+    };
+    worker?: NestAgentSchema | {
+        instructions?: string | PromptBuilder | Instructions;
+    };
+    completer?: NestAgentSchema | {
+        instructions?: string | PromptBuilder | Instructions;
+    };
+    stateManagement?: StateManagementOptions;
 }
 /**
  * Orchestrator Agent Class
@@ -61,8 +44,13 @@ export interface OrchestratorAgentOptions<I extends Message = Message, O extends
  * - Executes tasks and steps according to the plan
  * - Synthesizes final result through completer
  */
-export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends AIAgent<I, O> {
     tag: string;
+    static load<I extends Message = Message, O extends Message = Message>({ filepath, parsed, options, }: {
+        filepath: string;
+        parsed: AgentOptions<I, O> & LoadOrchestratorAgentOptions<I, O>;
+        options?: LoadOptions;
+    }): Promise<OrchestratorAgent<I, O>>;
     /**
      * Factory method to create an OrchestratorAgent instance
      * @param options - Configuration options for the Orchestrator Agent
@@ -74,36 +62,16 @@ export declare class OrchestratorAgent<I extends Message = Message, O extends Me
      * @param options - Configuration options for the Orchestrator Agent
      */
     constructor(options: OrchestratorAgentOptions<I, O>);
+    private objective;
     private planner;
+    private worker;
     private completer;
-    inputKey: string;
-    /**
-     * Maximum number of iterations
-     * Prevents infinite execution loops
-     */
-    maxIterations?: number;
-    /**
-     * Number of concurrent tasks
-     * Controls how many tasks can be executed simultaneously
-     */
-    tasksConcurrency?: number;
+    private stateManagement?;
     /**
-     * Process input and execute the orchestrator workflow
-     *
-     * Workflow:
-     * 1. Extract the objective
-     * 2. Loop until plan completion or maximum iterations:
-     *    a. Generate/update execution plan
-     *    b. If plan is complete, synthesize result
-     *    c. Otherwise, execute steps in the plan
-     *
-     * @param input - Input message containing the objective
-     * @param options - Agent invocation options
-     * @returns Processing result
+     * Compress execution state to prevent context overflow
+     * Uses reverse accumulation to efficiently find optimal task count
      */
-    process(input: I, options: AgentInvokeOptions): Promise<O>;
-    private getFullPlanInput;
-    private getFullPlan;
-    private synthesizePlanResult;
-    private executeStep;
+    private compressState;
+    process(input: I, options: AgentInvokeOptions): AsyncGenerator<import("@aigne/core").AgentResponseChunk<O>, void, unknown>;
 }
+export default OrchestratorAgent;

package/lib/esm/orchestrator/index.js

@@ -1,20 +1,13 @@
-import { Agent, AIAgent, PromptTemplate, } from "@aigne/core";
-import { checkArguments } from "@aigne/core/utils/type-utils.js";
-import fastq from "fastq";
+import { AIAgent, } from "@aigne/core";
+import { getInstructionsSchema, getNestAgentSchema, } from "@aigne/core/loader/agent-yaml.js";
+import { instructionsToPromptBuilder, loadNestAgent, } from "@aigne/core/loader/index.js";
+import { camelizeSchema, optionalize } from "@aigne/core/loader/schema.js";
+import { isAgent } from "@aigne/core/utils/agent-utils.js";
+import { estimateTokens } from "@aigne/core/utils/token-estimator.js";
+import { omit } from "@aigne/core/utils/type-utils.js";
 import { z } from "zod";
-import { FULL_PLAN_PROMPT_TEMPLATE, getFullPlanSchema, SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE, SYNTHESIZE_STEP_PROMPT_TEMPLATE, TASK_PROMPT_TEMPLATE, } from "./orchestrator-prompts.js";
-/**
- * Default maximum number of iterations to prevent infinite loops
- */
-const DEFAULT_MAX_ITERATIONS = 30;
-/**
- * Default number of concurrent tasks
- */
-const DEFAULT_TASK_CONCURRENCY = 5;
-/**
- * Re-export orchestrator prompt templates and related types
- */
-export * from "./orchestrator-prompts.js";
+import { ORCHESTRATOR_COMPLETE_PROMPT, TODO_PLANNER_PROMPT_TEMPLATE, TODO_WORKER_PROMPT_TEMPLATE, } from "./prompt.js";
+import { completerInputSchema, DEFAULT_MAX_ITERATIONS, plannerInputSchema, plannerOutputSchema, stateManagementOptionsSchema, workerInputSchema, workerOutputSchema, } from "./type.js";
 /**
  * Orchestrator Agent Class
  *
@@ -30,8 +23,46 @@ export * from "./orchestrator-prompts.js";
  * - Executes tasks and steps according to the plan
  * - Synthesizes final result through completer
  */
-export class OrchestratorAgent extends Agent {
+export class OrchestratorAgent extends AIAgent {
     tag = "OrchestratorAgent";
+    static async load({ filepath, parsed, options, }) {
+        const schema = getOrchestratorAgentSchema({ filepath });
+        const valid = await schema.parseAsync(parsed);
+        return new OrchestratorAgent({
+            ...parsed,
+            objective: instructionsToPromptBuilder(valid.objective),
+            planner: valid.planner
+                ? (await loadNestAgent(filepath, valid.planner, options, {
+                    name: "Planner",
+                    instructions: TODO_PLANNER_PROMPT_TEMPLATE,
+                    inputSchema: plannerInputSchema,
+                    outputSchema: plannerOutputSchema,
+                    afs: parsed.afs,
+                    skills: parsed.skills,
+                }))
+                : undefined,
+            worker: valid.worker
+                ? (await loadNestAgent(filepath, valid.worker, options, {
+                    name: "Worker",
+                    instructions: TODO_WORKER_PROMPT_TEMPLATE,
+                    inputSchema: workerInputSchema,
+                    outputSchema: workerOutputSchema,
+                    afs: parsed.afs,
+                    skills: parsed.skills,
+                }))
+                : undefined,
+            completer: valid.completer
+                ? (await loadNestAgent(filepath, valid.completer, options, {
+                    instructions: ORCHESTRATOR_COMPLETE_PROMPT,
+                    inputSchema: completerInputSchema,
+                    outputSchema: parsed.outputSchema,
+                    afs: parsed.afs,
+                    skills: parsed.skills,
+                }))
+                : undefined,
+            stateManagement: valid.stateManagement,
+        });
+    }
     /**
      * Factory method to create an OrchestratorAgent instance
      * @param options - Configuration options for the Orchestrator Agent
@@ -45,158 +76,149 @@ export class OrchestratorAgent extends Agent {
      * @param options - Configuration options for the Orchestrator Agent
      */
     constructor(options) {
-        checkArguments("OrchestratorAgent", orchestratorAgentOptionsSchema, options);
         super({ ...options });
-        this.maxIterations = options.maxIterations;
-        this.tasksConcurrency = options.tasksConcurrency;
-        this.inputKey = options.inputKey;
-        this.planner = new AIAgent({
-            name: "llm_orchestration_planner",
-            instructions: FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: () => getFullPlanSchema(this.skills),
-        });
-        this.completer = new AIAgent({
-            name: "llm_orchestration_completer",
-            instructions: FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: this.outputSchema,
-        });
+        this.objective = options.objective;
+        this.planner = isAgent(options.planner)
+            ? options.planner
+            : new AIAgent({
+                ...options,
+                name: "Planner",
+                instructions: TODO_PLANNER_PROMPT_TEMPLATE,
+                inputSchema: plannerInputSchema,
+                outputSchema: plannerOutputSchema,
+            });
+        this.worker = isAgent(options.worker)
+            ? options.worker
+            : new AIAgent({
+                ...options,
+                name: "Worker",
+                instructions: TODO_WORKER_PROMPT_TEMPLATE,
+                inputSchema: workerInputSchema,
+                outputSchema: workerOutputSchema,
+            });
+        this.completer = isAgent(options.completer)
+            ? options.completer
+            : new AIAgent({
+                ...omit(options, "inputSchema"),
+                name: "Completer",
+                instructions: ORCHESTRATOR_COMPLETE_PROMPT,
+                outputKey: options.outputKey,
+                inputSchema: completerInputSchema,
+                outputSchema: options.outputSchema,
+            });
+        // Initialize state management config
+        this.stateManagement = options.stateManagement;
     }
+    objective;
     planner;
+    worker;
     completer;
-    inputKey;
-    /**
-     * Maximum number of iterations
-     * Prevents infinite execution loops
-     */
-    maxIterations;
+    stateManagement;
     /**
-     * Number of concurrent tasks
-     * Controls how many tasks can be executed simultaneously
+     * Compress execution state to prevent context overflow
+     * Uses reverse accumulation to efficiently find optimal task count
      */
-    tasksConcurrency;
-    /**
-     * Process input and execute the orchestrator workflow
-     *
-     * Workflow:
-     * 1. Extract the objective
-     * 2. Loop until plan completion or maximum iterations:
-     *    a. Generate/update execution plan
-     *    b. If plan is complete, synthesize result
-     *    c. Otherwise, execute steps in the plan
-     *
-     * @param input - Input message containing the objective
-     * @param options - Agent invocation options
-     * @returns Processing result
-     */
-    async process(input, options) {
-        const { model } = options.context;
-        if (!model)
-            throw new Error("model is required to run OrchestratorAgent");
-        const objective = input[this.inputKey];
-        if (typeof objective !== "string")
-            throw new Error("Objective is required to run OrchestratorAgent");
-        const result = {
-            objective,
-            steps: [],
-        };
-        let iterations = 0;
-        const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-        while (iterations++ < maxIterations) {
-            const plan = await this.getFullPlan(result, options.context);
-            result.plan = plan;
-            if (plan.isComplete) {
-                return this.synthesizePlanResult(result, options.context);
+    compressState(state) {
+        const { maxTokens, keepRecent } = this.stateManagement ?? {};
+        if (!maxTokens && !keepRecent) {
+            return state;
+        }
+        const tasks = state.tasks;
+        let selectedTasks = tasks;
+        // Step 1: Apply keepRecent limit if configured
+        if (keepRecent && tasks.length > keepRecent) {
+            selectedTasks = tasks.slice(-keepRecent);
+        }
+        // Step 2: Apply maxTokens limit if configured
+        if (maxTokens && selectedTasks.length > 0) {
+            // Start from the most recent task and accumulate backwards
+            let accumulatedTokens = 0;
+            let taskCount = 0;
+            for (let i = selectedTasks.length - 1; i >= 0; i--) {
+                const taskJson = JSON.stringify(selectedTasks[i]);
+                const taskTokens = estimateTokens(taskJson);
+                if (accumulatedTokens + taskTokens > maxTokens && taskCount > 0) {
+                    // Stop if adding this task would exceed limit
+                    break;
+                }
+                accumulatedTokens += taskTokens;
+                taskCount++;
             }
-            for (const step of plan.steps) {
-                const stepResult = await this.executeStep(result, step, options.context);
-                result.steps.push(stepResult);
+            // Keep the most recent N tasks that fit within token limit
+            if (taskCount < selectedTasks.length) {
+                selectedTasks = selectedTasks.slice(-taskCount);
             }
         }
-        throw new Error(`Max iterations reached: ${maxIterations}`);
-    }
-    getFullPlanInput(planResult) {
-        return {
-            objective: planResult.objective,
-            steps: planResult.steps,
-            plan: {
-                status: planResult.status ? "Complete" : "In Progress",
-                result: planResult.result || "No results yet",
-            },
-            agents: this.skills.map((i) => ({
-                name: i.name,
-                description: i.description,
-                tools: i.skills.map((i) => ({ name: i.name, description: i.description })),
-            })),
-        };
+        return { tasks: selectedTasks };
     }
-    async getFullPlan(planResult, context) {
-        return context.invoke(this.planner, this.getFullPlanInput(planResult));
-    }
-    async synthesizePlanResult(planResult, context) {
-        return context.invoke(this.completer, {
-            ...this.getFullPlanInput(planResult),
-            message: SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE,
-        });
-    }
-    async executeStep(planResult, step, context) {
-        const concurrency = this.tasksConcurrency ?? DEFAULT_TASK_CONCURRENCY;
-        const { model } = context;
+    async *process(input, options) {
+        const model = this.model || options.model || options.context.model;
         if (!model)
             throw new Error("model is required to run OrchestratorAgent");
-        const queue = fastq.promise(async (task) => {
-            const agent = this.skills.find((skill) => skill.name === task.agent);
-            if (!agent)
-                throw new Error(`Agent ${task.agent} not found`);
-            const prompt = await PromptTemplate.from(TASK_PROMPT_TEMPLATE).format({
-                objective: planResult.objective,
-                step,
-                task,
-                steps: planResult.steps,
-            });
-            let result;
-            if (agent.isInvokable) {
-                result = getMessageOrJsonString(await context.invoke(agent, { message: prompt }));
+        const { tools: availableSkills = [] } = await this.objective.build({
+            ...options,
+            input,
+            model,
+            agent: this,
+        });
+        const skills = availableSkills.map((i) => ({
+            name: i.function.name,
+            description: i.function.description,
+        }));
+        const { prompt: objective } = await this.objective.buildPrompt({
+            input,
+            context: options.context,
+        });
+        const executionState = { tasks: [] };
+        let iterationCount = 0;
+        const maxIterations = this.stateManagement?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        while (true) {
+            // Check if maximum iterations reached
+            if (maxIterations && iterationCount >= maxIterations) {
+                console.warn(`Maximum iterations (${maxIterations}) reached. Stopping execution.`);
+                break;
             }
-            else {
-                const executor = AIAgent.from({
-                    name: "llm_orchestration_task_executor",
-                    instructions: prompt,
-                    skills: agent.skills,
-                });
-                result = getMessageOrJsonString(await context.invoke(executor, {}));
+            iterationCount++;
+            // Compress state for planner input if needed
+            const compressedState = this.compressState(executionState);
+            const plan = await this.invokeChildAgent(this.planner, { objective, skills, executionState: compressedState }, { ...options, model, streaming: false });
+            if (plan.finished || !plan.nextTask) {
+                break;
             }
-            return { task, result };
-        }, concurrency);
-        let results;
-        try {
-            results = await Promise.all(step.tasks.map((task) => queue.push(task)));
-        }
-        catch (error) {
-            queue.kill();
-            throw error;
+            const task = plan.nextTask;
+            const createdAt = Date.now();
+            const taskResult = await this.invokeChildAgent(this.worker, { objective, executionState: compressedState, task }, { ...options, model, streaming: false })
+                .then((res) => {
+                if (res.error || res.success === false) {
+                    return { status: "failed", result: res.result, error: res.error };
+                }
+                return { status: "completed", result: res.result };
+            })
+                .catch((error) => ({
+                status: "failed",
+                error: { message: error instanceof Error ? error.message : String(error) },
+            }));
+            executionState.tasks.push({
+                ...taskResult,
+                task: task,
+                createdAt,
+                completedAt: Date.now(),
+            });
         }
-        const result = getMessageOrJsonString(await context.invoke(AIAgent.from({
-            name: "llm_orchestration_step_synthesizer",
-            instructions: SYNTHESIZE_STEP_PROMPT_TEMPLATE,
-        }), { objective: planResult.objective, step, tasks: results }));
-        if (!result)
-            throw new Error("unexpected empty result from synthesize step's tasks results");
-        return {
-            step,
-            tasks: results,
-            result,
-        };
+        // Compress state for completer input if needed
+        const compressedState = this.compressState(executionState);
+        yield* await this.invokeChildAgent(this.completer, { objective, executionState: compressedState }, { ...options, model, streaming: true });
     }
 }
-function getMessageOrJsonString(output) {
-    const entries = Object.entries(output);
-    const firstValue = entries[0]?.[1];
-    if (entries.length === 1 && typeof firstValue === "string") {
-        return firstValue;
-    }
-    return JSON.stringify(output);
+export default OrchestratorAgent;
+function getOrchestratorAgentSchema({ filepath }) {
+    const nestAgentSchema = getNestAgentSchema({ filepath });
+    const instructionsSchema = getInstructionsSchema({ filepath });
+    return camelizeSchema(z.object({
+        objective: instructionsSchema,
+        planner: optionalize(nestAgentSchema),
+        worker: optionalize(nestAgentSchema),
+        completer: optionalize(nestAgentSchema),
+        stateManagement: optionalize(camelizeSchema(stateManagementOptionsSchema)),
+    }));
 }
-const orchestratorAgentOptionsSchema = z.object({
-    maxIterations: z.number().optional(),
-    tasksConcurrency: z.number().optional(),
-});

package/lib/esm/orchestrator/prompt.d.ts

@@ -0,0 +1,3 @@
+export declare const ORCHESTRATOR_COMPLETE_PROMPT = "You are an intelligent assistant that synthesizes and presents the results of completed tasks.\n\n## User Objective\n{{ objective }}\n\n## Execution Results\n{{ executionState | yaml.stringify }}\n\n## Your Task\nBased on the execution results above, provide a comprehensive and helpful response to the user's objective.\n";
+export declare const TODO_PLANNER_PROMPT_TEMPLATE = "You are an intelligent task planner that determines what needs to be done next to achieve the user's objective.\n\n## Your Role\nContinuously evaluate progress and decide the next task to execute. You work iteratively - planning one task at a time based on the current state and previous results.\n\n## Available Skills\n{{ skills | yaml.stringify }}\n\n## User Objective\n{{ objective }}\n\n## Current State\n{{ executionState | yaml.stringify }}\n\n## Understanding Task Status\nEach task in the execution state has a status:\n- **completed**: Task finished successfully, result is available\n- **failed**: Task encountered an error, check error field for details\n- **pending**: Task has not been executed yet\n\n## Your Task\nBased on the objective, current state, and any previous results, determine what should happen next:\n\n1. **If the objective is achieved or all work is complete:** Set finished: true and leave nextTask empty\n2. **If a previous task failed:** Decide whether to retry, skip, or use an alternative approach\n3. **If more work is needed:** Provide a clear, actionable nextTask description\n\n### Guidelines:\n- Focus on the immediate next step, not the entire plan\n- Review task history to avoid repeating work and build on previous results\n- Pay attention to task status - handle failures appropriately\n- Write self-contained task descriptions that the worker can execute independently\n- Set finished: true when the objective is satisfied\n- Consider retrying failed tasks with different approaches if appropriate\n";
+export declare const TODO_WORKER_PROMPT_TEMPLATE = "You are a task execution agent. Your job is to execute the specific task assigned to you - nothing more, nothing less.\n\n## Overall Objective (For Context Only)\n{{ objective }}\n\n**CRITICAL CONSTRAINT**: The objective above is provided ONLY for context. You must NOT attempt to:\n- Solve the entire objective\n- Plan additional steps beyond your current task\n- Make decisions about what should happen next\n- Execute any tasks other than the one explicitly assigned to you below\n\nYour SOLE responsibility is to execute the specific task described below and return the result.\n\n## Current Execution State\n{{ executionState | yaml.stringify }}\n\n## Your Current Task\n{{ task }}\n\n## Important Instructions\n- Focus EXCLUSIVELY on completing the current task described above\n- The task is self-contained - execute it completely and accurately\n- Do NOT perform additional tasks beyond what is specified\n- Do NOT try to determine what should happen after this task\n- Use the available tools and skills to accomplish this specific task\n- Return a clear result that the planner can use to decide the next step\n\n## Output Format\nReturn your task execution result as a structured response. The output schema will guide you on the required fields.\n";

package/lib/esm/orchestrator/prompt.js

@@ -0,0 +1,79 @@
+export const ORCHESTRATOR_COMPLETE_PROMPT = `\
+You are an intelligent assistant that synthesizes and presents the results of completed tasks.
+
+## User Objective
+{{ objective }}
+
+## Execution Results
+{{ executionState | yaml.stringify }}
+
+## Your Task
+Based on the execution results above, provide a comprehensive and helpful response to the user's objective.
+`;
+export const TODO_PLANNER_PROMPT_TEMPLATE = `\
+You are an intelligent task planner that determines what needs to be done next to achieve the user's objective.
+
+## Your Role
+Continuously evaluate progress and decide the next task to execute. You work iteratively - planning one task at a time based on the current state and previous results.
+
+## Available Skills
+{{ skills | yaml.stringify }}
+
+## User Objective
+{{ objective }}
+
+## Current State
+{{ executionState | yaml.stringify }}
+
+## Understanding Task Status
+Each task in the execution state has a status:
+- **completed**: Task finished successfully, result is available
+- **failed**: Task encountered an error, check error field for details
+- **pending**: Task has not been executed yet
+
+## Your Task
+Based on the objective, current state, and any previous results, determine what should happen next:
+
+1. **If the objective is achieved or all work is complete:** Set finished: true and leave nextTask empty
+2. **If a previous task failed:** Decide whether to retry, skip, or use an alternative approach
+3. **If more work is needed:** Provide a clear, actionable nextTask description
+
+### Guidelines:
+- Focus on the immediate next step, not the entire plan
+- Review task history to avoid repeating work and build on previous results
+- Pay attention to task status - handle failures appropriately
+- Write self-contained task descriptions that the worker can execute independently
+- Set finished: true when the objective is satisfied
+- Consider retrying failed tasks with different approaches if appropriate
+`;
+export const TODO_WORKER_PROMPT_TEMPLATE = `\
+You are a task execution agent. Your job is to execute the specific task assigned to you - nothing more, nothing less.
+
+## Overall Objective (For Context Only)
+{{ objective }}
+
+**CRITICAL CONSTRAINT**: The objective above is provided ONLY for context. You must NOT attempt to:
+- Solve the entire objective
+- Plan additional steps beyond your current task
+- Make decisions about what should happen next
+- Execute any tasks other than the one explicitly assigned to you below
+
+Your SOLE responsibility is to execute the specific task described below and return the result.
+
+## Current Execution State
+{{ executionState | yaml.stringify }}
+
+## Your Current Task
+{{ task }}
+
+## Important Instructions
+- Focus EXCLUSIVELY on completing the current task described above
+- The task is self-contained - execute it completely and accurately
+- Do NOT perform additional tasks beyond what is specified
+- Do NOT try to determine what should happen after this task
+- Use the available tools and skills to accomplish this specific task
+- Return a clear result that the planner can use to decide the next step
+
+## Output Format
+Return your task execution result as a structured response. The output schema will guide you on the required fields.
+`;