@aigne/agent-library 1.22.4-beta → 1.23.0-beta

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

@@ -0,0 +1,505 @@
+import type { Message } from "@aigne/core";
+import z from "zod";
+/**
+ * Task execution status
+ */
+export type TaskStatus = "pending" | "completed" | "failed";
+/**
+ * Individual task execution record
+ */
+export interface TaskRecord {
+    /** Task description */
+    task: string;
+    /** Task execution status */
+    status: TaskStatus;
+    /** Task execution result (can be any type) */
+    result?: unknown;
+    /** Error information if task failed */
+    error?: {
+        message: string;
+    };
+    /** Timestamp when task was created */
+    createdAt?: number;
+    /** Timestamp when task was completed or failed */
+    completedAt?: number;
+}
+/**
+ * Execution state tracking all tasks
+ */
+export interface ExecutionState {
+    tasks: TaskRecord[];
+}
+export declare const taskRecordSchema: z.ZodObject<{
+    task: z.ZodString;
+    status: z.ZodEnum<["pending", "completed", "failed"]>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "completed" | "failed";
+    task: string;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: unknown;
+    createdAt?: number | undefined;
+    completedAt?: number | undefined;
+}, {
+    status: "pending" | "completed" | "failed";
+    task: string;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: unknown;
+    createdAt?: number | undefined;
+    completedAt?: number | undefined;
+}>;
+export declare const executionStateSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        task: z.ZodString;
+        status: z.ZodEnum<["pending", "completed", "failed"]>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }, {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tasks: {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[];
+}, {
+    tasks: {
+        status: "pending" | "completed" | "failed";
+        task: string;
+        error?: {
+            message: string;
+        } | undefined;
+        result?: unknown;
+        createdAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[];
+}>;
+export interface PlannerInput extends Message {
+    objective: string;
+    skills: {
+        name: string;
+        description?: string;
+    }[];
+    executionState: ExecutionState;
+}
+export declare const plannerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+    }>, "many">;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    skills: {
+        name: string;
+        description?: string | undefined;
+    }[];
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    skills: {
+        name: string;
+        description?: string | undefined;
+    }[];
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+export interface PlannerOutput extends Message {
+    nextTask?: string;
+    finished?: boolean;
+}
+export declare const plannerOutputSchema: z.ZodObject<{
+    nextTask: z.ZodOptional<z.ZodString>;
+    finished: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    nextTask?: string | undefined;
+    finished?: boolean | undefined;
+}, {
+    nextTask?: string | undefined;
+    finished?: boolean | undefined;
+}>;
+export interface WorkerInput extends Message {
+    objective: string;
+    executionState: ExecutionState;
+    task: string;
+}
+export declare const workerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    task: z.ZodString;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    task: string;
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+/**
+ * Worker output structure
+ */
+export interface WorkerOutput extends Message {
+    /** Task execution result */
+    result?: string;
+    /** Whether the task was completed successfully */
+    success: boolean;
+    /** Error information if task failed */
+    error?: {
+        message: string;
+    };
+}
+export declare const workerOutputSchema: z.ZodObject<{
+    result: z.ZodOptional<z.ZodString>;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: string | undefined;
+}, {
+    success: boolean;
+    error?: {
+        message: string;
+    } | undefined;
+    result?: string | undefined;
+}>;
+export interface CompleterInput extends Message {
+    objective: string;
+    executionState: ExecutionState;
+}
+export declare const completerInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    executionState: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodEnum<["pending", "completed", "failed"]>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+            }, {
+                message: string;
+            }>>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }, {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }, {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}, {
+    objective: string;
+    executionState: {
+        tasks: {
+            status: "pending" | "completed" | "failed";
+            task: string;
+            error?: {
+                message: string;
+            } | undefined;
+            result?: unknown;
+            createdAt?: number | undefined;
+            completedAt?: number | undefined;
+        }[];
+    };
+}>;
+/**
+ * Default maximum number of task execution iterations
+ */
+export declare const DEFAULT_MAX_ITERATIONS = 20;
+/**
+ * Options for managing execution state to prevent context overflow
+ */
+export interface StateManagementOptions {
+    /**
+     * Maximum tokens allowed for execution state
+     * When exceeded, triggers compression
+     */
+    maxTokens?: number;
+    /**
+     * Number of recent tasks to keep when compression is triggered
+     */
+    keepRecent?: number;
+    /**
+     * Maximum number of task execution iterations
+     * When reached, orchestrator will stop and synthesize final result
+     * @default 20
+     */
+    maxIterations?: number;
+}
+export declare const stateManagementOptionsSchema: z.ZodObject<{
+    maxTokens: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    keepRecent: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    maxIterations: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens?: number | undefined;
+    keepRecent?: number | undefined;
+    maxIterations?: number | undefined;
+}, {
+    maxTokens?: number | undefined;
+    keepRecent?: number | undefined;
+    maxIterations?: number | undefined;
+}>;

package/lib/esm/orchestrator/type.js

@@ -0,0 +1,77 @@
+import { optionalize } from "@aigne/core/loader/schema.js";
+import z from "zod";
+export const taskRecordSchema = z.object({
+    task: z.string().describe("The description of the executed task."),
+    status: z
+        .enum(["pending", "completed", "failed"])
+        .describe("The execution status of the task: pending, completed, or failed."),
+    result: z.unknown().optional().describe("The result produced by executing the task."),
+    error: z
+        .object({
+        message: z.string().describe("Error message if the task failed."),
+    })
+        .optional()
+        .describe("Error information if the task failed."),
+    createdAt: z.number().optional().describe("Timestamp when the task was created."),
+    completedAt: z.number().optional().describe("Timestamp when the task completed or failed."),
+});
+export const executionStateSchema = z.object({
+    tasks: z
+        .array(taskRecordSchema)
+        .describe("The list of tasks that have been executed along with their results."),
+});
+export const plannerInputSchema = z.object({
+    objective: z.string().describe("The user's overall objective."),
+    skills: z
+        .array(z.object({
+        name: z.string().describe("The name of the skill."),
+        description: z.string().optional().describe("A brief description of the skill."),
+    }))
+        .describe("The list of available skills the agent can use."),
+    executionState: executionStateSchema,
+});
+export const plannerOutputSchema = z.object({
+    nextTask: z
+        .string()
+        .optional()
+        .describe("The next task to be executed by the worker. Should contain a clear, actionable description of what needs to be done."),
+    finished: z
+        .boolean()
+        .optional()
+        .describe("Indicates if all tasks are completed and the objective has been achieved. Set to true when no more work is needed."),
+});
+export const workerInputSchema = z.object({
+    objective: z.string().describe("The user's overall objective."),
+    task: z.string().describe("The specific task assigned to the worker for execution."),
+    executionState: executionStateSchema,
+});
+export const workerOutputSchema = z.object({
+    result: z
+        .string()
+        .optional()
+        .describe("The text result or output produced by executing the task. Include key findings, data retrieved, or actions taken. Can be omitted if the task failed with no partial results."),
+    success: z
+        .boolean()
+        .describe("Whether the task completed successfully. Set to true if the task achieved its goal, false if it encountered errors or could not be completed."),
+    error: z
+        .object({
+        message: z
+            .string()
+            .describe("A clear description of what went wrong, including error type and relevant context to help with debugging or retry strategies."),
+    })
+        .optional()
+        .describe("Error details if the task failed. Only include when success is false."),
+});
+export const completerInputSchema = z.object({
+    objective: z.string().describe("The user's overall objective."),
+    executionState: executionStateSchema,
+});
+/**
+ * Default maximum number of task execution iterations
+ */
+export const DEFAULT_MAX_ITERATIONS = 20;
+export const stateManagementOptionsSchema = z.object({
+    maxTokens: optionalize(z.number().int().positive()),
+    keepRecent: optionalize(z.number().int().positive()),
+    maxIterations: optionalize(z.number().int().positive()),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/agent-library",
-  "version": "1.22.4-beta",
+  "version": "1.23.0-beta",
   "description": "Collection of agent libraries for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -29,9 +29,14 @@
   "types": "./lib/dts/index.d.ts",
   "exports": {
     "./*": {
-      "import": "./lib/esm/*",
-      "require": "./lib/cjs/*",
+      "import": "./lib/esm/*/index.js",
+      "require": "./lib/cjs/*/index.js",
       "types": "./lib/dts/*"
+    },
+    "./utils/*": {
+      "import": "./lib/esm/utils/*",
+      "require": "./lib/cjs/utils/*",
+      "types": "./lib/dts/utils/*"
     }
   },
   "typesVersions": {
@@ -49,9 +54,10 @@
     "jsonschema": "^1.5.0",
     "yaml": "^2.8.1",
     "zod": "^3.25.67",
-    "@aigne/sqlite": "^0.4.7",
-    "@aigne/core": "^1.70.1-beta",
-    "@aigne/openai": "^0.16.14-beta"
+    "zod-to-json-schema": "^3.24.6",
+    "@aigne/core": "^1.71.0-beta",
+    "@aigne/openai": "^0.16.15-beta",
+    "@aigne/sqlite": "^0.4.7"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",