@blocklet/pages-kit-agents 0.5.55 → 0.6.0

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

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 json_schema_js_1 = require("@aigne/core/utils/json-schema.js");
-const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
-const zod_1 = require("zod");
-/**
- * @hidden
- */
-exports.SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = `\
-Synthesize the results of executing all steps in the plan into a cohesive result
-`;
-/**
- * @hidden
- */
-function getFullPlanSchema(agents) {
-    const agentNames = agents.map((i) => i.name);
-    if (new Set(agentNames).size !== agentNames.length) {
-        const dup = (0, type_utils_js_1.duplicates)(agentNames);
-        throw new Error(`Duplicate agent names found in orchestrator: ${dup.join(',')}`);
-    }
-    const TaskSchema = zod_1.z.object({
-        description: zod_1.z.string().describe('Detailed description of the task'),
-        agent: zod_1.z
-            .union((0, json_schema_js_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'),
-    });
-}
-/**
- * @hidden
- */
-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>
-
-<steps_completed>
-{{#steps}}
-- Step: {{step.description}}
-  Result: {{result}}
-{{/steps}}
-</steps_completed>
-
-<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}}
-- Agent: {{name}}
-  Description: {{description}}
-  Functions:
-    {{#tools}}
-    - Tool: {{name}}
-      Description: {{description}}
-    {{/tools}}
-{{/agents}}
-</agents>
-
-- 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`;
-/**
- * @hidden
- */
-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:
-
-<steps_completed>
-{{#steps}}
-- Step: {{step.description}}
-  Result: {{result}}
-{{/steps}}
-</steps_completed>
-`;
-/**
- * @hidden
- */
-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/esm/agents/orchestrator/index.d.ts

@@ -1,115 +0,0 @@
-import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from '@aigne/core';
-import { type FullPlanOutput, type StepWithResult } from './orchestrator-prompts.js';
-/**
- * Re-export orchestrator prompt templates and related types
- */
-export * from './orchestrator-prompts.js';
-/**
- * Represents a complete plan with execution results
- * @hidden
- */
-export interface FullPlanWithResult {
-    /**
-     * The overall objective
-     */
-    objective: string;
-    /**
-     * The generated complete plan
-     */
-    plan?: FullPlanOutput;
-    /**
-     * List of executed steps with their results
-     */
-    steps: StepWithResult[];
-    /**
-     * Final result
-     */
-    result?: string;
-    /**
-     * Plan completion status
-     */
-    status?: boolean;
-}
-/**
- * Configuration options for the Orchestrator Agent
- */
-export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
-    /**
-     * Maximum number of iterations to prevent infinite loops
-     * Default: 30
-     */
-    maxIterations?: number;
-    /**
-     * Number of concurrent tasks
-     * Default: 5
-     */
-    tasksConcurrency?: number;
-    /**
-     * Chain step results as input to the next step
-     * Default: false
-     */
-    chainStepResults?: boolean;
-}
-/**
- * Orchestrator Agent Class
- *
- * This Agent is responsible for:
- * 1. Generating an execution plan based on the objective
- * 2. Breaking down the plan into steps and tasks
- * 3. Coordinating the execution of steps and tasks
- * 4. Synthesizing the final result
- *
- * Workflow:
- * - Receives input objective
- * - Uses planner to create execution plan
- * - Executes tasks and steps according to the plan
- * - Synthesizes final result through completer
- */
-export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
-    /**
-     * Factory method to create an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     * @returns A new OrchestratorAgent instance
-     */
-    static from<I extends Message, O extends Message>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
-    /**
-     * Creates an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     */
-    constructor(options: OrchestratorAgentOptions<I, O>);
-    private planner;
-    private completer;
-    /**
-     * Maximum number of iterations
-     * Prevents infinite execution loops
-     */
-    maxIterations?: number;
-    /**
-     * Number of concurrent tasks
-     * Controls how many tasks can be executed simultaneously
-     */
-    tasksConcurrency?: number;
-    /**
-     * Whether to chain step results as input to next step
-     */
-    chainStepResults?: boolean;
-    /**
-     * Process input and execute the orchestrator workflow
-     *
-     * Workflow:
-     * 1. Extract the objective
-     * 2. Loop until plan completion or maximum iterations:
-     *    a. Generate/update execution plan
-     *    b. If plan is complete, synthesize result
-     *    c. Otherwise, execute steps in the plan
-     *
-     * @param input - Input message containing the objective
-     * @param options - Agent invocation options
-     * @returns Processing result
-     */
-    process(input: I, options: AgentInvokeOptions): Promise<O>;
-    private getFullPlanInput;
-    private getFullPlan;
-    private synthesizePlanResult;
-    private executeStep;
-}

package/lib/esm/agents/orchestrator/index.js

@@ -1,243 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import { AIAgent, Agent, MESSAGE_KEY, PromptTemplate, createMessage, getMessage, } from '@aigne/core';
-import { checkArguments } from '@aigne/core/utils/type-utils.js';
-import fastq from 'fastq';
-import { z } from 'zod';
-import { FULL_PLAN_PROMPT_TEMPLATE, SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE, SYNTHESIZE_STEP_PROMPT_TEMPLATE, TASK_PROMPT_TEMPLATE, getFullPlanSchema, } from './orchestrator-prompts.js';
-/**
- * Default maximum number of iterations to prevent infinite loops
- */
-const DEFAULT_MAX_ITERATIONS = 30;
-/**
- * Default number of concurrent tasks
- */
-const DEFAULT_TASK_CONCURRENCY = 5;
-/**
- * Re-export orchestrator prompt templates and related types
- */
-export * from './orchestrator-prompts.js';
-/**
- * Orchestrator Agent Class
- *
- * This Agent is responsible for:
- * 1. Generating an execution plan based on the objective
- * 2. Breaking down the plan into steps and tasks
- * 3. Coordinating the execution of steps and tasks
- * 4. Synthesizing the final result
- *
- * Workflow:
- * - Receives input objective
- * - Uses planner to create execution plan
- * - Executes tasks and steps according to the plan
- * - Synthesizes final result through completer
- */
-export class OrchestratorAgent extends Agent {
-    /**
-     * Factory method to create an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     * @returns A new OrchestratorAgent instance
-     */
-    static from(options) {
-        return new OrchestratorAgent(options);
-    }
-    /**
-     * Creates an OrchestratorAgent instance
-     * @param options - Configuration options for the Orchestrator Agent
-     */
-    constructor(options) {
-        checkArguments('OrchestratorAgent', orchestratorAgentOptionsSchema, options);
-        super({ ...options });
-        this.maxIterations = options.maxIterations;
-        this.tasksConcurrency = options.tasksConcurrency;
-        this.chainStepResults = options.chainStepResults;
-        this.planner = new AIAgent({
-            name: 'llm_orchestration_planner',
-            instructions: FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: () => getFullPlanSchema(this.skills),
-        });
-        this.completer = new AIAgent({
-            name: 'llm_orchestration_completer',
-            instructions: FULL_PLAN_PROMPT_TEMPLATE,
-            outputSchema: this.outputSchema,
-        });
-    }
-    planner;
-    completer;
-    /**
-     * Maximum number of iterations
-     * Prevents infinite execution loops
-     */
-    maxIterations;
-    /**
-     * Number of concurrent tasks
-     * Controls how many tasks can be executed simultaneously
-     */
-    tasksConcurrency;
-    /**
-     * Whether to chain step results as input to next step
-     */
-    chainStepResults;
-    /**
-     * Process input and execute the orchestrator workflow
-     *
-     * Workflow:
-     * 1. Extract the objective
-     * 2. Loop until plan completion or maximum iterations:
-     *    a. Generate/update execution plan
-     *    b. If plan is complete, synthesize result
-     *    c. Otherwise, execute steps in the plan
-     *
-     * @param input - Input message containing the objective
-     * @param options - Agent invocation options
-     * @returns Processing result
-     */
-    async process(input, options) {
-        const { model } = options.context;
-        if (!model)
-            throw new Error('model is required to run OrchestratorAgent');
-        const objective = getMessage(input);
-        if (!objective)
-            throw new Error('Objective is required to run OrchestratorAgent');
-        const result = {
-            objective,
-            steps: [],
-        };
-        let iterations = 0;
-        const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-        while (iterations++ < maxIterations) {
-            const plan = await this.getFullPlan(result, options.context);
-            result.plan = plan;
-            if (plan.isComplete) {
-                return this.synthesizePlanResult(result, options.context);
-            }
-            for (const step of plan.steps) {
-                const stepResult = await this.executeStep(result, step, options.context);
-                result.steps.push(stepResult);
-            }
-        }
-        throw new Error(`Max iterations reached: ${maxIterations}`);
-    }
-    getFullPlanInput(planResult) {
-        return {
-            objective: planResult.objective,
-            steps: planResult.steps,
-            plan: {
-                status: planResult.status ? 'Complete' : 'In Progress',
-                result: planResult.result || 'No results yet',
-            },
-            agents: this.skills.map((i) => ({
-                name: i.name,
-                description: i.description,
-                tools: i.skills.map((i) => ({ name: i.name, description: i.description })),
-            })),
-        };
-    }
-    async getFullPlan(planResult, context) {
-        return context.invoke(this.planner, this.getFullPlanInput(planResult));
-    }
-    async synthesizePlanResult(planResult, context) {
-        return context.invoke(this.completer, {
-            ...this.getFullPlanInput(planResult),
-            ...createMessage(SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE),
-        });
-    }
-    async executeStep(planResult, step, context) {
-        const concurrency = this.tasksConcurrency ?? DEFAULT_TASK_CONCURRENCY;
-        const { model } = context;
-        if (!model)
-            throw new Error('model is required to run OrchestratorAgent');
-        let lastTaskResult = {};
-        // 将上一步最后一个任务的输入作为下一步的输入
-        if (this.chainStepResults) {
-            if (planResult.steps.length > 0) {
-                const lastStep = planResult.steps[planResult.steps.length - 1];
-                if (lastStep?.result) {
-                    try {
-                        const lastStepResult = JSON.parse(lastStep.result);
-                        if (lastStepResult?.step?.results && Array.isArray(lastStepResult.step.results) && lastStepResult.step.results.length > 0) {
-                            const lastStepResults = lastStepResult.step.results[lastStepResult.step.results.length - 1];
-                            console.log('lastStepResults', lastStepResults.result);
-                            lastTaskResult = JSON.parse(lastStepResults.result);
-                        }
-                    }
-                    catch (error) {
-                        console.error('Failed to parse last step result', error);
-                    }
-                }
-            }
-        }
-        const queue = fastq.promise(async (task) => {
-            const agent = this.skills.find((skill) => skill.name === task.agent);
-            if (!agent)
-                throw new Error(`Agent ${task.agent} not found`);
-            const prompt = PromptTemplate.from(TASK_PROMPT_TEMPLATE).format({
-                // eslint-disable-next-line prettier/prettier
-                objective: planResult.objective,
-                step,
-                task,
-                steps: planResult.steps,
-            });
-            let result;
-            if (agent.isInvokable) {
-                result = getMessageOrJsonString(await context.invoke(agent, { ...lastTaskResult, [MESSAGE_KEY]: prompt }));
-            }
-            else {
-                const executor = AIAgent.from({
-                    name: 'llm_orchestration_task_executor',
-                    instructions: prompt,
-                    skills: agent.skills,
-                });
-                result = getMessageOrJsonString(await context.invoke(executor, this.chainStepResults ? { ...lastTaskResult } : {}));
-            }
-            return { task, result };
-        }, concurrency);
-        let results;
-        try {
-            results = await Promise.all(step.tasks.map((task) => queue.push(task)));
-        }
-        catch (error) {
-            queue.kill();
-            throw error;
-        }
-        let result = '';
-        if (!this.chainStepResults) {
-            result = getMessageOrJsonString(await context.invoke(AIAgent.from({
-                name: 'llm_orchestration_step_synthesizer',
-                instructions: SYNTHESIZE_STEP_PROMPT_TEMPLATE,
-            }), { objective: planResult.objective, step, tasks: results }));
-        }
-        else {
-            const resultData = {
-                step: {
-                    description: step.description,
-                    results: results.map((task) => ({
-                        agent: task.task.agent,
-                        task: task.task.description,
-                        result: task.result,
-                    })),
-                },
-            };
-            result = JSON.stringify(resultData);
-        }
-        if (!result)
-            throw new Error('unexpected empty result from synthesize step\'s tasks results');
-        return {
-            step,
-            tasks: results,
-            result,
-        };
-    }
-}
-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);
-}
-const orchestratorAgentOptionsSchema = z.object({
-    maxIterations: z.number().optional(),
-    tasksConcurrency: z.number().optional(),
-    chainStepResults: z.boolean().optional(),
-});

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

@@ -1,130 +0,0 @@
-import type { Agent, Message } from '@aigne/core';
-import { z } from 'zod';
-/**
- * @hidden
- */
-export declare const SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = "Synthesize the results of executing all steps in the plan into a cohesive result\n";
-/**
- * @hidden
- */
-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.ZodUnion<[z.ZodLiteral<string>, z.ZodLiteral<string>, ...z.ZodLiteral<string>[]]>;
-        }, "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">;
-    isComplete: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    steps: {
-        description: string;
-        tasks: {
-            description: string;
-            agent: string;
-        }[];
-    }[];
-    isComplete: boolean;
-}, {
-    steps: {
-        description: string;
-        tasks: {
-            description: string;
-            agent: string;
-        }[];
-    }[];
-    isComplete: boolean;
-}>;
-/**
- * @hidden
- */
-export type FullPlanOutput = z.infer<ReturnType<typeof getFullPlanSchema>>;
-/**
- * @hidden
- */
-export type Step = FullPlanOutput['steps'][number];
-/**
- * @hidden
- */
-export type Task = Step['tasks'][number];
-/**
- * @hidden
- */
-export interface StepWithResult {
-    step: Step;
-    tasks: Array<TaskWithResult>;
-    result: string;
-}
-/**
- * @hidden
- */
-export interface TaskWithResult {
-    task: Task;
-    result: string;
-}
-/**
- * @hidden
- */
-export interface FullPlanInput extends Message {
-    objective: string;
-    steps: StepWithResult[];
-    plan: {
-        status: string;
-        result: string;
-    };
-    agents: {
-        name: string;
-        description?: string;
-        tools: {
-            name: string;
-            description?: string;
-        }[];
-    }[];
-}
-/**
- * @hidden
- */
-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";
-/**
- * @hidden
- */
-export interface TaskPromptInput extends Message {
-    objective: string;
-    step: Step;
-    task: Task;
-    steps: StepWithResult[];
-}
-/**
- * @hidden
- */
-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";
-/**
- * @hidden
- */
-export interface SynthesizeStepPromptInput extends Message {
-    objective: string;
-    step: Step;
-    tasks: TaskWithResult[];
-}
-/**
- * @hidden
- */
-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";