@aigne/agent-library 1.22.4 → 1.23.0-beta

package/CHANGELOG.md

@@ -7,6 +7,21 @@
     * @aigne/core bumped to 1.22.0
     * @aigne/openai bumped to 0.3.4
 
+## [1.23.0-beta](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.22.4...agent-library-v1.23.0-beta) (2025-12-07)
+
+
+### Features
+
+* support define agent by third library & orchestrator agent refactor ([#799](https://github.com/AIGNE-io/aigne-framework/issues/799)) ([7264b11](https://github.com/AIGNE-io/aigne-framework/commit/7264b11ab6eed787e928367f09aa08d254968d40))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.71.0-beta
+    * @aigne/openai bumped to 0.16.15-beta
+
 ## [1.22.4](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.22.4-beta...agent-library-v1.22.4) (2025-12-06)
 
 

package/README.md

@@ -54,101 +54,13 @@ yarn add @aigne/agent-library @aigne/core
 pnpm add @aigne/agent-library @aigne/core
 ```
 
-## Basic Usage
-
-```typescript
-import { OrchestratorAgent } from "@aigne/agent-library/orchestrator";
-import { AIGNE } from "@aigne/core";
-import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
-
-// Create AI model instance
-const model = new OpenAIChatModel({
-  apiKey: process.env.OPENAI_API_KEY,
-  model: "gpt-4-turbo",
-});
-
-// Create AIGNE
-const aigne = new AIGNE({ model });
-
-// Create orchestrator agent
-const orchestrator = new OrchestratorAgent({
-  name: "MainOrchestrator",
-  instructions:
-    "You are a task orchestrator responsible for coordinating multiple specialized agents to complete complex tasks.",
-  // Configure sub-agents and tools...
-});
-
-// Execute orchestration task
-const result = await aigne.invoke(
-  orchestrator,
-  "Analyze this article and generate a summary and keywords",
-);
-console.log(result);
-```
+## Components
 
-## Provided Agent Types
-
-The library currently provides one specialized agent implementation:
-
-* **Orchestrator Agent (OrchestratorAgent)**: Responsible for coordinating work between multiple agents and managing complex workflows. It can automatically plan task steps, distribute and execute tasks across multiple agents, and finally synthesize the results.
-
-## Advanced Usage
-
-### Creating an Orchestration Workflow
-
-```typescript
-import { OrchestratorAgent } from "@aigne/agent-library/orchestrator";
-import { AIAgent, AIGNE } from "@aigne/core";
-import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
-
-const model = new OpenAIChatModel({
-  apiKey: process.env.OPENAI_API_KEY,
-  model: "gpt-4-turbo",
-});
-
-// Create specialized sub-agents
-const researchAgent = AIAgent.from({
-  name: "Researcher",
-  instructions:
-    "You are a professional researcher responsible for collecting and analyzing information.",
-  outputKey: "research",
-});
-
-const writerAgent = AIAgent.from({
-  name: "Writer",
-  instructions:
-    "You are a professional writer responsible for creating high-quality content.",
-  outputKey: "content",
-});
-
-const editorAgent = AIAgent.from({
-  name: "Editor",
-  instructions:
-    "You are a strict editor responsible for checking content quality and formatting.",
-  outputKey: "edited",
-});
-
-// Create orchestrator agent
-const orchestrator = new OrchestratorAgent({
-  name: "WorkflowOrchestrator",
-  instructions:
-    "You are responsible for coordinating research, writing, and editing processes.",
-  skills: [researchAgent, writerAgent, editorAgent],
-  // Optional configuration
-  maxIterations: 30, // Maximum number of iterations
-  tasksConcurrency: 5, // Task concurrency
-});
-
-// Use the orchestrator agent
-const aigne = new AIGNE({ model });
-
-const result = await aigne.invoke(
-  orchestrator,
-  "Applications of artificial intelligence in healthcare",
-);
-
-console.log(result);
-```
+The library provides the following components:
+
+### Agent Types
+
+* **[Orchestrator Agent](src/orchestrator/README.md)**: A sophisticated agent pattern that enables autonomous task planning and execution through a three-phase architecture: Planner → Worker → Completer. It breaks down complex objectives into manageable tasks, executes them iteratively, and synthesizes the final results. Perfect for coordinating complex workflows and multi-step tasks.
 
 ## License
 

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

@@ -1,40 +1,16 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 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 index_js_1 = require("@aigne/core/loader/index.js");
+const schema_js_1 = require("@aigne/core/loader/schema.js");
+const agent_utils_js_1 = require("@aigne/core/utils/agent-utils.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 fastq_1 = __importDefault(require("fastq"));
 const zod_1 = require("zod");
-const orchestrator_prompts_js_1 = require("./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
- */
-__exportStar(require("./orchestrator-prompts.js"), exports);
+const prompt_js_1 = require("./prompt.js");
+const type_js_1 = require("./type.js");
 /**
  * Orchestrator Agent Class
  *
@@ -50,8 +26,46 @@ __exportStar(require("./orchestrator-prompts.js"), exports);
  * - Executes tasks and steps according to the plan
  * - Synthesizes final result through completer
  */
-class OrchestratorAgent extends core_1.Agent {
+class OrchestratorAgent extends core_1.AIAgent {
     tag = "OrchestratorAgent";
+    static async load({ filepath, parsed, options, }) {
+        const schema = getOrchestratorAgentSchema({ filepath });
+        const valid = await schema.parseAsync(parsed);
+        return new OrchestratorAgent({
+            ...parsed,
+            objective: (0, index_js_1.instructionsToPromptBuilder)(valid.objective),
+            planner: valid.planner
+                ? (await (0, index_js_1.loadNestAgent)(filepath, valid.planner, options, {
+                    name: "Planner",
+                    instructions: prompt_js_1.TODO_PLANNER_PROMPT_TEMPLATE,
+                    inputSchema: type_js_1.plannerInputSchema,
+                    outputSchema: type_js_1.plannerOutputSchema,
+                    afs: parsed.afs,
+                    skills: parsed.skills,
+                }))
+                : undefined,
+            worker: valid.worker
+                ? (await (0, index_js_1.loadNestAgent)(filepath, valid.worker, options, {
+                    name: "Worker",
+                    instructions: prompt_js_1.TODO_WORKER_PROMPT_TEMPLATE,
+                    inputSchema: type_js_1.workerInputSchema,
+                    outputSchema: type_js_1.workerOutputSchema,
+                    afs: parsed.afs,
+                    skills: parsed.skills,
+                }))
+                : undefined,
+            completer: valid.completer
+                ? (await (0, index_js_1.loadNestAgent)(filepath, valid.completer, options, {
+                    instructions: prompt_js_1.ORCHESTRATOR_COMPLETE_PROMPT,
+                    inputSchema: type_js_1.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
@@ -65,159 +79,150 @@ class OrchestratorAgent extends core_1.Agent {
      * @param options - Configuration options for the Orchestrator Agent
      */
     constructor(options) {
-        (0, type_utils_js_1.checkArguments)("OrchestratorAgent", orchestratorAgentOptionsSchema, options);
         super({ ...options });
-        this.maxIterations = options.maxIterations;
-        this.tasksConcurrency = options.tasksConcurrency;
-        this.inputKey = options.inputKey;
-        this.planner = new core_1.AIAgent({
-            name: "llm_orchestration_planner",
-            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: () => (0, orchestrator_prompts_js_1.getFullPlanSchema)(this.skills),
-        });
-        this.completer = new core_1.AIAgent({
-            name: "llm_orchestration_completer",
-            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: this.outputSchema,
-        });
+        this.objective = options.objective;
+        this.planner = (0, agent_utils_js_1.isAgent)(options.planner)
+            ? options.planner
+            : new core_1.AIAgent({
+                ...options,
+                name: "Planner",
+                instructions: prompt_js_1.TODO_PLANNER_PROMPT_TEMPLATE,
+                inputSchema: type_js_1.plannerInputSchema,
+                outputSchema: type_js_1.plannerOutputSchema,
+            });
+        this.worker = (0, agent_utils_js_1.isAgent)(options.worker)
+            ? options.worker
+            : new core_1.AIAgent({
+                ...options,
+                name: "Worker",
+                instructions: prompt_js_1.TODO_WORKER_PROMPT_TEMPLATE,
+                inputSchema: type_js_1.workerInputSchema,
+                outputSchema: type_js_1.workerOutputSchema,
+            });
+        this.completer = (0, agent_utils_js_1.isAgent)(options.completer)
+            ? options.completer
+            : new core_1.AIAgent({
+                ...(0, type_utils_js_1.omit)(options, "inputSchema"),
+                name: "Completer",
+                instructions: prompt_js_1.ORCHESTRATOR_COMPLETE_PROMPT,
+                outputKey: options.outputKey,
+                inputSchema: type_js_1.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 = (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++;
             }
-            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 })),
-            })),
-        };
-    }
-    async getFullPlan(planResult, context) {
-        return context.invoke(this.planner, this.getFullPlanInput(planResult));
+        return { tasks: selectedTasks };
     }
-    async synthesizePlanResult(planResult, context) {
-        return context.invoke(this.completer, {
-            ...this.getFullPlanInput(planResult),
-            message: orchestrator_prompts_js_1.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_1.default.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 core_1.PromptTemplate.from(orchestrator_prompts_js_1.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 ?? 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.`);
+                break;
             }
-            else {
-                const executor = core_1.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(core_1.AIAgent.from({
-            name: "llm_orchestration_step_synthesizer",
-            instructions: orchestrator_prompts_js_1.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 });
     }
 }
 exports.OrchestratorAgent = OrchestratorAgent;
-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);
+exports.default = OrchestratorAgent;
+function getOrchestratorAgentSchema({ filepath }) {
+    const nestAgentSchema = (0, agent_yaml_js_1.getNestAgentSchema)({ filepath });
+    const instructionsSchema = (0, agent_yaml_js_1.getInstructionsSchema)({ filepath });
+    return (0, schema_js_1.camelizeSchema)(zod_1.z.object({
+        objective: 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)),
+    }));
 }
-const orchestratorAgentOptionsSchema = zod_1.z.object({
-    maxIterations: zod_1.z.number().optional(),
-    tasksConcurrency: zod_1.z.number().optional(),
-});

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";