@aigne/agent-library 1.2.0 → 1.3.1

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

@@ -1,6 +1,9 @@
-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";
+import { AIAgent, Agent, PromptTemplate, createMessage, getMessage, } from "@aigne/core";
+import fastq from "fastq";
+import { FULL_PLAN_PROMPT_TEMPLATE, SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE, SYNTHESIZE_STEP_PROMPT_TEMPLATE, TASK_PROMPT_TEMPLATE, getFullPlanSchema, } from "./orchestrator-prompts.js";
 const DEFAULT_MAX_ITERATIONS = 30;
+const DEFAULT_TASK_CONCURRENCY = 5;
+export * from "./orchestrator-prompts.js";
 export class OrchestratorAgent extends Agent {
     static from(options) {
         return new OrchestratorAgent(options);
@@ -8,109 +11,127 @@ export class OrchestratorAgent extends Agent {
     constructor(options) {
         super({ ...options });
         this.maxIterations = options.maxIterations;
+        this.tasksConcurrency = options.tasksConcurrency;
         this.planner = new AIAgent({
             name: "llm_orchestration_planner",
             instructions: FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: FullPlanSchema,
+            outputSchema: () => getFullPlanSchema(this.tools),
         });
         this.completer = new AIAgent({
             name: "llm_orchestration_completer",
-            instructions: SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
+            instructions: 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 = getUserInputMessage(input);
+        const objective = 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),
+            ...createMessage(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.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 = PromptTemplate.from(TASK_PROMPT_TEMPLATE).format({
-                objective: previousResult.objective,
-                task: task.description,
-                context: this.formatPlanResult(previousResult),
+                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 = 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(AIAgent.from({
+            name: "llm_orchestration_step_synthesizer",
+            instructions: 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 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");
+}
+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/esm/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/esm/orchestrator/orchestrator-prompts.js

@@ -1,54 +1,116 @@
+import { ensureZodUnionArray } from "@aigne/core";
+import { groupBy, pickBy } from "lodash-es";
 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 SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = `\
+Synthesize the results of executing all steps in the plan into a cohesive result
+`;
+export function getFullPlanSchema(agents) {
+    const agentNames = agents.map((i) => i.name);
+    if (new Set(agentNames).size !== agentNames.length) {
+        const duplicates = pickBy(groupBy(agentNames), (x) => x.length > 1);
+        throw new Error(`Tools name must be unique for orchestrator: ${Object.keys(duplicates).join(",")}`);
+    }
+    const TaskSchema = z.object({
+        description: z.string().describe("Detailed description of the task"),
+        agent: z
+            .union(ensureZodUnionArray(agents.map((i) => z.literal(i.name))))
+            .describe("Name of the agent to execute the task"),
+    });
+    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"),
+    });
+    return z.object({
+        steps: z.array(StepSchema).describe("All sequential steps in the plan"),
+        isComplete: z.boolean().describe("Whether the previous plan results achieve the objective"),
+    });
+}
 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}}
+<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`;
-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}}.
+export const 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}}`;
-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"),
-});
+
+<steps_completed>
+{{#steps}}
+- Step: {{step.description}}
+  Result: {{result}}
+{{/steps}}
+</steps_completed>
+`;
+export const 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/esm/package.json

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