@blocklet/pages-kit-agents 0.5.47 → 0.5.49

package/.env.local.example

@@ -9,3 +9,10 @@ XAI_API_KEY=""
 DEEPSEEK_API_KEY=""
 
 OPENAI_BASE_URL=https://openai.arcblock.io/v1
+
+PAGES_KIT_DEBUG_API_URL=<your-pages-kit-domain-with-mount-point>/api/sdk/upload-data
+PAGES_KIT_DEBUG_ACCESS_KEY_ID=
+PAGES_KIT_DEBUG_ACCESS_KEY_SECRET=
+PAGES_KIT_DEBUG_PROJECT_ID=
+
+

package/cli.ts

@@ -270,7 +270,7 @@ async function main() {
 
   if (modelsToRun.length === 0) {
     logger.warn(
-      'No models enabled. Please enable at least one model in config.yaml or specify a model via command line.'
+      'No available models. Please enable at least one model in config.yaml or specify a model via command line.'
     );
     return;
   }

package/index.ts

@@ -7,7 +7,6 @@ export {
 } from './agents/multi-agent-page-writer';
 export * from './agents/page-metadata-generator';
 export * from './agents/page-structure-planner';
-export * from './agents/page-structure-validator';
 export * from './agents/section-content-generator';
 
 // Export utilities that might be useful for consumers

package/lib/cjs/agents/content-reviwer.d.ts

@@ -10,8 +10,8 @@ export declare const contentReviewerAgent: AIAgent<{
         level: string;
         suggestions: string[];
         dimension_scores: {
-            score: number;
             name: string;
+            score: number;
             maxScore: number;
             comment: string;
         }[];

package/lib/cjs/agents/multi-agent-page-writer.js

@@ -8,7 +8,6 @@ const agent_utils_js_1 = require("../utils/agent-utils.js");
 const logger_js_1 = require("../utils/logger.js");
 const page_metadata_generator_js_1 = require("./page-metadata-generator.js");
 const page_structure_planner_js_1 = require("./page-structure-planner.js");
-const page_structure_validator_js_1 = require("./page-structure-validator.js");
 const section_content_generator_js_1 = require("./section-content-generator.js");
 /**
  * 多Agent协作生成页面内容
@@ -56,26 +55,20 @@ async function generatePageContentMultiAgent(input) {
         // 3-4 使用反思工作流生成页面结构
         const planningEngine = new core_1.AIGNE({
             model,
-            agents: [page_structure_planner_js_1.pageStructurePlannerAgent, page_structure_validator_js_1.pageStructureValidatorAgent],
-            limits: {
-                maxAgentInvokes: 30,
-            },
         });
-        await planningEngine.invoke(page_structure_planner_js_1.pageStructurePlannerAgent, {
+        const structurePlanResult = await planningEngine.invoke(page_structure_planner_js_1.pageStructurePlannerWithReflection, {
             context,
             question,
             locale,
-            initialStructurePlan: Object.entries(sectionsRules || {}).map(([sectionName, sectionContentPlan]) => ({
+            structurePlan: Object.entries(sectionsRules || {}).map(([sectionName, sectionContentPlan]) => ({
                 sectionName,
                 sectionContentPlan,
             })),
             outputSchema: JSON.stringify(outputSchemaJson),
             expectedSections: JSON.stringify(sectionNames),
         });
-        const structurePlanResult = await planningEngine.subscribe(core_1.UserOutputTopic);
-        const { structurePlan } = structurePlanResult.message;
+        const { structurePlan } = structurePlanResult;
         logger_js_1.logger.info(`[${modelName}] Initial structure plan generated`, structurePlan);
-        await planningEngine.shutdown();
         // 触发页面结构生成成功事件
         if (onProgress) {
             onProgress({

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

@@ -0,0 +1,115 @@
+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/cjs/agents/orchestrator/index.js

@@ -0,0 +1,264 @@
+"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;
+/* eslint-disable no-await-in-loop */
+const core_1 = require("@aigne/core");
+const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
+const fastq_1 = __importDefault(require("fastq"));
+const zod_1 = require("zod");
+const orchestrator_prompts_js_1 = require("./orchestrator-prompts.js");
+/**
+ * Default maximum number of iterations to prevent infinite loops
+ */
+const DEFAULT_MAX_ITERATIONS = 30;
+/**
+ * Default number of concurrent tasks
+ */
+const DEFAULT_TASK_CONCURRENCY = 5;
+/**
+ * Re-export orchestrator prompt templates and related types
+ */
+__exportStar(require("./orchestrator-prompts.js"), exports);
+/**
+ * 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
+ */
+class OrchestratorAgent extends core_1.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) {
+        (0, type_utils_js_1.checkArguments)('OrchestratorAgent', orchestratorAgentOptionsSchema, options);
+        super({ ...options });
+        this.maxIterations = options.maxIterations;
+        this.tasksConcurrency = options.tasksConcurrency;
+        this.chainStepResults = options.chainStepResults;
+        this.planner = new core_1.AIAgent({
+            name: 'llm_orchestration_planner',
+            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: () => (0, orchestrator_prompts_js_1.getFullPlanSchema)(this.skills),
+        });
+        this.completer = new core_1.AIAgent({
+            name: 'llm_orchestration_completer',
+            instructions: orchestrator_prompts_js_1.FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: this.outputSchema,
+        });
+    }
+    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 = (0, core_1.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),
+            ...(0, core_1.createMessage)(orchestrator_prompts_js_1.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_1.default.promise(async (task) => {
+            const agent = this.skills.find((skill) => skill.name === task.agent);
+            if (!agent)
+                throw new Error(`Agent ${task.agent} not found`);
+            const prompt = core_1.PromptTemplate.from(orchestrator_prompts_js_1.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, [core_1.MESSAGE_KEY]: prompt }));
+            }
+            else {
+                const executor = core_1.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(core_1.AIAgent.from({
+                name: 'llm_orchestration_step_synthesizer',
+                instructions: orchestrator_prompts_js_1.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,
+        };
+    }
+}
+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);
+}
+const orchestratorAgentOptionsSchema = zod_1.z.object({
+    maxIterations: zod_1.z.number().optional(),
+    tasksConcurrency: zod_1.z.number().optional(),
+    chainStepResults: zod_1.z.boolean().optional(),
+});

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

@@ -0,0 +1,130 @@
+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";