@aigne/agent-library 1.24.0 → 1.74.0-beta

package/lib/cjs/data-mapper/tools.js

@@ -1,164 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyJsonataWithValidation = applyJsonataWithValidation;
-exports.applyJsonata = applyJsonata;
-exports.extendJsonata = extendJsonata;
-exports.addNullableToOptional = addNullableToOptional;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const jsonata_1 = __importDefault(require("jsonata"));
-const jsonschema_1 = require("jsonschema");
-async function applyJsonataWithValidation(data, expr, schema) {
-    try {
-        const result = await applyJsonata(data, expr);
-        if (result === null ||
-            result === undefined ||
-            (Array.isArray(result) && result.length === 0) ||
-            (typeof result === "object" && Object.keys(result).length === 0)) {
-            return { success: false, error: "Result is empty" };
-        }
-        const validator = new jsonschema_1.Validator();
-        const optionalSchema = addNullableToOptional(schema);
-        const validation = validator.validate(result, optionalSchema);
-        if (!validation.valid) {
-            return {
-                success: false,
-                error: validation.errors
-                    .map((e) => `${e.stack}. Source: ${e.instance ? JSON.stringify(e.instance) : "undefined"}`)
-                    .join("\n")
-                    .slice(0, 5000),
-            };
-        }
-        return { success: true, data: result };
-    }
-    catch (error) {
-        return { success: false, error: `Validation failed: ${error.message}` };
-    }
-}
-async function applyJsonata(data, expr) {
-    try {
-        const expression = extendJsonata(expr);
-        const result = await expression.evaluate(data);
-        return result;
-    }
-    catch (error) {
-        throw new Error(`JSONata evaluation failed for expression "${expr}": ${error.message}`);
-    }
-}
-function extendJsonata(expr) {
-    const expression = (0, jsonata_1.default)(expr);
-    expression.registerFunction("max", (arr) => {
-        if (Array.isArray(arr)) {
-            return Math.max(...arr.map(Number).filter((n) => !Number.isNaN(n)));
-        }
-        return arr;
-    });
-    expression.registerFunction("min", (arr) => {
-        if (Array.isArray(arr)) {
-            return Math.min(...arr.map(Number).filter((n) => !Number.isNaN(n)));
-        }
-        return arr;
-    });
-    expression.registerFunction("number", (value) => Number.parseFloat(value));
-    expression.registerFunction("substring", (str, start, end) => String(str).substring(start, end));
-    expression.registerFunction("replace", (obj, pattern, replacement) => {
-        if (Array.isArray(obj)) {
-            return obj.map((item) => String(item).replace(pattern, replacement));
-        }
-        if (typeof obj === "object") {
-            return Object.fromEntries(Object.entries(obj || {}).map(([key, value]) => [
-                key,
-                String(value).replace(pattern, replacement),
-            ]));
-        }
-        return String(obj).replace(pattern, replacement);
-    });
-    expression.registerFunction("toDate", (date) => {
-        try {
-            // Handle numeric timestamps (milliseconds or seconds)
-            if (typeof date === "number" || /^\d+$/.test(date)) {
-                const timestamp = typeof date === "number" ? date : Number.parseInt(date, 10);
-                // If timestamp is in seconds (typically 10 digits), convert to milliseconds
-                const millisTimestamp = timestamp < 10000000000 ? timestamp * 1000 : timestamp;
-                return new Date(millisTimestamp).toISOString();
-            }
-            // Handle date strings in MM/DD/YYYY format
-            const match = String(date).match(/^(\d{2})\/(\d{2})\/(\d{4})(?:\s+(\d{2}):(\d{2}):(\d{2}))?$/);
-            if (match) {
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                const [_, month, day, year, hours = "00", minutes = "00", seconds = "00"] = match;
-                const isoDate = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.000Z`;
-                return new Date(isoDate).toISOString();
-            }
-            // Default case: try standard Date parsing
-            return new Date(date).toISOString();
-        }
-        catch (e) {
-            throw new Error(`Invalid date: ${e.message}`);
-        }
-    });
-    expression.registerFunction("dateMax", (dates) => dates.reduce((max, curr) => (new Date(max) > new Date(curr) ? max : curr)));
-    expression.registerFunction("dateMin", (dates) => dates.reduce((min, curr) => (new Date(min) < new Date(curr) ? min : curr)));
-    expression.registerFunction("dateDiff", (date1, date2, unit = "days") => {
-        const d1 = new Date(date1);
-        const d2 = new Date(date2);
-        const diff = Math.abs(d1.getTime() - d2.getTime());
-        switch (unit.toLowerCase()) {
-            case "seconds":
-                return Math.floor(diff / 1000);
-            case "minutes":
-                return Math.floor(diff / (1000 * 60));
-            case "hours":
-                return Math.floor(diff / (1000 * 60 * 60));
-            case "days":
-                return Math.floor(diff / (1000 * 60 * 60 * 24));
-            default:
-                return diff; // milliseconds
-        }
-    });
-    return expression;
-}
-function addNullableToOptional(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    const newSchema = { ...schema };
-    if (schema.type === "object" && schema.properties) {
-        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
-            // biome-ignore lint/performance/noAccumulatingSpread: false positive
-            ...acc,
-            [key]: !required.has(key) ? makeNullable(value) : addNullableToOptional(value),
-        }), {});
-    }
-    if (schema.type === "array" && schema.items) {
-        newSchema.items = addNullableToOptional(schema.items);
-    }
-    return newSchema;
-}
-function makeNullable(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    const newSchema = { ...schema };
-    if (Array.isArray(schema.type)) {
-        if (!schema.type.includes("null")) {
-            newSchema.type = [...schema.type, "null"];
-        }
-    }
-    else if (schema.type) {
-        newSchema.type = [schema.type, "null"];
-    }
-    // Recursively process nested properties
-    if (schema.properties) {
-        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
-            // biome-ignore lint/performance/noAccumulatingSpread: false positive
-            ...acc,
-            [key]: makeNullable(value),
-        }), {});
-    }
-    if (schema.items) {
-        newSchema.items = makeNullable(schema.items);
-    }
-    return newSchema;
-}

package/lib/cjs/index.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/cjs/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,78 +0,0 @@
-import { type AgentInvokeOptions, type AgentOptions, AIAgent, type AIAgentOptions, type Message, type PromptBuilder } from "@aigne/core";
-import { type NestAgentSchema } from "@aigne/core/loader/agent-yaml.js";
-import type { AgentLoadOptions } from "@aigne/core/loader/index.js";
-import { type Instructions } from "@aigne/core/loader/schema.js";
-import { type ZodType } from "zod";
-import { type StateManagementOptions } from "./type.js";
-/**
- * Configuration options for the Orchestrator Agent
- */
-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"];
-    /**
-     * Configuration for managing execution state
-     * Prevents context overflow during long-running executions
-     */
-    stateManagement?: StateManagementOptions;
-    concurrency?: number;
-}
-export interface LoadOrchestratorAgentOptions {
-    objective?: string | Instructions;
-    planner?: NestAgentSchema;
-    worker?: NestAgentSchema;
-    completer?: NestAgentSchema;
-    stateManagement?: StateManagementOptions;
-}
-/**
- * Orchestrator Agent Class
- *
- * This Agent is responsible for:
- * 1. Generating an execution plan based on the objective
- * 2. Breaking down the plan into steps and tasks
- * 3. Coordinating the execution of steps and tasks
- * 4. Synthesizing the final result
- *
- * Workflow:
- * - Receives input objective
- * - Uses planner to create execution plan
- * - 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 AIAgent<I, O> {
-    tag: string;
-    static schema<T>({ filepath }: {
-        filepath: string;
-    }): ZodType<T>;
-    static load<I extends Message = Message, O extends Message = Message>({ filepath, parsed, options, }: {
-        filepath: string;
-        parsed: LoadOrchestratorAgentOptions & AgentOptions<I, O>;
-        options?: AgentLoadOptions;
-    }): Promise<OrchestratorAgent<I, O>>;
-    /**
-     * Factory method to create an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     * @returns A new OrchestratorAgent instance
-     */
-    static from<I extends Message, O extends Message>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
-    /**
-     * Creates an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     */
-    constructor(options: OrchestratorAgentOptions<I, O>);
-    private objective?;
-    private planner;
-    private worker;
-    private completer;
-    private stateManagement?;
-    private concurrency;
-    /**
-     * Compress execution state to prevent context overflow
-     * Uses reverse accumulation to efficiently find optimal task count
-     */
-    private compressState;
-    process(input: I, options: AgentInvokeOptions): AsyncGenerator<import("@aigne/core").AgentResponseChunk<O>, void, unknown>;
-}
-export default OrchestratorAgent;

package/lib/cjs/orchestrator/index.js

@@ -1,277 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrchestratorAgent = void 0;
-const core_1 = require("@aigne/core");
-const agent_yaml_js_1 = require("@aigne/core/loader/agent-yaml.js");
-const schema_js_1 = require("@aigne/core/loader/schema.js");
-const agent_utils_js_1 = require("@aigne/core/utils/agent-utils.js");
-const fastq = __importStar(require("@aigne/core/utils/queue.js"));
-const token_estimator_js_1 = require("@aigne/core/utils/token-estimator.js");
-const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
-const zod_1 = require("zod");
-const prompt_js_1 = require("./prompt.js");
-const type_js_1 = require("./type.js");
-const defaultPlannerOptions = {
-    name: "Planner",
-    instructions: prompt_js_1.TODO_PLANNER_PROMPT_TEMPLATE,
-    inputSchema: type_js_1.plannerInputSchema,
-    outputSchema: type_js_1.plannerOutputSchema,
-};
-const defaultWorkerOptions = {
-    name: "Worker",
-    taskTitle: "Execute Task: {{task}}",
-    instructions: prompt_js_1.TODO_WORKER_PROMPT_TEMPLATE,
-    inputSchema: type_js_1.workerInputSchema,
-    outputSchema: type_js_1.workerOutputSchema,
-};
-const defaultCompleterOptions = {
-    name: "Completer",
-    instructions: prompt_js_1.ORCHESTRATOR_COMPLETE_PROMPT,
-    inputSchema: type_js_1.completerInputSchema,
-};
-const DEFAULT_CONCURRENCY = 5;
-/**
- * Orchestrator Agent Class
- *
- * This Agent is responsible for:
- * 1. Generating an execution plan based on the objective
- * 2. Breaking down the plan into steps and tasks
- * 3. Coordinating the execution of steps and tasks
- * 4. Synthesizing the final result
- *
- * Workflow:
- * - Receives input objective
- * - Uses planner to create execution plan
- * - Executes tasks and steps according to the plan
- * - Synthesizes final result through completer
- */
-class OrchestratorAgent extends core_1.AIAgent {
-    tag = "OrchestratorAgent";
-    static schema({ filepath }) {
-        const nestAgentSchema = (0, agent_yaml_js_1.getNestAgentSchema)({ filepath });
-        const instructionsSchema = (0, schema_js_1.getInstructionsSchema)({ filepath });
-        return (0, schema_js_1.camelizeSchema)(zod_1.z.object({
-            objective: (0, schema_js_1.optionalize)(instructionsSchema),
-            planner: (0, schema_js_1.optionalize)(nestAgentSchema),
-            worker: (0, schema_js_1.optionalize)(nestAgentSchema),
-            completer: (0, schema_js_1.optionalize)(nestAgentSchema),
-            stateManagement: (0, schema_js_1.optionalize)((0, schema_js_1.camelizeSchema)(type_js_1.stateManagementOptionsSchema)),
-            concurrency: (0, schema_js_1.optionalize)(zod_1.z.number().int().min(1).default(DEFAULT_CONCURRENCY)),
-        }));
-    }
-    static async load({ filepath, parsed, options, }) {
-        const valid = await OrchestratorAgent.schema({
-            filepath,
-        }).parseAsync(parsed);
-        return new OrchestratorAgent({
-            ...parsed,
-            objective: valid.objective ? (0, schema_js_1.instructionsToPromptBuilder)(valid.objective) : undefined,
-            planner: valid.planner
-                ? (await options?.loadNestAgent(filepath, valid.planner, options, {
-                    ...defaultPlannerOptions,
-                    afs: parsed.afs,
-                    skills: parsed.skills,
-                }))
-                : undefined,
-            worker: valid.worker
-                ? (await options?.loadNestAgent(filepath, valid.worker, options, {
-                    ...defaultWorkerOptions,
-                    afs: parsed.afs,
-                    skills: parsed.skills,
-                }))
-                : undefined,
-            completer: valid.completer
-                ? (await options?.loadNestAgent(filepath, valid.completer, options, {
-                    ...defaultCompleterOptions,
-                    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
-     * @returns A new OrchestratorAgent instance
-     */
-    static from(options) {
-        return new OrchestratorAgent(options);
-    }
-    /**
-     * Creates an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     */
-    constructor(options) {
-        super({ ...options });
-        this.objective = options.objective;
-        this.planner = (0, agent_utils_js_1.isAgent)(options.planner)
-            ? options.planner
-            : new core_1.AIAgent({
-                ...options,
-                ...defaultPlannerOptions,
-            });
-        this.worker = (0, agent_utils_js_1.isAgent)(options.worker)
-            ? options.worker
-            : new core_1.AIAgent({
-                ...options,
-                ...defaultWorkerOptions,
-            });
-        this.completer = (0, agent_utils_js_1.isAgent)(options.completer)
-            ? options.completer
-            : new core_1.AIAgent({
-                ...(0, type_utils_js_1.omit)(options, "inputSchema"),
-                ...defaultCompleterOptions,
-                outputKey: options.outputKey,
-                outputSchema: options.outputSchema,
-            });
-        // Initialize state management config
-        this.stateManagement = options.stateManagement;
-        this.concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-    }
-    objective;
-    planner;
-    worker;
-    completer;
-    stateManagement;
-    concurrency;
-    /**
-     * Compress execution state to prevent context overflow
-     * Uses reverse accumulation to efficiently find optimal task count
-     */
-    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 = (0, token_estimator_js_1.estimateTokens)(taskJson);
-                if (accumulatedTokens + taskTokens > maxTokens && taskCount > 0) {
-                    // Stop if adding this task would exceed limit
-                    break;
-                }
-                accumulatedTokens += taskTokens;
-                taskCount++;
-            }
-            // Keep the most recent N tasks that fit within token limit
-            if (taskCount < selectedTasks.length) {
-                selectedTasks = selectedTasks.slice(-taskCount);
-            }
-        }
-        return { tasks: selectedTasks };
-    }
-    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 objective = (await this.objective?.buildPrompt({
-            input,
-            context: options.context,
-        }))?.prompt;
-        const executionState = { tasks: [] };
-        let iterationCount = 0;
-        const maxIterations = this.stateManagement?.maxIterations ?? type_js_1.DEFAULT_MAX_ITERATIONS;
-        while (true) {
-            // Check if maximum iterations reached
-            if (maxIterations && iterationCount >= maxIterations) {
-                console.warn(`Maximum iterations (${maxIterations}) reached. Stopping execution.`);
-                executionState.tasks.push({
-                    status: "failed",
-                    error: { message: `ERROR: Maximum iterations (${maxIterations}) reached` },
-                    task: `ERROR: Objective not completed within iteration limit of ${maxIterations}`,
-                    createdAt: Date.now(),
-                    completedAt: Date.now(),
-                });
-                break;
-            }
-            iterationCount++;
-            // Compress state for planner input if needed
-            const compressedState = this.compressState(executionState);
-            const plan = await this.invokeChildAgent(this.planner, {
-                objective,
-                executionState: compressedState,
-                ...(0, type_utils_js_1.pick)(input, this.planner.inputKeys),
-            }, { ...options, model, streaming: false });
-            if (plan.finished || !plan.nextTasks?.length) {
-                break;
-            }
-            const createdAt = Date.now();
-            const queue = fastq.promise(async ({ task }) => {
-                const taskResult = await this.invokeChildAgent(this.worker, {
-                    objective,
-                    executionState: compressedState,
-                    task,
-                    ...(0, type_utils_js_1.pick)(input, this.worker.inputKeys),
-                }, { ...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) },
-                }));
-                return { ...taskResult, task, createdAt, completedAt: Date.now() };
-            }, plan.parallelTasks ? this.concurrency : 1);
-            const taskResults = await Promise.all(plan.nextTasks.map((task) => queue.push({ task })));
-            executionState.tasks.push(...taskResults);
-        }
-        // Compress state for completer input if needed
-        const compressedState = this.compressState(executionState);
-        yield* await this.invokeChildAgent(this.completer, {
-            objective,
-            executionState: compressedState,
-            ...(0, type_utils_js_1.pick)(input, this.completer.inputKeys),
-        }, { ...options, model, streaming: true });
-    }
-}
-exports.OrchestratorAgent = OrchestratorAgent;
-exports.default = OrchestratorAgent;

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

@@ -1,3 +0,0 @@
-export declare const ORCHESTRATOR_COMPLETE_PROMPT = "You are an intelligent assistant that synthesizes and presents the results of completed tasks.\n\n{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's latest objective you need to address\"\n{{ objective }}\n```\n\n## Current Execution State\n\n```yaml alt=\"The latest execution state\"\n{{ executionState | yaml.stringify }}\n```\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 = "Your responsibility is to decide the next tasks based on the current execution state.\n\n## Responsibilities\n\nYou are the Planner in the Orchestrator. The entire Orchestrator completes tasks through collaboration of three roles:\n\n1. **Planner (you)** analyzes the current state and outputs \"nextTasks\" (one or more tasks)\n2. **Worker** executes the tasks and updates the execution state\n3. **Loop back to step 1**, Planner plans the next tasks based on the new state\n4. **Repeat steps 1-3** until Planner determines the objective is complete\n5. **Planner** sets \"finished: true\"\n6. **Completer** generates the final report and returns it to the user\n\n{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's next objective you need to plan for\"\n{{ objective }}\n```\n\n## Current Execution State\n\n```yaml alt=\"The latest execution state\"\n{{ executionState | yaml.stringify }}\n```\n\n## How to Plan Tasks\n\n### 1. Determine if Tasks Are Needed\n\nFirst, assess whether the objective requires any tasks at all. Ask yourself:\n\n**Does this objective require tasks?**\n\nConsider if completing the objective needs:\n- **Information gathering**: Does it need to collect or retrieve information?\n- **Analysis or processing**: Does it need to analyze, process, or compute something?\n- **State dependency**: Does it depend on information not yet in the execution state?\n\n**Set \"finished: true\" immediately when:**\n- The objective requires no exploration, analysis, or information gathering\n- The current execution state already contains everything needed to respond\n- The objective is purely conversational without requiring any action\n\n**Plan tasks when:**\n- The objective requires gathering information from external sources\n- The objective requires analysis, processing, or computation to be performed\n- Additional information must be collected before a complete response can be given\n\n### 2. Analyze Information Requirements\n\nIf tasks are needed, think about the current state and objective:\n- What information is needed to complete the objective?\n- Where can this information be obtained from?\n- What information has already been collected? What is still missing?\n- Is deeper exploration needed, or is it ready to generate a summary?\n\n### 3. Decision Principles\n\n- **Plan one or more tasks per iteration**: You can output multiple tasks when they are independent\n- **Only decide, don't execute**: You only output task descriptions, actual execution is done by the Worker\n- **Trust the iterative process**: You will be called again after tasks complete, allowing you to adjust the plan dynamically\n- **Avoid duplicate work**: Review the execution history to understand what has been completed\n- **Goal-oriented descriptions**: Task descriptions should state \"what to do\", not \"how to do it\"\n- **Handle failures appropriately**: If a previous task failed, decide whether to retry, skip, or use an alternative approach\n\n### 4. Parallel vs Sequential Execution\n\nYou can specify whether tasks should run in parallel or sequentially using `parallelTasks`.\n\n**IMPORTANT: When tasks run in parallel, they CANNOT see each other's results.** Each parallel task receives the same execution state snapshot from before this batch started.\n\n**Set `parallelTasks: true` ONLY when ALL conditions are met:**\n- Tasks operate on **completely independent** data sources or resources\n- Task results are **not needed by other tasks** in the same batch\n- Tasks have **no ordering requirements** between them\n- You are **100% certain** there are no dependencies\n\n**Set `parallelTasks: false` (default) when ANY of these apply:**\n- Any task needs results from another task in the same batch\n- Tasks must be executed in a specific order\n- Tasks operate on shared resources that could conflict\n- You are **uncertain** whether tasks are truly independent\n\n**When in doubt, use sequential execution.** It's safer to be slower than to produce incorrect results.\n\n### 5. Decision Making at Different Stages\n\nFlexibly decide the next step based on current progress:\n\n**Exploration Stage**:\n- Plan exploration tasks to gather required information\n- If exploring multiple independent sources, consider parallel execution\n\n**Processing Stage**:\n- Process gathered information\n- Use sequential execution when processing depends on previous results\n\n**Summary Stage**:\n- When sufficient information is collected, plan to generate a summary or report task\n\n**Completion Stage**:\n- Set \"finished: true\" when:\n  - The objective doesn't require any tasks\n  - All necessary tasks are completed\n  - The objective is fully achieved\n- This will trigger the Completer to integrate all information and generate the final report\n\n## Understanding Task Status\n\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## Output Format\n\n```yaml\nnextTasks:            # List of tasks to execute (omit if finished)\n  - \"task description 1\"\n  - \"task description 2\"\nparallelTasks: false  # true if tasks can run in parallel, false for sequential (default: false)\nfinished: false       # true if objective is achieved and no more tasks needed\n```\n\n**Notes:**\n- Task descriptions should be **goal-oriented**, not specifying concrete operations\n- Let the worker autonomously decide how to complete each task\n- Default to sequential execution (`parallelTasks: false`) unless you're certain tasks are independent\n- When `finished: true`, omit `nextTasks`\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{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's objective provide for context only\"\n{{ objective }}\n```\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\n## Latest Execution State\n\n```yaml alt=\"The latest execution state for your reference\"\n{{ executionState | yaml.stringify }}\n```\n\n## Your Current Task\n\n```txt alt=\"The specific task you need to execute now\"\n{{ task }}\n```\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";