@aigne/agent-library 1.1.0-beta.9 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+## [1.2.0](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.1.0...agent-library-v1.2.0) (2025-03-18)
+
+- chore: release 1.2.0
+
+## 1.1.0-beta.17 (2025-3-18)
+
+- chore: add support for esm module
+
+## 1.1.0-beta.16 (2025-3-18)
+
+- chore: add puppeteer in linux need docker_container
+
+## 1.1.0-beta.15 (2025-3-18)
+
+- chore: make coverage report as text to terminal
+- chore: update contributing docs
+
+## 1.1.0-beta.14 (2025-3-18)
+
+- chore(example): add code-execution example
+
+## 1.1.0-beta.13 (2025-3-18)
+
+- feat: add OrchestratorAgent in agent library

package/lib/cjs/index.d.ts

@@ -1 +1 @@
-export {};
+export * from "./orchestrator/index.js";

package/lib/cjs/index.js

@@ -1,2 +1,17 @@
 "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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./orchestrator/index.js"), exports);

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

@@ -0,0 +1,40 @@
+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 {
+    objective: string;
+    plan?: FullPlanOutput;
+    is_complete?: boolean;
+    result?: string;
+    step_results: StepResult[];
+}
+export interface FullPlanInput extends AgentInput {
+    objective: string;
+    plan_result: string;
+    agents: string;
+}
+export interface OrchestratorAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+    maxIterations?: 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>;
+    constructor(options: OrchestratorAgentOptions<I, O>);
+    private planner;
+    private completer;
+    maxIterations?: number;
+    process(input: I, context?: Context): Promise<O>;
+    private getFullPlan;
+    private executeStep;
+    private formatPlanResult;
+    private formatStepsResults;
+}

package/lib/cjs/orchestrator/index.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestratorAgent = void 0;
+const core_next_1 = require("@aigne/core-next");
+const orchestrator_prompts_js_1 = require("./orchestrator-prompts.js");
+const DEFAULT_MAX_ITERATIONS = 30;
+class OrchestratorAgent extends core_next_1.Agent {
+    static from(options) {
+        return new OrchestratorAgent(options);
+    }
+    constructor(options) {
+        super({ ...options });
+        this.maxIterations = options.maxIterations;
+        this.planner = new core_next_1.AIAgent({
+            name: "llm_orchestration_planner",
+            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: orchestrator_prompts_js_1.FullPlanSchema,
+        });
+        this.completer = new core_next_1.AIAgent({
+            name: "llm_orchestration_completer",
+            instructions: orchestrator_prompts_js_1.SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
+            outputSchema: this.outputSchema,
+        });
+    }
+    planner;
+    completer;
+    maxIterations;
+    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);
+        if (!objective)
+            throw new Error("Objective is required to run OrchestratorAgent");
+        const result = {
+            objective,
+            step_results: [],
+        };
+        let iterations = 0;
+        const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        while (iterations++ < maxIterations) {
+            const plan = await this.getFullPlan(objective, result, context);
+            result.plan = plan;
+            if (plan.is_complete) {
+                return this.completer.call({ plan_result: this.formatPlanResult(result) }, context);
+            }
+            for (const step of plan.steps) {
+                const stepResult = await this.executeStep(result, step, context);
+                result.step_results.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);
+    }
+    async executeStep(previousResult, step, context) {
+        const model = context?.model;
+        if (!model)
+            throw new Error("model is required to run OrchestratorAgent");
+        const taskResults = [];
+        for (const task of step.tasks) {
+            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),
+            });
+            let result;
+            if (agent.isCallable) {
+                result = JSON.stringify(await agent.call(prompt, context));
+            }
+            else {
+                const executor = core_next_1.AIAgent.from({
+                    instructions: prompt,
+                    tools: agent.tools,
+                });
+                result = JSON.stringify(await executor.call({}, context));
+            }
+            taskResults.push({ ...task, result });
+        }
+        return {
+            step,
+            task_results: taskResults,
+        };
+    }
+    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;

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

@@ -0,0 +1,91 @@
+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<{
+    steps: z.ZodArray<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;
+        }[];
+    }>, "many">;
+    is_complete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export type Step = z.infer<typeof StepSchema>;
+export type FullPlanOutput = z.infer<typeof FullPlanSchema>;

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

@@ -0,0 +1,57 @@
+"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;
+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.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}}
+
+{{plan_result}}
+
+If the previous results achieve the objective, return is_complete=true.
+Otherwise, generate remaining steps needed.
+
+You have access to the following Agents(which are collections of tools/functions):
+
+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:
+    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}}.
+
+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"),
+});

package/lib/dts/index.d.ts

@@ -1 +1 @@
-export {};
+export * from "./orchestrator/index.js";

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

@@ -0,0 +1,40 @@
+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 {
+    objective: string;
+    plan?: FullPlanOutput;
+    is_complete?: boolean;
+    result?: string;
+    step_results: StepResult[];
+}
+export interface FullPlanInput extends AgentInput {
+    objective: string;
+    plan_result: string;
+    agents: string;
+}
+export interface OrchestratorAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+    maxIterations?: 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>;
+    constructor(options: OrchestratorAgentOptions<I, O>);
+    private planner;
+    private completer;
+    maxIterations?: number;
+    process(input: I, context?: Context): Promise<O>;
+    private getFullPlan;
+    private executeStep;
+    private formatPlanResult;
+    private formatStepsResults;
+}

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

@@ -0,0 +1,91 @@
+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<{
+    steps: z.ZodArray<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;
+        }[];
+    }>, "many">;
+    is_complete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export type Step = z.infer<typeof StepSchema>;
+export type FullPlanOutput = z.infer<typeof FullPlanSchema>;

package/lib/esm/index.d.ts

@@ -1 +1 @@
-export {};
+export * from "./orchestrator/index.js";

package/lib/esm/index.js

@@ -1 +1 @@
-export {};
+export * from "./orchestrator/index.js";

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

@@ -0,0 +1,40 @@
+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 {
+    objective: string;
+    plan?: FullPlanOutput;
+    is_complete?: boolean;
+    result?: string;
+    step_results: StepResult[];
+}
+export interface FullPlanInput extends AgentInput {
+    objective: string;
+    plan_result: string;
+    agents: string;
+}
+export interface OrchestratorAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+    maxIterations?: 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>;
+    constructor(options: OrchestratorAgentOptions<I, O>);
+    private planner;
+    private completer;
+    maxIterations?: number;
+    process(input: I, context?: Context): Promise<O>;
+    private getFullPlan;
+    private executeStep;
+    private formatPlanResult;
+    private formatStepsResults;
+}

package/lib/esm/orchestrator/index.js

@@ -0,0 +1,116 @@
+import { AIAgent, Agent, PromptTemplate, getUserInputMessage } from "@aigne/core-next";
+import { FULL_PLAN_PROMPT_TEMPLATE, FullPlanSchema, PLAN_RESULT_TEMPLATE, STEP_RESULT_TEMPLATE, SYNTHESIZE_PLAN_PROMPT_TEMPLATE, TASK_PROMPT_TEMPLATE, TASK_RESULT_TEMPLATE, } from "./orchestrator-prompts.js";
+const DEFAULT_MAX_ITERATIONS = 30;
+export class OrchestratorAgent extends Agent {
+    static from(options) {
+        return new OrchestratorAgent(options);
+    }
+    constructor(options) {
+        super({ ...options });
+        this.maxIterations = options.maxIterations;
+        this.planner = new AIAgent({
+            name: "llm_orchestration_planner",
+            instructions: FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: FullPlanSchema,
+        });
+        this.completer = new AIAgent({
+            name: "llm_orchestration_completer",
+            instructions: SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
+            outputSchema: this.outputSchema,
+        });
+    }
+    planner;
+    completer;
+    maxIterations;
+    async process(input, context) {
+        const model = context?.model;
+        if (!model)
+            throw new Error("model is required to run OrchestratorAgent");
+        const objective = getUserInputMessage(input);
+        if (!objective)
+            throw new Error("Objective is required to run OrchestratorAgent");
+        const result = {
+            objective,
+            step_results: [],
+        };
+        let iterations = 0;
+        const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        while (iterations++ < maxIterations) {
+            const plan = await this.getFullPlan(objective, result, context);
+            result.plan = plan;
+            if (plan.is_complete) {
+                return this.completer.call({ plan_result: this.formatPlanResult(result) }, context);
+            }
+            for (const step of plan.steps) {
+                const stepResult = await this.executeStep(result, step, context);
+                result.step_results.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);
+    }
+    async executeStep(previousResult, step, context) {
+        const model = context?.model;
+        if (!model)
+            throw new Error("model is required to run OrchestratorAgent");
+        const taskResults = [];
+        for (const task of step.tasks) {
+            const agent = this.tools.find((agent) => agent.name === task.agent);
+            if (!agent)
+                throw new Error(`Agent ${task.agent} not found`);
+            const prompt = PromptTemplate.from(TASK_PROMPT_TEMPLATE).format({
+                objective: previousResult.objective,
+                task: task.description,
+                context: this.formatPlanResult(previousResult),
+            });
+            let result;
+            if (agent.isCallable) {
+                result = JSON.stringify(await agent.call(prompt, context));
+            }
+            else {
+                const executor = AIAgent.from({
+                    instructions: prompt,
+                    tools: agent.tools,
+                });
+                result = JSON.stringify(await executor.call({}, context));
+            }
+            taskResults.push({ ...task, result });
+        }
+        return {
+            step,
+            task_results: taskResults,
+        };
+    }
+    formatPlanResult(planResult) {
+        return PromptTemplate.from(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
+            ? PromptTemplate.from(STEP_RESULT_TEMPLATE).format({
+                step_description: stepResult.step.description,
+                tasks_str: stepResult.task_results
+                    .map((task) => `- ${PromptTemplate.from(TASK_RESULT_TEMPLATE).format({
+                    task_description: task.description,
+                    task_result: task.result,
+                })}`)
+                    .join("\n"),
+            })
+            : "No result"}`)
+            .join("\n\n");
+    }
+}

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

@@ -0,0 +1,91 @@
+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<{
+    steps: z.ZodArray<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;
+        }[];
+    }>, "many">;
+    is_complete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    is_complete: boolean;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export type Step = z.infer<typeof StepSchema>;
+export type FullPlanOutput = z.infer<typeof FullPlanSchema>;

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const TASK_RESULT_TEMPLATE = `Task: {{task_description}}
+Result: {{task_result}}`;
+export const STEP_RESULT_TEMPLATE = `Step: {{step_description}}
+Step Subtasks:
+{{tasks_str}}`;
+export const PLAN_RESULT_TEMPLATE = `Plan Objective: {{plan_objective}}
+
+Progress So Far (steps completed):
+{{steps_str}}
+
+Plan Current Status: {{plan_status}}
+Plan Current Result: {{plan_result}}`;
+export const 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}}
+
+{{plan_result}}
+
+If the previous results achieve the objective, return is_complete=true.
+Otherwise, generate remaining steps needed.
+
+You have access to the following Agents(which are collections of tools/functions):
+
+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:
+    1. Clear description of the task that an LLM can execute
+    2. Name of 1 Agent to use for the task`;
+export const 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}}.
+
+Results so far that may provide helpful context:
+{{context}}`;
+export const SYNTHESIZE_PLAN_PROMPT_TEMPLATE = `Synthesize the results of executing all steps in the plan into a cohesive result:
+{{plan_result}}`;
+export const TaskSchema = z.object({
+    description: z.string().describe("Detailed description of the task"),
+    agent: z.string().describe("Name of the agent to execute the task"),
+});
+export const StepSchema = z.object({
+    description: z.string().describe("Detailed description of the step"),
+    tasks: z.array(TaskSchema).describe("Tasks that can run in parallel in this step"),
+});
+export const FullPlanSchema = z.object({
+    steps: z.array(StepSchema).describe("All sequential steps in the plan"),
+    is_complete: z.boolean().describe("Whether the plan is complete"),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/agent-library",
-  "version": "1.1.0-beta.9",
+  "version": "1.2.0",
   "description": "Collection of agent libraries for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -33,10 +33,10 @@
   },
   "dependencies": {
     "zod": "^3.24.2",
-    "@aigne/core-next": "^1.1.0-beta.9"
+    "@aigne/core-next": "^1.2.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.4",
+    "@types/bun": "^1.2.5",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.2"