@aigne/agent-library 1.24.0 → 1.74.0-beta

package/lib/esm/data-mapper/index.js

@@ -1,16 +0,0 @@
-import { AIGNE, UserInputTopic, UserOutputTopic } from "@aigne/core";
-import mapper from "./agents/mapper.js";
-import reviewer from "./agents/reviewer.js";
-export async function generateMapping({ input, model, }) {
-    if (!model)
-        throw new Error("model is required to run data mapper");
-    const aigne = new AIGNE({ model, agents: [mapper, reviewer] });
-    aigne.publish(UserInputTopic, input);
-    const { message } = await aigne.subscribe(UserOutputTopic);
-    return {
-        jsonata: message.jsonata || "",
-        confidence: message.confidence || 0,
-        confidenceReasoning: message.confidenceReasoning || "",
-    };
-}
-export { applyJsonata } from "./tools.js";

package/lib/esm/data-mapper/prompts.d.ts

@@ -1 +0,0 @@
-export declare const PROMPT_MAPPING = "You are an AI that generates JSONata mapping expressions to transform source data structures into target structures.\n\nGuidelines for creating JSONata mappings:\n\n1. Source References:\n   - Use exact field paths from the source data, e.g. $.merchant_category\n   - For accessing fields with names containing spaces, use backticks, e.g. $.`merchant category`\n   - Jsonata will automatically extract all the fields from the current context. E.g. if you need all variants from all products, you can use $.products.variants. No need to do nested map reduce operations.\n   - $. The variable with no name refers to the context value at any point in the input JSON hierarchy. E.g. if the current context is products.price, then $.currency is products.price.currency\n   - %. The parent of the current context value. E.g. if the current context is products.variants.size and you want variant name, use %.name\n\n   - When multiple source fields could map to a target, use a maximum of 3 fallbacks:\n     GOOD: source1 ? source1 : source2 ? source2 : source3 ? source3 : 'default'\n     BAD: source1 ? source1 : source1 ? source1 : source1 (repeated fields)\n\n2. Expression Rules:\n   - Avoid unnecessary array/string operations\n   - Each mapping should be clear and concise\n   - Use proper JSONata syntax for coalesce operations\n   - Do not use ~> to execute functions. Use the functions directly with the correct arguments or use $map(arr, $function) to apply a function to each element of an array.\n\n3. Array Handling:\n   - For mapping to an array of objects, use the following patterns:\n     a) When in array scope, use $.{} to map each object:\n        Correct: [$.{\"id\": id, \"name\": name}]\n        Incorrect: [{\"id\": $.id}]\n     b) When outside array scope, include the source path:\n        Correct: [$.items.{\"id\": id, \"name\": name}]\n        Incorrect: [{\"id\": $.items.id}]\n     c) For nested arrays, chain the array operators:\n        Correct: [products.variants.{\"size\": size, \"color\": color}]\n        Incorrect: [products.[{\"size\": variants.size}]]\n     d) You need to use the square brackets [] to map to an array of objects, otherwise it might return an object and fail the validation.\n        Correct: variants: [variants.{\"size\": size, \"color\": color}]\n        Incorrect: variants: variants.{\"size\": variants.size}\n   - For array elements, use JSONata array operators like [0] for first element, [-1] for last element\n   - Square bracket notation [] can be used with predicates, e.g. items[type='book']\n\n4. Field Selection Priority:\n   - Prefer variant-specific fields over general fields (e.g., sizeVariants.description over sizes)\n   - Choose the most specific/detailed field available (e.g., type=\"shelf\" over category=\"furniture\")\n\n5. Filters:\n   - Pay special attention to filter statements in the instruction and the schema description. Add them to the generated jsonata expression.\n     Example: Get me all products with SKU 0406654608 or products: {\"type\": \"array\", description: \"only products with SKU 0406654608\"}\n     Generated jsonata expression: Account.Order.Product[SKU = \"0406654608\"].{\"Description\": Description}\n   - For filtering with arrays, you can use the \"in\" operator. E.g. library.books[\"Steven King\" in authors]\n\n6. Data Integrity:\n   - ONLY use fields that exist in the source data structure\n   - If no matching source field exists, leave the field undefined\n   - Never invent or assume the existence of fields not present in the source data\n\n7. Function Calls:\n   - You may use the following functions if prompted:\n      $string(arg) - Converts argument to string\n      $length(str) - Returns string length\n      $substring(str, start[, length]) - Extracts substring\n      $substringBefore(str, chars) - Gets substring before specified chars\n      $substringAfter(str, chars) - Gets substring after specified chars\n      $uppercase(str) - Converts to uppercase\n      $lowercase(str) - Converts to lowercase\n      $trim(str) - Removes whitespace from both ends\n      $pad(str, width[, char]) - Pads string to specified width\n      $contains(str, substring) - Tests if string contains substring\n      $toMillis(timestamp [, picture]) - Converts ISO 8601 timestamp to milliseconds. E.g. $toMillis(\"2017-11-07T15:07:54.972Z\") => 1510067274972\n      $toDate(str | number) - Converts any timestamp string to valid ISO 8601 date string. E.g. $toDate(\"Oct 15, 2024 12:00:00 AM UTC\") => \"2024-10-15T00:00:00.000Z\", $toDate(1728873600000) => \"2024-10-15T00:00:00.000Z\"\n      $dateMax(arr) - Returns the maximum date of an array of dates. E.g. $dateMax([\"2017-11-07T15:07:54.972Z\", \"Oct 15, 2012 12:00:00 AM UTC\"]) returns \"2017-11-07T15:07:54.972Z\".\n      $dateMin(arr) - Returns the minimum date of an array of dates. E.g. $dateMin($.variants.created_at) returns the minimum created_at date of all variants.\n      $dateDiff(date1, date2, unit: \"seconds\" | \"minutes\" | \"hours\" | \"days\") - Returns the difference between two dates in the specified unit. E.g. $dateDiff($.order.created_at, $.order.updated_at, \"days\") returns the number of days between the order created_at and updated_at.\n      $now([picture [, timezone]]) - Returns current date and time in ISO 8601 format. E.g. $now() => \"2017-05-15T15:12:59.152Z\"\n      $split(str[, separator][, limit]) - Splits string into array\n      $join(array[, separator]) - Joins array elements into string\n      $match(str, pattern[, limit]) - Returns array of regex matches\n      $replace(str, pattern, replacement) - Replaces all occurrences of pattern. E.g. $replace(\"abracadabra\", /a.*?a/, \"*\") returns \"ab*ad*bra\". $replace(\"John Smith\", \"John\", \"Marc\") returns Marc Smith.\n      $number(arg) - Converts an argument to a number.\n      $min(arr) - Returns minimum number of a number array. E.g. $min($map($.variants.price, $number)) returns the minimum price of all variants.\n      $max(arr) - Returns maximum number of a number array. E.g. $max($map($.variants.price, $number)) returns the maximum price of all variants.\n      $count(array) - Returns array length\n      $sort(array[, function]) - Sorts array\n      $distinct(array) - Removes duplicates\n      $map(array, function) - Applies function to each element\n      $filter(array, function) - Filters array based on predicate\n\n- Error handling:\n  - If you get an error like \"is not of a type(s) string/number/object\", try to convert the source field, but also consider that the original field or one of its parent might be null. In this case, add a default value.\n  - If the error is something like \"instance is not of a type(s) object\", make sure you REALLY create the target schema with the correct type.\n  - If the error is something like \"instance is not of a type(s) array or array/null\". In this case, wrap the source selector in an array to ensure it always returns an array. E.g. \"result\": [$.items]\n  - if an object is optional but its fields required, you can add a test and default to {}, but do not set the inner fields to default null.\n\nRemember: The goal is to create valid JSONata expressions that accurately transform the source data structure into the required target structure.";

package/lib/esm/data-mapper/tools.d.ts

@@ -1,11 +0,0 @@
-import jsonata from "jsonata";
-import type { Schema } from "jsonschema";
-export interface TransformResult {
-    success: boolean;
-    data?: unknown;
-    error?: string;
-}
-export declare function applyJsonataWithValidation(data: unknown, expr: string, schema: unknown): Promise<TransformResult>;
-export declare function applyJsonata(data: unknown, expr: string): Promise<unknown>;
-export declare function extendJsonata(expr: string): jsonata.Expression;
-export declare function addNullableToOptional(schema: Schema): Schema;

package/lib/esm/data-mapper/tools.js

@@ -1,155 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import jsonata from "jsonata";
-import { Validator } from "jsonschema";
-export async function applyJsonataWithValidation(data, expr, schema) {
-    try {
-        const result = await applyJsonata(data, expr);
-        if (result === null ||
-            result === undefined ||
-            (Array.isArray(result) && result.length === 0) ||
-            (typeof result === "object" && Object.keys(result).length === 0)) {
-            return { success: false, error: "Result is empty" };
-        }
-        const validator = new Validator();
-        const optionalSchema = addNullableToOptional(schema);
-        const validation = validator.validate(result, optionalSchema);
-        if (!validation.valid) {
-            return {
-                success: false,
-                error: validation.errors
-                    .map((e) => `${e.stack}. Source: ${e.instance ? JSON.stringify(e.instance) : "undefined"}`)
-                    .join("\n")
-                    .slice(0, 5000),
-            };
-        }
-        return { success: true, data: result };
-    }
-    catch (error) {
-        return { success: false, error: `Validation failed: ${error.message}` };
-    }
-}
-export async function applyJsonata(data, expr) {
-    try {
-        const expression = extendJsonata(expr);
-        const result = await expression.evaluate(data);
-        return result;
-    }
-    catch (error) {
-        throw new Error(`JSONata evaluation failed for expression "${expr}": ${error.message}`);
-    }
-}
-export function extendJsonata(expr) {
-    const expression = jsonata(expr);
-    expression.registerFunction("max", (arr) => {
-        if (Array.isArray(arr)) {
-            return Math.max(...arr.map(Number).filter((n) => !Number.isNaN(n)));
-        }
-        return arr;
-    });
-    expression.registerFunction("min", (arr) => {
-        if (Array.isArray(arr)) {
-            return Math.min(...arr.map(Number).filter((n) => !Number.isNaN(n)));
-        }
-        return arr;
-    });
-    expression.registerFunction("number", (value) => Number.parseFloat(value));
-    expression.registerFunction("substring", (str, start, end) => String(str).substring(start, end));
-    expression.registerFunction("replace", (obj, pattern, replacement) => {
-        if (Array.isArray(obj)) {
-            return obj.map((item) => String(item).replace(pattern, replacement));
-        }
-        if (typeof obj === "object") {
-            return Object.fromEntries(Object.entries(obj || {}).map(([key, value]) => [
-                key,
-                String(value).replace(pattern, replacement),
-            ]));
-        }
-        return String(obj).replace(pattern, replacement);
-    });
-    expression.registerFunction("toDate", (date) => {
-        try {
-            // Handle numeric timestamps (milliseconds or seconds)
-            if (typeof date === "number" || /^\d+$/.test(date)) {
-                const timestamp = typeof date === "number" ? date : Number.parseInt(date, 10);
-                // If timestamp is in seconds (typically 10 digits), convert to milliseconds
-                const millisTimestamp = timestamp < 10000000000 ? timestamp * 1000 : timestamp;
-                return new Date(millisTimestamp).toISOString();
-            }
-            // Handle date strings in MM/DD/YYYY format
-            const match = String(date).match(/^(\d{2})\/(\d{2})\/(\d{4})(?:\s+(\d{2}):(\d{2}):(\d{2}))?$/);
-            if (match) {
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                const [_, month, day, year, hours = "00", minutes = "00", seconds = "00"] = match;
-                const isoDate = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.000Z`;
-                return new Date(isoDate).toISOString();
-            }
-            // Default case: try standard Date parsing
-            return new Date(date).toISOString();
-        }
-        catch (e) {
-            throw new Error(`Invalid date: ${e.message}`);
-        }
-    });
-    expression.registerFunction("dateMax", (dates) => dates.reduce((max, curr) => (new Date(max) > new Date(curr) ? max : curr)));
-    expression.registerFunction("dateMin", (dates) => dates.reduce((min, curr) => (new Date(min) < new Date(curr) ? min : curr)));
-    expression.registerFunction("dateDiff", (date1, date2, unit = "days") => {
-        const d1 = new Date(date1);
-        const d2 = new Date(date2);
-        const diff = Math.abs(d1.getTime() - d2.getTime());
-        switch (unit.toLowerCase()) {
-            case "seconds":
-                return Math.floor(diff / 1000);
-            case "minutes":
-                return Math.floor(diff / (1000 * 60));
-            case "hours":
-                return Math.floor(diff / (1000 * 60 * 60));
-            case "days":
-                return Math.floor(diff / (1000 * 60 * 60 * 24));
-            default:
-                return diff; // milliseconds
-        }
-    });
-    return expression;
-}
-export function addNullableToOptional(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    const newSchema = { ...schema };
-    if (schema.type === "object" && schema.properties) {
-        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
-            // biome-ignore lint/performance/noAccumulatingSpread: false positive
-            ...acc,
-            [key]: !required.has(key) ? makeNullable(value) : addNullableToOptional(value),
-        }), {});
-    }
-    if (schema.type === "array" && schema.items) {
-        newSchema.items = addNullableToOptional(schema.items);
-    }
-    return newSchema;
-}
-function makeNullable(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    const newSchema = { ...schema };
-    if (Array.isArray(schema.type)) {
-        if (!schema.type.includes("null")) {
-            newSchema.type = [...schema.type, "null"];
-        }
-    }
-    else if (schema.type) {
-        newSchema.type = [schema.type, "null"];
-    }
-    // Recursively process nested properties
-    if (schema.properties) {
-        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
-            // biome-ignore lint/performance/noAccumulatingSpread: false positive
-            ...acc,
-            [key]: makeNullable(value),
-        }), {});
-    }
-    if (schema.items) {
-        newSchema.items = makeNullable(schema.items);
-    }
-    return newSchema;
-}

package/lib/esm/index.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/esm/index.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,78 +0,0 @@
-import { type AgentInvokeOptions, type AgentOptions, AIAgent, type AIAgentOptions, type Message, type PromptBuilder } from "@aigne/core";
-import { type NestAgentSchema } from "@aigne/core/loader/agent-yaml.js";
-import type { AgentLoadOptions } from "@aigne/core/loader/index.js";
-import { type Instructions } from "@aigne/core/loader/schema.js";
-import { type ZodType } from "zod";
-import { type StateManagementOptions } from "./type.js";
-/**
- * Configuration options for the Orchestrator Agent
- */
-export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends Omit<AIAgentOptions<I, O>, "instructions"> {
-    objective?: PromptBuilder;
-    planner?: OrchestratorAgent<I, O>["planner"];
-    worker?: OrchestratorAgent<I, O>["worker"];
-    completer?: OrchestratorAgent<I, O>["completer"];
-    /**
-     * Configuration for managing execution state
-     * Prevents context overflow during long-running executions
-     */
-    stateManagement?: StateManagementOptions;
-    concurrency?: number;
-}
-export interface LoadOrchestratorAgentOptions {
-    objective?: string | Instructions;
-    planner?: NestAgentSchema;
-    worker?: NestAgentSchema;
-    completer?: NestAgentSchema;
-    stateManagement?: StateManagementOptions;
-}
-/**
- * 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 AIAgent<I, O> {
-    tag: string;
-    static schema<T>({ filepath }: {
-        filepath: string;
-    }): ZodType<T>;
-    static load<I extends Message = Message, O extends Message = Message>({ filepath, parsed, options, }: {
-        filepath: string;
-        parsed: LoadOrchestratorAgentOptions & AgentOptions<I, O>;
-        options?: AgentLoadOptions;
-    }): Promise<OrchestratorAgent<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 objective?;
-    private planner;
-    private worker;
-    private completer;
-    private stateManagement?;
-    private concurrency;
-    /**
-     * Compress execution state to prevent context overflow
-     * Uses reverse accumulation to efficiently find optimal task count
-     */
-    private compressState;
-    process(input: I, options: AgentInvokeOptions): AsyncGenerator<import("@aigne/core").AgentResponseChunk<O>, void, unknown>;
-}
-export default OrchestratorAgent;

package/lib/esm/orchestrator/index.js

@@ -1,240 +0,0 @@
-import { AIAgent, } from "@aigne/core";
-import { getNestAgentSchema } from "@aigne/core/loader/agent-yaml.js";
-import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize, } from "@aigne/core/loader/schema.js";
-import { isAgent } from "@aigne/core/utils/agent-utils.js";
-import * as fastq from "@aigne/core/utils/queue.js";
-import { estimateTokens } from "@aigne/core/utils/token-estimator.js";
-import { omit, pick } from "@aigne/core/utils/type-utils.js";
-import { z } from "zod";
-import { ORCHESTRATOR_COMPLETE_PROMPT, TODO_PLANNER_PROMPT_TEMPLATE, TODO_WORKER_PROMPT_TEMPLATE, } from "./prompt.js";
-import { completerInputSchema, DEFAULT_MAX_ITERATIONS, plannerInputSchema, plannerOutputSchema, stateManagementOptionsSchema, workerInputSchema, workerOutputSchema, } from "./type.js";
-const defaultPlannerOptions = {
-    name: "Planner",
-    instructions: TODO_PLANNER_PROMPT_TEMPLATE,
-    inputSchema: plannerInputSchema,
-    outputSchema: plannerOutputSchema,
-};
-const defaultWorkerOptions = {
-    name: "Worker",
-    taskTitle: "Execute Task: {{task}}",
-    instructions: TODO_WORKER_PROMPT_TEMPLATE,
-    inputSchema: workerInputSchema,
-    outputSchema: workerOutputSchema,
-};
-const defaultCompleterOptions = {
-    name: "Completer",
-    instructions: ORCHESTRATOR_COMPLETE_PROMPT,
-    inputSchema: completerInputSchema,
-};
-const DEFAULT_CONCURRENCY = 5;
-/**
- * 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 AIAgent {
-    tag = "OrchestratorAgent";
-    static schema({ filepath }) {
-        const nestAgentSchema = getNestAgentSchema({ filepath });
-        const instructionsSchema = getInstructionsSchema({ filepath });
-        return camelizeSchema(z.object({
-            objective: optionalize(instructionsSchema),
-            planner: optionalize(nestAgentSchema),
-            worker: optionalize(nestAgentSchema),
-            completer: optionalize(nestAgentSchema),
-            stateManagement: optionalize(camelizeSchema(stateManagementOptionsSchema)),
-            concurrency: optionalize(z.number().int().min(1).default(DEFAULT_CONCURRENCY)),
-        }));
-    }
-    static async load({ filepath, parsed, options, }) {
-        const valid = await OrchestratorAgent.schema({
-            filepath,
-        }).parseAsync(parsed);
-        return new OrchestratorAgent({
-            ...parsed,
-            objective: valid.objective ? instructionsToPromptBuilder(valid.objective) : undefined,
-            planner: valid.planner
-                ? (await options?.loadNestAgent(filepath, valid.planner, options, {
-                    ...defaultPlannerOptions,
-                    afs: parsed.afs,
-                    skills: parsed.skills,
-                }))
-                : undefined,
-            worker: valid.worker
-                ? (await options?.loadNestAgent(filepath, valid.worker, options, {
-                    ...defaultWorkerOptions,
-                    afs: parsed.afs,
-                    skills: parsed.skills,
-                }))
-                : undefined,
-            completer: valid.completer
-                ? (await options?.loadNestAgent(filepath, valid.completer, options, {
-                    ...defaultCompleterOptions,
-                    outputSchema: parsed.outputSchema,
-                    afs: parsed.afs,
-                    skills: parsed.skills,
-                }))
-                : undefined,
-            stateManagement: valid.stateManagement,
-        });
-    }
-    /**
-     * 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) {
-        super({ ...options });
-        this.objective = options.objective;
-        this.planner = isAgent(options.planner)
-            ? options.planner
-            : new AIAgent({
-                ...options,
-                ...defaultPlannerOptions,
-            });
-        this.worker = isAgent(options.worker)
-            ? options.worker
-            : new AIAgent({
-                ...options,
-                ...defaultWorkerOptions,
-            });
-        this.completer = isAgent(options.completer)
-            ? options.completer
-            : new AIAgent({
-                ...omit(options, "inputSchema"),
-                ...defaultCompleterOptions,
-                outputKey: options.outputKey,
-                outputSchema: options.outputSchema,
-            });
-        // Initialize state management config
-        this.stateManagement = options.stateManagement;
-        this.concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-    }
-    objective;
-    planner;
-    worker;
-    completer;
-    stateManagement;
-    concurrency;
-    /**
-     * Compress execution state to prevent context overflow
-     * Uses reverse accumulation to efficiently find optimal task count
-     */
-    compressState(state) {
-        const { maxTokens, keepRecent } = this.stateManagement ?? {};
-        if (!maxTokens && !keepRecent) {
-            return state;
-        }
-        const tasks = state.tasks;
-        let selectedTasks = tasks;
-        // Step 1: Apply keepRecent limit if configured
-        if (keepRecent && tasks.length > keepRecent) {
-            selectedTasks = tasks.slice(-keepRecent);
-        }
-        // Step 2: Apply maxTokens limit if configured
-        if (maxTokens && selectedTasks.length > 0) {
-            // Start from the most recent task and accumulate backwards
-            let accumulatedTokens = 0;
-            let taskCount = 0;
-            for (let i = selectedTasks.length - 1; i >= 0; i--) {
-                const taskJson = JSON.stringify(selectedTasks[i]);
-                const taskTokens = estimateTokens(taskJson);
-                if (accumulatedTokens + taskTokens > maxTokens && taskCount > 0) {
-                    // Stop if adding this task would exceed limit
-                    break;
-                }
-                accumulatedTokens += taskTokens;
-                taskCount++;
-            }
-            // Keep the most recent N tasks that fit within token limit
-            if (taskCount < selectedTasks.length) {
-                selectedTasks = selectedTasks.slice(-taskCount);
-            }
-        }
-        return { tasks: selectedTasks };
-    }
-    async *process(input, options) {
-        const model = this.model || options.model || options.context.model;
-        if (!model)
-            throw new Error("model is required to run OrchestratorAgent");
-        const objective = (await this.objective?.buildPrompt({
-            input,
-            context: options.context,
-        }))?.prompt;
-        const executionState = { tasks: [] };
-        let iterationCount = 0;
-        const maxIterations = this.stateManagement?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-        while (true) {
-            // Check if maximum iterations reached
-            if (maxIterations && iterationCount >= maxIterations) {
-                console.warn(`Maximum iterations (${maxIterations}) reached. Stopping execution.`);
-                executionState.tasks.push({
-                    status: "failed",
-                    error: { message: `ERROR: Maximum iterations (${maxIterations}) reached` },
-                    task: `ERROR: Objective not completed within iteration limit of ${maxIterations}`,
-                    createdAt: Date.now(),
-                    completedAt: Date.now(),
-                });
-                break;
-            }
-            iterationCount++;
-            // Compress state for planner input if needed
-            const compressedState = this.compressState(executionState);
-            const plan = await this.invokeChildAgent(this.planner, {
-                objective,
-                executionState: compressedState,
-                ...pick(input, this.planner.inputKeys),
-            }, { ...options, model, streaming: false });
-            if (plan.finished || !plan.nextTasks?.length) {
-                break;
-            }
-            const createdAt = Date.now();
-            const queue = fastq.promise(async ({ task }) => {
-                const taskResult = await this.invokeChildAgent(this.worker, {
-                    objective,
-                    executionState: compressedState,
-                    task,
-                    ...pick(input, this.worker.inputKeys),
-                }, { ...options, model, streaming: false })
-                    .then((res) => {
-                    if (res.error || res.success === false) {
-                        return { status: "failed", result: res.result, error: res.error };
-                    }
-                    return { status: "completed", result: res.result };
-                })
-                    .catch((error) => ({
-                    status: "failed",
-                    error: { message: error instanceof Error ? error.message : String(error) },
-                }));
-                return { ...taskResult, task, createdAt, completedAt: Date.now() };
-            }, plan.parallelTasks ? this.concurrency : 1);
-            const taskResults = await Promise.all(plan.nextTasks.map((task) => queue.push({ task })));
-            executionState.tasks.push(...taskResults);
-        }
-        // Compress state for completer input if needed
-        const compressedState = this.compressState(executionState);
-        yield* await this.invokeChildAgent(this.completer, {
-            objective,
-            executionState: compressedState,
-            ...pick(input, this.completer.inputKeys),
-        }, { ...options, model, streaming: true });
-    }
-}
-export default OrchestratorAgent;

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

@@ -1,3 +0,0 @@
-export declare const ORCHESTRATOR_COMPLETE_PROMPT = "You are an intelligent assistant that synthesizes and presents the results of completed tasks.\n\n{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's latest objective you need to address\"\n{{ objective }}\n```\n\n## Current Execution State\n\n```yaml alt=\"The latest execution state\"\n{{ executionState | yaml.stringify }}\n```\n\n## Your Task\nBased on the execution results above, provide a comprehensive and helpful response to the user's objective.\n";
-export declare const TODO_PLANNER_PROMPT_TEMPLATE = "Your responsibility is to decide the next tasks based on the current execution state.\n\n## Responsibilities\n\nYou are the Planner in the Orchestrator. The entire Orchestrator completes tasks through collaboration of three roles:\n\n1. **Planner (you)** analyzes the current state and outputs \"nextTasks\" (one or more tasks)\n2. **Worker** executes the tasks and updates the execution state\n3. **Loop back to step 1**, Planner plans the next tasks based on the new state\n4. **Repeat steps 1-3** until Planner determines the objective is complete\n5. **Planner** sets \"finished: true\"\n6. **Completer** generates the final report and returns it to the user\n\n{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's next objective you need to plan for\"\n{{ objective }}\n```\n\n## Current Execution State\n\n```yaml alt=\"The latest execution state\"\n{{ executionState | yaml.stringify }}\n```\n\n## How to Plan Tasks\n\n### 1. Determine if Tasks Are Needed\n\nFirst, assess whether the objective requires any tasks at all. Ask yourself:\n\n**Does this objective require tasks?**\n\nConsider if completing the objective needs:\n- **Information gathering**: Does it need to collect or retrieve information?\n- **Analysis or processing**: Does it need to analyze, process, or compute something?\n- **State dependency**: Does it depend on information not yet in the execution state?\n\n**Set \"finished: true\" immediately when:**\n- The objective requires no exploration, analysis, or information gathering\n- The current execution state already contains everything needed to respond\n- The objective is purely conversational without requiring any action\n\n**Plan tasks when:**\n- The objective requires gathering information from external sources\n- The objective requires analysis, processing, or computation to be performed\n- Additional information must be collected before a complete response can be given\n\n### 2. Analyze Information Requirements\n\nIf tasks are needed, think about the current state and objective:\n- What information is needed to complete the objective?\n- Where can this information be obtained from?\n- What information has already been collected? What is still missing?\n- Is deeper exploration needed, or is it ready to generate a summary?\n\n### 3. Decision Principles\n\n- **Plan one or more tasks per iteration**: You can output multiple tasks when they are independent\n- **Only decide, don't execute**: You only output task descriptions, actual execution is done by the Worker\n- **Trust the iterative process**: You will be called again after tasks complete, allowing you to adjust the plan dynamically\n- **Avoid duplicate work**: Review the execution history to understand what has been completed\n- **Goal-oriented descriptions**: Task descriptions should state \"what to do\", not \"how to do it\"\n- **Handle failures appropriately**: If a previous task failed, decide whether to retry, skip, or use an alternative approach\n\n### 4. Parallel vs Sequential Execution\n\nYou can specify whether tasks should run in parallel or sequentially using `parallelTasks`.\n\n**IMPORTANT: When tasks run in parallel, they CANNOT see each other's results.** Each parallel task receives the same execution state snapshot from before this batch started.\n\n**Set `parallelTasks: true` ONLY when ALL conditions are met:**\n- Tasks operate on **completely independent** data sources or resources\n- Task results are **not needed by other tasks** in the same batch\n- Tasks have **no ordering requirements** between them\n- You are **100% certain** there are no dependencies\n\n**Set `parallelTasks: false` (default) when ANY of these apply:**\n- Any task needs results from another task in the same batch\n- Tasks must be executed in a specific order\n- Tasks operate on shared resources that could conflict\n- You are **uncertain** whether tasks are truly independent\n\n**When in doubt, use sequential execution.** It's safer to be slower than to produce incorrect results.\n\n### 5. Decision Making at Different Stages\n\nFlexibly decide the next step based on current progress:\n\n**Exploration Stage**:\n- Plan exploration tasks to gather required information\n- If exploring multiple independent sources, consider parallel execution\n\n**Processing Stage**:\n- Process gathered information\n- Use sequential execution when processing depends on previous results\n\n**Summary Stage**:\n- When sufficient information is collected, plan to generate a summary or report task\n\n**Completion Stage**:\n- Set \"finished: true\" when:\n  - The objective doesn't require any tasks\n  - All necessary tasks are completed\n  - The objective is fully achieved\n- This will trigger the Completer to integrate all information and generate the final report\n\n## Understanding Task Status\n\nEach task in the execution state has a status:\n- **completed**: Task finished successfully, result is available\n- **failed**: Task encountered an error, check error field for details\n- **pending**: Task has not been executed yet\n\n## Output Format\n\n```yaml\nnextTasks:            # List of tasks to execute (omit if finished)\n  - \"task description 1\"\n  - \"task description 2\"\nparallelTasks: false  # true if tasks can run in parallel, false for sequential (default: false)\nfinished: false       # true if objective is achieved and no more tasks needed\n```\n\n**Notes:**\n- Task descriptions should be **goal-oriented**, not specifying concrete operations\n- Let the worker autonomously decide how to complete each task\n- Default to sequential execution (`parallelTasks: false`) unless you're certain tasks are independent\n- When `finished: true`, omit `nextTasks`\n";
-export declare const TODO_WORKER_PROMPT_TEMPLATE = "You are a task execution agent. Your job is to execute the specific task assigned to you - nothing more, nothing less.\n\n{% if $afs.enabled %}\n## Environment\n\n### AFS\n{{ $afs.description }}\n\n```yaml alt=\"The modules available in the AFS\"\n{{ $afs.modules | yaml.stringify }}\n```\n{% endif %}\n\n## User's Objective\n\n```txt alt=\"The user's objective provide for context only\"\n{{ objective }}\n```\n\n**CRITICAL CONSTRAINT**: The objective above is provided ONLY for context. You must NOT attempt to:\n- Solve the entire objective\n- Plan additional steps beyond your current task\n- Make decisions about what should happen next\n- Execute any tasks other than the one explicitly assigned to you below\n\n## Latest Execution State\n\n```yaml alt=\"The latest execution state for your reference\"\n{{ executionState | yaml.stringify }}\n```\n\n## Your Current Task\n\n```txt alt=\"The specific task you need to execute now\"\n{{ task }}\n```\n\n## Important Instructions\n- Focus EXCLUSIVELY on completing the current task described above\n- The task is self-contained - execute it completely and accurately\n- Do NOT perform additional tasks beyond what is specified\n- Do NOT try to determine what should happen after this task\n- Use the available tools and skills to accomplish this specific task\n- Return a clear result that the planner can use to decide the next step\n\n## Output Format\nReturn your task execution result as a structured response. The output schema will guide you on the required fields.\n";