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

package/lib/cjs/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/cjs/orchestrator/prompt.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TODO_WORKER_PROMPT_TEMPLATE = exports.TODO_PLANNER_PROMPT_TEMPLATE = exports.ORCHESTRATOR_COMPLETE_PROMPT = void 0;
+exports.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.
+`;
+exports.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
+`;
+exports.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.
+`;

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

@@ -0,0 +1,505 @@
+import type { Message } from "@aigne/core";
+import z from "zod";
+/**
+ * Task execution status
+ */
+export type TaskStatus = "pending" | "completed" | "failed";
+/**
+ * Individual task execution record
+ */
+export interface TaskRecord {
+    /** Task description */
+    task: string;
+    /** Task execution status */
+    status: TaskStatus;
+    /** Task execution result (can be any type) */
+    result?: unknown;
+    /** Error information if task failed */
+    error?: {
+        message: string;
+    };
+    /** Timestamp when task was created */
+    createdAt?: number;
+    /** Timestamp when task was completed or failed */
+    completedAt?: number;
+}
+/**
+ * Execution state tracking all tasks
+ */
+export interface ExecutionState {
+    tasks: TaskRecord[];
+}
+export declare const taskRecordSchema: z.ZodObject<{
+    task: z.ZodString;
+    status: z.ZodEnum<["pending", "completed", "failed"]>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "completed" | "failed";
+    task: string;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: unknown;
+    createdAt?: number | undefined;
+    completedAt?: number | undefined;
+}, {
+    status: "pending" | "completed" | "failed";
+    task: string;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: unknown;
+    createdAt?: number | undefined;
+    completedAt?: number | undefined;
+}>;
+export declare const executionStateSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        task: z.ZodString;
+        status: z.ZodEnum<["pending", "completed", "failed"]>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }, {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tasks: {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[];
+}, {
+    tasks: {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[];
+}>;
+export interface PlannerInput extends Message {
+    objective: string;
+    skills: {
+        name: string;
+        description?: string;
+    }[];
+    executionState: ExecutionState;
+}
+export declare const plannerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+    }>, "many">;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    skills: {
+        name: string;
+        description?: string | undefined;
+    }[];
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    skills: {
+        name: string;
+        description?: string | undefined;
+    }[];
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+export interface PlannerOutput extends Message {
+    nextTask?: string;
+    finished?: boolean;
+}
+export declare const plannerOutputSchema: z.ZodObject<{
+    nextTask: z.ZodOptional<z.ZodString>;
+    finished: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    nextTask?: string | undefined;
+    finished?: boolean | undefined;
+}, {
+    nextTask?: string | undefined;
+    finished?: boolean | undefined;
+}>;
+export interface WorkerInput extends Message {
+    objective: string;
+    executionState: ExecutionState;
+    task: string;
+}
+export declare const workerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    task: z.ZodString;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    task: string;
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+/**
+ * Worker output structure
+ */
+export interface WorkerOutput extends Message {
+    /** Task execution result */
+    result?: string;
+    /** Whether the task was completed successfully */
+    success: boolean;
+    /** Error information if task failed */
+    error?: {
+        message: string;
+    };
+}
+export declare const workerOutputSchema: z.ZodObject<{
+    result: z.ZodOptional<z.ZodString>;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: string | undefined;
+}, {
+    success: boolean;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: string | undefined;
+}>;
+export interface CompleterInput extends Message {
+    objective: string;
+    executionState: ExecutionState;
+}
+export declare const completerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+/**
+ * Default maximum number of task execution iterations
+ */
+export declare const DEFAULT_MAX_ITERATIONS = 20;
+/**
+ * Options for managing execution state to prevent context overflow
+ */
+export interface StateManagementOptions {
+    /**
+     * Maximum tokens allowed for execution state
+     * When exceeded, triggers compression
+     */
+    maxTokens?: number;
+    /**
+     * Number of recent tasks to keep when compression is triggered
+     */
+    keepRecent?: number;
+    /**
+     * Maximum number of task execution iterations
+     * When reached, orchestrator will stop and synthesize final result
+     * @default 20
+     */
+    maxIterations?: number;
+}
+export declare const stateManagementOptionsSchema: z.ZodObject<{
+    maxTokens: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    keepRecent: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    maxIterations: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens?: number | undefined;
+    keepRecent?: number | undefined;
+    maxIterations?: number | undefined;
+}, {
+    maxTokens?: number | undefined;
+    keepRecent?: number | undefined;
+    maxIterations?: number | undefined;
+}>;

package/lib/cjs/orchestrator/type.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateManagementOptionsSchema = exports.DEFAULT_MAX_ITERATIONS = exports.completerInputSchema = exports.workerOutputSchema = exports.workerInputSchema = exports.plannerOutputSchema = exports.plannerInputSchema = exports.executionStateSchema = exports.taskRecordSchema = void 0;
+const schema_js_1 = require("@aigne/core/loader/schema.js");
+const zod_1 = __importDefault(require("zod"));
+exports.taskRecordSchema = zod_1.default.object({
+    task: zod_1.default.string().describe("The description of the executed task."),
+    status: zod_1.default
+        .enum(["pending", "completed", "failed"])
+        .describe("The execution status of the task: pending, completed, or failed."),
+    result: zod_1.default.unknown().optional().describe("The result produced by executing the task."),
+    error: zod_1.default
+        .object({
+        message: zod_1.default.string().describe("Error message if the task failed."),
+    })
+        .optional()
+        .describe("Error information if the task failed."),
+    createdAt: zod_1.default.number().optional().describe("Timestamp when the task was created."),
+    completedAt: zod_1.default.number().optional().describe("Timestamp when the task completed or failed."),
+});
+exports.executionStateSchema = zod_1.default.object({
+    tasks: zod_1.default
+        .array(exports.taskRecordSchema)
+        .describe("The list of tasks that have been executed along with their results."),
+});
+exports.plannerInputSchema = zod_1.default.object({
+    objective: zod_1.default.string().describe("The user's overall objective."),
+    skills: zod_1.default
+        .array(zod_1.default.object({
+        name: zod_1.default.string().describe("The name of the skill."),
+        description: zod_1.default.string().optional().describe("A brief description of the skill."),
+    }))
+        .describe("The list of available skills the agent can use."),
+    executionState: exports.executionStateSchema,
+});
+exports.plannerOutputSchema = zod_1.default.object({
+    nextTask: zod_1.default
+        .string()
+        .optional()
+        .describe("The next task to be executed by the worker. Should contain a clear, actionable description of what needs to be done."),
+    finished: zod_1.default
+        .boolean()
+        .optional()
+        .describe("Indicates if all tasks are completed and the objective has been achieved. Set to true when no more work is needed."),
+});
+exports.workerInputSchema = zod_1.default.object({
+    objective: zod_1.default.string().describe("The user's overall objective."),
+    task: zod_1.default.string().describe("The specific task assigned to the worker for execution."),
+    executionState: exports.executionStateSchema,
+});
+exports.workerOutputSchema = zod_1.default.object({
+    result: zod_1.default
+        .string()
+        .optional()
+        .describe("The text result or output produced by executing the task. Include key findings, data retrieved, or actions taken. Can be omitted if the task failed with no partial results."),
+    success: zod_1.default
+        .boolean()
+        .describe("Whether the task completed successfully. Set to true if the task achieved its goal, false if it encountered errors or could not be completed."),
+    error: zod_1.default
+        .object({
+        message: zod_1.default
+            .string()
+            .describe("A clear description of what went wrong, including error type and relevant context to help with debugging or retry strategies."),
+    })
+        .optional()
+        .describe("Error details if the task failed. Only include when success is false."),
+});
+exports.completerInputSchema = zod_1.default.object({
+    objective: zod_1.default.string().describe("The user's overall objective."),
+    executionState: exports.executionStateSchema,
+});
+/**
+ * Default maximum number of task execution iterations
+ */
+exports.DEFAULT_MAX_ITERATIONS = 20;
+exports.stateManagementOptionsSchema = zod_1.default.object({
+    maxTokens: (0, schema_js_1.optionalize)(zod_1.default.number().int().positive()),
+    keepRecent: (0, schema_js_1.optionalize)(zod_1.default.number().int().positive()),
+    maxIterations: (0, schema_js_1.optionalize)(zod_1.default.number().int().positive()),
+});