@aigne/agent-library 1.2.0 → 1.3.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 - chore: release 1.2.0
 
+## [1.3.1](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.3.0...agent-library-v1.3.1) (2025-03-26)
+
+
+### Bug Fixes
+
+* **orchestrator:** refactor and enhance orchestrator with step synthesis ([#31](https://github.com/AIGNE-io/aigne-framework/issues/31)) ([ba9fca0](https://github.com/AIGNE-io/aigne-framework/commit/ba9fca04fad71d49c8f4f52172b56668a94ea714))
+
+## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.2.0...agent-library-v1.3.0) (2025-03-24)
+
+
+### Features
+
+* **core:** add ChatModelClaude to use models of anthropic ([#30](https://github.com/AIGNE-io/aigne-framework/issues/30)) ([0a62a64](https://github.com/AIGNE-io/aigne-framework/commit/0a62a6499e3da723a4646e67952051708ce7de6a))
+* **core:** add support for subscribing topics for agent memory ([#28](https://github.com/AIGNE-io/aigne-framework/issues/28)) ([eeecc67](https://github.com/AIGNE-io/aigne-framework/commit/eeecc67049a60ebcc4cdba0fbcd987b3d81f4af6))
+
+
+### Bug Fixes
+
+* rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
+
 ## 1.1.0-beta.17 (2025-3-18)
 
 - chore: add support for esm module

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

@@ -1,40 +1,27 @@
-import type { AgentOptions, AgentOutput, Context } from "@aigne/core-next";
-import type { AgentInput } from "@aigne/core-next";
-import { Agent } from "@aigne/core-next";
-import { type FullPlanOutput, type Step } from "./orchestrator-prompts.js";
-export interface StepResult {
-    step: Step;
-    task_results: Array<TaskWithResult>;
-}
-export interface TaskWithResult {
-    description: string;
-    agent: string;
-    result: string;
-}
-export interface PlanResult extends AgentOutput {
+import { Agent, type AgentOptions, type Context, type Message } from "@aigne/core";
+import { type FullPlanOutput, type StepWithResult } from "./orchestrator-prompts.js";
+export * from "./orchestrator-prompts.js";
+export interface FullPlanWithResult {
     objective: string;
     plan?: FullPlanOutput;
-    is_complete?: boolean;
+    steps: StepWithResult[];
     result?: string;
-    step_results: StepResult[];
-}
-export interface FullPlanInput extends AgentInput {
-    objective: string;
-    plan_result: string;
-    agents: string;
+    status?: boolean;
 }
-export interface OrchestratorAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     maxIterations?: number;
+    tasksConcurrency?: number;
 }
-export declare class OrchestratorAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
+export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
     constructor(options: OrchestratorAgentOptions<I, O>);
     private planner;
     private completer;
     maxIterations?: number;
+    tasksConcurrency?: number;
     process(input: I, context?: Context): Promise<O>;
+    private getFullPlanInput;
     private getFullPlan;
+    private synthesizePlanResult;
     private executeStep;
-    private formatPlanResult;
-    private formatStepsResults;
 }

package/lib/cjs/orchestrator/index.js

@@ -1,120 +1,158 @@
 "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_next_1 = require("@aigne/core-next");
+const core_1 = require("@aigne/core");
+const fastq_1 = __importDefault(require("fastq"));
 const orchestrator_prompts_js_1 = require("./orchestrator-prompts.js");
 const DEFAULT_MAX_ITERATIONS = 30;
-class OrchestratorAgent extends core_next_1.Agent {
+const DEFAULT_TASK_CONCURRENCY = 5;
+__exportStar(require("./orchestrator-prompts.js"), exports);
+class OrchestratorAgent extends core_1.Agent {
     static from(options) {
         return new OrchestratorAgent(options);
     }
     constructor(options) {
         super({ ...options });
         this.maxIterations = options.maxIterations;
-        this.planner = new core_next_1.AIAgent({
+        this.tasksConcurrency = options.tasksConcurrency;
+        this.planner = new core_1.AIAgent({
             name: "llm_orchestration_planner",
             instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: orchestrator_prompts_js_1.FullPlanSchema,
+            outputSchema: () => (0, orchestrator_prompts_js_1.getFullPlanSchema)(this.tools),
         });
-        this.completer = new core_next_1.AIAgent({
+        this.completer = new core_1.AIAgent({
             name: "llm_orchestration_completer",
-            instructions: orchestrator_prompts_js_1.SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
+            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
             outputSchema: this.outputSchema,
         });
     }
     planner;
     completer;
     maxIterations;
+    tasksConcurrency;
     async process(input, context) {
         const model = context?.model;
         if (!model)
             throw new Error("model is required to run OrchestratorAgent");
-        const objective = (0, core_next_1.getUserInputMessage)(input);
+        const objective = (0, core_1.getMessage)(input);
         if (!objective)
             throw new Error("Objective is required to run OrchestratorAgent");
         const result = {
             objective,
-            step_results: [],
+            steps: [],
         };
         let iterations = 0;
         const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
         while (iterations++ < maxIterations) {
-            const plan = await this.getFullPlan(objective, result, context);
+            const plan = await this.getFullPlan(result, context);
             result.plan = plan;
-            if (plan.is_complete) {
-                return this.completer.call({ plan_result: this.formatPlanResult(result) }, context);
+            if (plan.isComplete) {
+                return this.synthesizePlanResult(result, context);
             }
             for (const step of plan.steps) {
                 const stepResult = await this.executeStep(result, step, context);
-                result.step_results.push(stepResult);
+                result.steps.push(stepResult);
             }
         }
         throw new Error(`Max iterations reached: ${maxIterations}`);
     }
-    async getFullPlan(objective, planResult, context) {
-        const agents = this.tools
-            .map((agent, idx) => `${idx + 1}. Agent Name: ${agent.name}
-Description: ${agent.description}
-Functions: ${agent.tools.map((tool) => `- ${tool.name} ${tool.description}`).join("\n")}`)
-            .join("\n");
-        return this.planner.call({ objective, plan_result: this.formatPlanResult(planResult), agents }, context);
+    getFullPlanInput(planResult) {
+        return {
+            objective: planResult.objective,
+            steps: planResult.steps,
+            plan: {
+                status: planResult.status ? "Complete" : "In Progress",
+                result: planResult.result || "No results yet",
+            },
+            agents: this.tools.map((i) => ({
+                name: i.name,
+                description: i.description,
+                tools: i.tools.map((i) => ({ name: i.name, description: i.description })),
+            })),
+        };
+    }
+    async getFullPlan(planResult, context) {
+        return context.call(this.planner, this.getFullPlanInput(planResult));
+    }
+    async synthesizePlanResult(planResult, context) {
+        return context.call(this.completer, {
+            ...this.getFullPlanInput(planResult),
+            ...(0, core_1.createMessage)(orchestrator_prompts_js_1.SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE),
+        });
     }
-    async executeStep(previousResult, step, context) {
+    async executeStep(planResult, step, context) {
+        const concurrency = this.tasksConcurrency ?? DEFAULT_TASK_CONCURRENCY;
         const model = context?.model;
         if (!model)
             throw new Error("model is required to run OrchestratorAgent");
-        const taskResults = [];
-        for (const task of step.tasks) {
+        const queue = fastq_1.default.promise(async (task) => {
             const agent = this.tools.find((agent) => agent.name === task.agent);
             if (!agent)
                 throw new Error(`Agent ${task.agent} not found`);
-            const prompt = core_next_1.PromptTemplate.from(orchestrator_prompts_js_1.TASK_PROMPT_TEMPLATE).format({
-                objective: previousResult.objective,
-                task: task.description,
-                context: this.formatPlanResult(previousResult),
+            const prompt = core_1.PromptTemplate.from(orchestrator_prompts_js_1.TASK_PROMPT_TEMPLATE).format({
+                objective: planResult.objective,
+                step,
+                task,
+                steps: planResult.steps,
             });
             let result;
             if (agent.isCallable) {
-                result = JSON.stringify(await agent.call(prompt, context));
+                result = getMessageOrJsonString(await context.call(agent, prompt));
             }
             else {
-                const executor = core_next_1.AIAgent.from({
+                const executor = core_1.AIAgent.from({
+                    name: "llm_orchestration_task_executor",
                     instructions: prompt,
                     tools: agent.tools,
                 });
-                result = JSON.stringify(await executor.call({}, context));
+                result = getMessageOrJsonString(await context.call(executor, {}));
             }
-            taskResults.push({ ...task, result });
+            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 result = getMessageOrJsonString(await context.call(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,
-            task_results: taskResults,
+            tasks: results,
+            result,
         };
     }
-    formatPlanResult(planResult) {
-        return core_next_1.PromptTemplate.from(orchestrator_prompts_js_1.PLAN_RESULT_TEMPLATE).format({
-            plan_objective: planResult.objective,
-            steps_str: this.formatStepsResults(planResult.step_results),
-            plan_status: planResult.is_complete ? "Complete" : "In Progress",
-            plan_result: planResult.result || "No results yet",
-        });
-    }
-    formatStepsResults(stepResults) {
-        if (!stepResults.length)
-            return "No steps executed yet";
-        return stepResults
-            .map((stepResult, index) => `${index + 1}:\n${stepResult.task_results.length
-            ? core_next_1.PromptTemplate.from(orchestrator_prompts_js_1.STEP_RESULT_TEMPLATE).format({
-                step_description: stepResult.step.description,
-                tasks_str: stepResult.task_results
-                    .map((task) => `- ${core_next_1.PromptTemplate.from(orchestrator_prompts_js_1.TASK_RESULT_TEMPLATE).format({
-                    task_description: task.description,
-                    task_result: task.result,
-                })}`)
-                    .join("\n"),
-            })
-            : "No result"}`)
-            .join("\n\n");
-    }
 }
 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);
+}

package/lib/cjs/orchestrator/orchestrator-prompts.d.ts

@@ -1,51 +1,12 @@
+import { type Agent, type Message } from "@aigne/core";
 import { z } from "zod";
-export declare const TASK_RESULT_TEMPLATE = "Task: {{task_description}}\nResult: {{task_result}}";
-export declare const STEP_RESULT_TEMPLATE = "Step: {{step_description}}\nStep Subtasks:\n{{tasks_str}}";
-export declare const PLAN_RESULT_TEMPLATE = "Plan Objective: {{plan_objective}}\n\nProgress So Far (steps completed):\n{{steps_str}}\n\nPlan Current Status: {{plan_status}}\nPlan Current Result: {{plan_result}}";
-export declare const FULL_PLAN_PROMPT_TEMPLATE = "You are tasked with orchestrating a plan to complete an objective.\nYou can analyze results from the previous steps already executed to decide if the objective is complete.\nYour plan must be structured in sequential steps, with each step containing independent parallel subtasks.\n\nObjective: {{objective}}\n\n{{plan_result}}\n\nIf the previous results achieve the objective, return is_complete=true.\nOtherwise, generate remaining steps needed.\n\nYou have access to the following Agents(which are collections of tools/functions):\n\nAgents:\n{{agents}}\n\nGenerate a plan with all remaining steps needed.\nSteps are sequential, but each Step can have parallel subtasks.\nFor each Step, specify a description of the step and independent subtasks that can run in parallel.\nFor each subtask specify:\n    1. Clear description of the task that an LLM can execute\n    2. Name of 1 Agent to use for the task";
-export declare const TASK_PROMPT_TEMPLATE = "You are part of a larger workflow to achieve the objective: {{objective}}.\nYour job is to accomplish only the following task: {{task}}.\n\nResults so far that may provide helpful context:\n{{context}}";
-export declare const SYNTHESIZE_PLAN_PROMPT_TEMPLATE = "Synthesize the results of executing all steps in the plan into a cohesive result:\n{{plan_result}}";
-export declare const TaskSchema: z.ZodObject<{
-    description: z.ZodString;
-    agent: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    agent: string;
-}, {
-    description: string;
-    agent: string;
-}>;
-export declare const StepSchema: z.ZodObject<{
-    description: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        description: z.ZodString;
-        agent: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-        agent: string;
-    }, {
-        description: string;
-        agent: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    tasks: {
-        description: string;
-        agent: string;
-    }[];
-}, {
-    description: string;
-    tasks: {
-        description: string;
-        agent: string;
-    }[];
-}>;
-export declare const FullPlanSchema: z.ZodObject<{
+export declare const SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = "Synthesize the results of executing all steps in the plan into a cohesive result\n";
+export declare function getFullPlanSchema(agents: Agent[]): z.ZodObject<{
     steps: z.ZodArray<z.ZodObject<{
         description: z.ZodString;
         tasks: z.ZodArray<z.ZodObject<{
             description: z.ZodString;
-            agent: z.ZodString;
+            agent: z.ZodUnion<[z.ZodLiteral<string>, z.ZodLiteral<string>, ...z.ZodLiteral<string>[]]>;
         }, "strip", z.ZodTypeAny, {
             description: string;
             agent: string;
@@ -66,7 +27,7 @@ export declare const FullPlanSchema: z.ZodObject<{
             agent: string;
         }[];
     }>, "many">;
-    is_complete: z.ZodBoolean;
+    isComplete: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     steps: {
         description: string;
@@ -75,7 +36,7 @@ export declare const FullPlanSchema: z.ZodObject<{
             agent: string;
         }[];
     }[];
-    is_complete: boolean;
+    isComplete: boolean;
 }, {
     steps: {
         description: string;
@@ -84,8 +45,47 @@ export declare const FullPlanSchema: z.ZodObject<{
             agent: string;
         }[];
     }[];
-    is_complete: boolean;
+    isComplete: boolean;
 }>;
-export type Task = z.infer<typeof TaskSchema>;
-export type Step = z.infer<typeof StepSchema>;
-export type FullPlanOutput = z.infer<typeof FullPlanSchema>;
+export type FullPlanOutput = z.infer<ReturnType<typeof getFullPlanSchema>>;
+export type Step = FullPlanOutput["steps"][number];
+export type Task = Step["tasks"][number];
+export interface StepWithResult {
+    step: Step;
+    tasks: Array<TaskWithResult>;
+    result: string;
+}
+export interface TaskWithResult {
+    task: Task;
+    result: string;
+}
+export interface FullPlanInput extends Message {
+    objective: string;
+    steps: StepWithResult[];
+    plan: {
+        status: string;
+        result: string;
+    };
+    agents: {
+        name: string;
+        description?: string;
+        tools: {
+            name: string;
+            description?: string;
+        }[];
+    }[];
+}
+export declare const FULL_PLAN_PROMPT_TEMPLATE = "You are tasked with orchestrating a plan to complete an objective.\nYou can analyze results from the previous steps already executed to decide if the objective is complete.\nYour plan must be structured in sequential steps, with each step containing independent parallel subtasks.\n\n<objective>\n{{objective}}\n</objective>\n\n<steps_completed>\n{{#steps}}\n- Step: {{step.description}}\n  Result: {{result}}\n{{/steps}}\n</steps_completed>\n\n<previous_plan_status>\n{{plan.status}}\n</previous_plan_status>\n\n<previous_plan_result>\n{{plan.result}}\n</previous_plan_result>\n\nYou have access to the following Agents(which are collections of tools/functions):\n\n<agents>\n{{#agents}}\n- Agent: {{name}}\n  Description: {{description}}\n  Functions:\n    {{#tools}}\n    - Tool: {{name}}\n      Description: {{description}}\n    {{/tools}}\n{{/agents}}\n</agents>\n\n- If the previous plan results achieve the objective, return isComplete=true.\n- Otherwise, generate remaining steps needed.\n- Generate a plan with all remaining steps needed.\n- Steps are sequential, but each Step can have parallel subtasks.\n- For each Step, specify a description of the step and independent subtasks that can run in parallel.\n- For each subtask specify:\n    1. Clear description of the task that an LLM can execute\n    2. Name of 1 Agent to use for the task";
+export interface TaskPromptInput extends Message {
+    objective: string;
+    step: Step;
+    task: Task;
+    steps: StepWithResult[];
+}
+export declare const TASK_PROMPT_TEMPLATE = "You are part of a larger workflow to achieve the step then the objective:\n\n<objective>\n{{objective}}\n</objective>\n\n<step>\n{{step.description}}\n</step>\n\nYour job is to accomplish only the following task:\n\n<task>\n{{task.description}}\n</task>\n\nResults so far that may provide helpful context:\n\n<steps_completed>\n{{#steps}}\n- Step: {{step.description}}\n  Result: {{result}}\n{{/steps}}\n</steps_completed>\n";
+export interface SynthesizeStepPromptInput extends Message {
+    objective: string;
+    step: Step;
+    tasks: TaskWithResult[];
+}
+export declare const SYNTHESIZE_STEP_PROMPT_TEMPLATE = "Synthesize the results of these parallel tasks into a cohesive result\n\n<objective>\n{{objective}}\n</objective>\n\n<step>\n{{step.description}}\n</step>\n\n<tasks>\n{{#tasks}}\n- Task: {{task.description}}\n  Result: {{result}}\n{{/tasks}}\n</tasks>\n";

package/lib/cjs/orchestrator/orchestrator-prompts.js

@@ -1,57 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FullPlanSchema = exports.StepSchema = exports.TaskSchema = exports.SYNTHESIZE_PLAN_PROMPT_TEMPLATE = exports.TASK_PROMPT_TEMPLATE = exports.FULL_PLAN_PROMPT_TEMPLATE = exports.PLAN_RESULT_TEMPLATE = exports.STEP_RESULT_TEMPLATE = exports.TASK_RESULT_TEMPLATE = void 0;
+exports.SYNTHESIZE_STEP_PROMPT_TEMPLATE = exports.TASK_PROMPT_TEMPLATE = exports.FULL_PLAN_PROMPT_TEMPLATE = exports.SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = void 0;
+exports.getFullPlanSchema = getFullPlanSchema;
+const core_1 = require("@aigne/core");
+const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
-exports.TASK_RESULT_TEMPLATE = `Task: {{task_description}}
-Result: {{task_result}}`;
-exports.STEP_RESULT_TEMPLATE = `Step: {{step_description}}
-Step Subtasks:
-{{tasks_str}}`;
-exports.PLAN_RESULT_TEMPLATE = `Plan Objective: {{plan_objective}}
-
-Progress So Far (steps completed):
-{{steps_str}}
-
-Plan Current Status: {{plan_status}}
-Plan Current Result: {{plan_result}}`;
+exports.SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = `\
+Synthesize the results of executing all steps in the plan into a cohesive result
+`;
+function getFullPlanSchema(agents) {
+    const agentNames = agents.map((i) => i.name);
+    if (new Set(agentNames).size !== agentNames.length) {
+        const duplicates = (0, lodash_es_1.pickBy)((0, lodash_es_1.groupBy)(agentNames), (x) => x.length > 1);
+        throw new Error(`Tools name must be unique for orchestrator: ${Object.keys(duplicates).join(",")}`);
+    }
+    const TaskSchema = zod_1.z.object({
+        description: zod_1.z.string().describe("Detailed description of the task"),
+        agent: zod_1.z
+            .union((0, core_1.ensureZodUnionArray)(agents.map((i) => zod_1.z.literal(i.name))))
+            .describe("Name of the agent to execute the task"),
+    });
+    const StepSchema = zod_1.z.object({
+        description: zod_1.z.string().describe("Detailed description of the step"),
+        tasks: zod_1.z.array(TaskSchema).describe("Tasks that can run in parallel in this step"),
+    });
+    return zod_1.z.object({
+        steps: zod_1.z.array(StepSchema).describe("All sequential steps in the plan"),
+        isComplete: zod_1.z.boolean().describe("Whether the previous plan results achieve the objective"),
+    });
+}
 exports.FULL_PLAN_PROMPT_TEMPLATE = `You are tasked with orchestrating a plan to complete an objective.
 You can analyze results from the previous steps already executed to decide if the objective is complete.
 Your plan must be structured in sequential steps, with each step containing independent parallel subtasks.
 
-Objective: {{objective}}
+<objective>
+{{objective}}
+</objective>
 
-{{plan_result}}
+<steps_completed>
+{{#steps}}
+- Step: {{step.description}}
+  Result: {{result}}
+{{/steps}}
+</steps_completed>
 
-If the previous results achieve the objective, return is_complete=true.
-Otherwise, generate remaining steps needed.
+<previous_plan_status>
+{{plan.status}}
+</previous_plan_status>
+
+<previous_plan_result>
+{{plan.result}}
+</previous_plan_result>
 
 You have access to the following Agents(which are collections of tools/functions):
 
-Agents:
-{{agents}}
+<agents>
+{{#agents}}
+- Agent: {{name}}
+  Description: {{description}}
+  Functions:
+    {{#tools}}
+    - Tool: {{name}}
+      Description: {{description}}
+    {{/tools}}
+{{/agents}}
+</agents>
 
-Generate a plan with all remaining steps needed.
-Steps are sequential, but each Step can have parallel subtasks.
-For each Step, specify a description of the step and independent subtasks that can run in parallel.
-For each subtask specify:
+- If the previous plan results achieve the objective, return isComplete=true.
+- Otherwise, generate remaining steps needed.
+- Generate a plan with all remaining steps needed.
+- Steps are sequential, but each Step can have parallel subtasks.
+- For each Step, specify a description of the step and independent subtasks that can run in parallel.
+- For each subtask specify:
     1. Clear description of the task that an LLM can execute
     2. Name of 1 Agent to use for the task`;
-exports.TASK_PROMPT_TEMPLATE = `You are part of a larger workflow to achieve the objective: {{objective}}.
-Your job is to accomplish only the following task: {{task}}.
+exports.TASK_PROMPT_TEMPLATE = `\
+You are part of a larger workflow to achieve the step then the objective:
+
+<objective>
+{{objective}}
+</objective>
+
+<step>
+{{step.description}}
+</step>
+
+Your job is to accomplish only the following task:
+
+<task>
+{{task.description}}
+</task>
 
 Results so far that may provide helpful context:
-{{context}}`;
-exports.SYNTHESIZE_PLAN_PROMPT_TEMPLATE = `Synthesize the results of executing all steps in the plan into a cohesive result:
-{{plan_result}}`;
-exports.TaskSchema = zod_1.z.object({
-    description: zod_1.z.string().describe("Detailed description of the task"),
-    agent: zod_1.z.string().describe("Name of the agent to execute the task"),
-});
-exports.StepSchema = zod_1.z.object({
-    description: zod_1.z.string().describe("Detailed description of the step"),
-    tasks: zod_1.z.array(exports.TaskSchema).describe("Tasks that can run in parallel in this step"),
-});
-exports.FullPlanSchema = zod_1.z.object({
-    steps: zod_1.z.array(exports.StepSchema).describe("All sequential steps in the plan"),
-    is_complete: zod_1.z.boolean().describe("Whether the plan is complete"),
-});
+
+<steps_completed>
+{{#steps}}
+- Step: {{step.description}}
+  Result: {{result}}
+{{/steps}}
+</steps_completed>
+`;
+exports.SYNTHESIZE_STEP_PROMPT_TEMPLATE = `\
+Synthesize the results of these parallel tasks into a cohesive result
+
+<objective>
+{{objective}}
+</objective>
+
+<step>
+{{step.description}}
+</step>
+
+<tasks>
+{{#tasks}}
+- Task: {{task.description}}
+  Result: {{result}}
+{{/tasks}}
+</tasks>
+`;

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

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

@@ -1,40 +1,27 @@
-import type { AgentOptions, AgentOutput, Context } from "@aigne/core-next";
-import type { AgentInput } from "@aigne/core-next";
-import { Agent } from "@aigne/core-next";
-import { type FullPlanOutput, type Step } from "./orchestrator-prompts.js";
-export interface StepResult {
-    step: Step;
-    task_results: Array<TaskWithResult>;
-}
-export interface TaskWithResult {
-    description: string;
-    agent: string;
-    result: string;
-}
-export interface PlanResult extends AgentOutput {
+import { Agent, type AgentOptions, type Context, type Message } from "@aigne/core";
+import { type FullPlanOutput, type StepWithResult } from "./orchestrator-prompts.js";
+export * from "./orchestrator-prompts.js";
+export interface FullPlanWithResult {
     objective: string;
     plan?: FullPlanOutput;
-    is_complete?: boolean;
+    steps: StepWithResult[];
     result?: string;
-    step_results: StepResult[];
-}
-export interface FullPlanInput extends AgentInput {
-    objective: string;
-    plan_result: string;
-    agents: string;
+    status?: boolean;
 }
-export interface OrchestratorAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     maxIterations?: number;
+    tasksConcurrency?: number;
 }
-export declare class OrchestratorAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
+export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
     constructor(options: OrchestratorAgentOptions<I, O>);
     private planner;
     private completer;
     maxIterations?: number;
+    tasksConcurrency?: number;
     process(input: I, context?: Context): Promise<O>;
+    private getFullPlanInput;
     private getFullPlan;
+    private synthesizePlanResult;
     private executeStep;
-    private formatPlanResult;
-    private formatStepsResults;
 }