@aigne/core 1.71.0-beta.2 → 1.71.0-beta.5

package/lib/cjs/prompt/skills/afs/edit.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSEditAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSEditAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_edit",
+            description: "Apply precise line-based patches to modify file content. Use when making targeted changes without rewriting the entire file.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to edit"),
+                patches: zod_1.z
+                    .array(zod_1.z.object({
+                    start_line: zod_1.z.number().int().describe("Start line number (0-based, inclusive)"),
+                    end_line: zod_1.z.number().int().describe("End line number (0-based, exclusive)"),
+                    replace: zod_1.z.string().optional().describe("New content to replace the line range"),
+                    delete: zod_1.z.boolean().describe("Delete mode: true to delete lines, false to replace"),
+                }))
+                    .min(1)
+                    .describe("List of patches to apply sequentially"),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                message: zod_1.z.string(),
+                content: zod_1.z.string(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        if (!input.patches?.length) {
+            throw new Error("No patches provided for afs_edit.");
+        }
+        const readResult = await this.afs.read(input.path);
+        if (!readResult.result?.content || typeof readResult.result.content !== "string") {
+            throw new Error(`Cannot read file content from: ${input.path}`);
+        }
+        const originalContent = readResult.result.content;
+        const updatedContent = this.applyCustomPatches(originalContent, input.patches);
+        await this.afs.write(input.path, {
+            content: updatedContent,
+        });
+        return {
+            status: "success",
+            tool: "afs_edit",
+            path: input.path,
+            message: `Applied ${input.patches.length} patches to ${input.path}`,
+            content: updatedContent,
+        };
+    }
+    applyCustomPatches(text, patches) {
+        // Sort by start_line to ensure sequential application
+        const sorted = [...patches].sort((a, b) => a.start_line - b.start_line);
+        const lines = text.split("\n");
+        for (let i = 0; i < sorted.length; i++) {
+            const patch = sorted[i];
+            if (!patch)
+                continue;
+            const start = patch.start_line;
+            const end = patch.end_line;
+            const deleteCount = end - start; // [start, end) range
+            let delta = 0;
+            if (patch.delete) {
+                // Delete mode: remove the specified lines [start, end)
+                lines.splice(start, deleteCount);
+                delta = -deleteCount;
+            }
+            else {
+                // Replace mode: replace the specified lines with new content
+                const replaceLines = patch.replace ? patch.replace.split("\n") : [];
+                lines.splice(start, deleteCount, ...replaceLines);
+                delta = replaceLines.length - deleteCount;
+            }
+            // Update subsequent patches' line numbers
+            // For exclusive-end semantics [start, end), we adjust patches that start >= current patch's start_line
+            // after the current patch has been applied
+            if (delta !== 0) {
+                for (let j = i + 1; j < sorted.length; j++) {
+                    const next = sorted[j];
+                    if (!next)
+                        continue;
+                    // Adjust patches that start at or after the current patch's end line
+                    if (next.start_line >= patch.end_line) {
+                        next.start_line += delta;
+                        next.end_line += delta;
+                    }
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+}
+exports.AFSEditAgent = AFSEditAgent;

package/lib/cjs/prompt/skills/afs/exec.d.ts

@@ -0,0 +1,15 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSExecInput extends Message {
+    path: string;
+    args: string;
+}
+export interface AFSExecOutput extends Message {
+    result: Record<string, any>;
+}
+export interface AFSExecAgentOptions extends AgentOptions<AFSExecInput, AFSExecOutput> {
+    afs: NonNullable<AgentOptions<AFSExecInput, AFSExecOutput>["afs"]>;
+}
+export declare class AFSExecAgent extends Agent<AFSExecInput, AFSExecOutput> {
+    constructor(options: AFSExecAgentOptions);
+    process(input: AFSExecInput, options: AgentInvokeOptions): Promise<AFSExecOutput>;
+}

package/lib/cjs/prompt/skills/afs/exec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSExecAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSExecAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_exec",
+            description: "Execute functions or commands from AFS modules. Use when running operations provided by mounted modules.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute path to the executable function in AFS"),
+                args: zod_1.z.string().describe("JSON string of arguments matching the function's input schema"),
+            }),
+            outputSchema: zod_1.z.object({
+                result: zod_1.z.record(zod_1.z.any()),
+            }),
+        });
+    }
+    async process(input, options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        return await this.afs.exec(input.path, JSON.parse(input.args), options);
+    }
+}
+exports.AFSExecAgent = AFSExecAgent;

package/lib/cjs/prompt/skills/{afs.d.ts → afs/index.d.ts}

@@ -1,3 +1,3 @@
 import type { AFS } from "@aigne/afs";
-import { type Agent } from "../../agents/agent.js";
+import type { Agent } from "../../../agents/agent.js";
 export declare function getAFSSkills(afs: AFS): Promise<Agent[]>;

package/lib/cjs/prompt/skills/afs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAFSSkills = getAFSSkills;
+const delete_js_1 = require("./delete.js");
+const edit_js_1 = require("./edit.js");
+const exec_js_1 = require("./exec.js");
+const list_js_1 = require("./list.js");
+const read_js_1 = require("./read.js");
+const rename_js_1 = require("./rename.js");
+const search_js_1 = require("./search.js");
+const write_js_1 = require("./write.js");
+async function getAFSSkills(afs) {
+    return [
+        new list_js_1.AFSListAgent({ afs }),
+        new search_js_1.AFSSearchAgent({ afs }),
+        new read_js_1.AFSReadAgent({ afs }),
+        new write_js_1.AFSWriteAgent({ afs }),
+        new edit_js_1.AFSEditAgent({ afs }),
+        new delete_js_1.AFSDeleteAgent({ afs }),
+        new rename_js_1.AFSRenameAgent({ afs }),
+        new exec_js_1.AFSExecAgent({ afs }),
+    ];
+}

package/lib/cjs/prompt/skills/afs/list.d.ts

@@ -0,0 +1,22 @@
+import type { AFSListOptions } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSListInput extends Message {
+    path: string;
+    options?: AFSListOptions;
+}
+export interface AFSListOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    options?: AFSListOptions;
+    message?: string;
+    result: string;
+}
+export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListOutput> {
+    afs: NonNullable<AgentOptions<AFSListInput, AFSListOutput>["afs"]>;
+}
+export declare class AFSListAgent extends Agent<AFSListInput, AFSListOutput> {
+    constructor(options: AFSListAgentOptions);
+    process(input: AFSListInput, _options: AgentInvokeOptions): Promise<AFSListOutput>;
+    private buildTreeView;
+}

package/lib/cjs/prompt/skills/afs/list.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSListAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSListAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_list",
+            description: "Browse directory structure as a tree view. Use when exploring directory contents or understanding file organization.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute directory path to browse"),
+                options: zod_1.z
+                    .object({
+                    maxDepth: zod_1.z.number().optional().describe("Tree depth limit (default: 1)"),
+                })
+                    .optional(),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                options: zod_1.z
+                    .object({
+                    maxDepth: zod_1.z.number().optional(),
+                })
+                    .optional(),
+                message: zod_1.z.string().optional(),
+                result: zod_1.z.string(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const { list, message } = await this.afs.list(input.path, input.options);
+        const result = this.buildTreeView(list);
+        return {
+            status: "success",
+            tool: "afs_list",
+            path: input.path,
+            options: input.options,
+            message,
+            result,
+        };
+    }
+    buildTreeView(entries) {
+        const tree = {};
+        const entryMap = new Map();
+        for (const entry of entries) {
+            entryMap.set(entry.path, entry);
+            const parts = entry.path.split("/").filter(Boolean);
+            let current = tree;
+            for (const part of parts) {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+        const renderTree = (node, prefix = "", currentPath = "") => {
+            let result = "";
+            const keys = Object.keys(node);
+            keys.forEach((key, index) => {
+                const isLast = index === keys.length - 1;
+                const fullPath = currentPath ? `${currentPath}/${key}` : `/${key}`;
+                const entry = entryMap.get(fullPath);
+                // Build metadata suffix
+                const metadataParts = [];
+                // Children count
+                const childrenCount = entry?.metadata?.childrenCount;
+                if (childrenCount !== undefined && childrenCount > 0) {
+                    metadataParts.push(`${childrenCount} items`);
+                }
+                // Executable
+                if (entry?.metadata?.execute) {
+                    metadataParts.push("executable");
+                }
+                const metadataSuffix = metadataParts.length > 0 ? ` [${metadataParts.join(", ")}]` : "";
+                result += `${prefix}${isLast ? "└── " : "├── "}${key}${metadataSuffix}`;
+                result += `\n`;
+                result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`, fullPath);
+            });
+            return result;
+        };
+        return renderTree(tree);
+    }
+}
+exports.AFSListAgent = AFSListAgent;

package/lib/cjs/prompt/skills/afs/read.d.ts

@@ -0,0 +1,21 @@
+import type { AFSEntry } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSReadInput extends Message {
+    path: string;
+    withLineNumbers?: boolean;
+}
+export interface AFSReadOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    withLineNumbers?: boolean;
+    result?: AFSEntry;
+    message?: string;
+}
+export interface AFSReadAgentOptions extends AgentOptions<AFSReadInput, AFSReadOutput> {
+    afs: NonNullable<AgentOptions<AFSReadInput, AFSReadOutput>["afs"]>;
+}
+export declare class AFSReadAgent extends Agent<AFSReadInput, AFSReadOutput> {
+    constructor(options: AFSReadAgentOptions);
+    process(input: AFSReadInput, _options: AgentInvokeOptions): Promise<AFSReadOutput>;
+}

package/lib/cjs/prompt/skills/afs/read.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSReadAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSReadAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_read",
+            description: "Read complete file contents. Use when you need to review, analyze, or understand file content before making changes.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to read"),
+                withLineNumbers: zod_1.z
+                    .boolean()
+                    .optional()
+                    .describe("Include line numbers in output (required when planning to edit the file)"),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                withLineNumbers: zod_1.z.boolean().optional(),
+                result: zod_1.z.custom().optional(),
+                message: zod_1.z.string().optional(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const result = await this.afs.read(input.path);
+        let content = result.result?.content;
+        if (input.withLineNumbers && typeof content === "string") {
+            content = content
+                .split("\n")
+                .map((line, idx) => `${idx + 1}| ${line}`)
+                .join("\n");
+        }
+        return {
+            status: "success",
+            tool: "afs_read",
+            path: input.path,
+            withLineNumbers: input.withLineNumbers,
+            ...result,
+            result: result.result && {
+                ...result.result,
+                content,
+            },
+        };
+    }
+}
+exports.AFSReadAgent = AFSReadAgent;

package/lib/cjs/prompt/skills/afs/rename.d.ts

@@ -0,0 +1,20 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSRenameInput extends Message {
+    oldPath: string;
+    newPath: string;
+    overwrite?: boolean;
+}
+export interface AFSRenameOutput extends Message {
+    status: string;
+    tool: string;
+    oldPath: string;
+    newPath: string;
+    message?: string;
+}
+export interface AFSRenameAgentOptions extends AgentOptions<AFSRenameInput, AFSRenameOutput> {
+    afs: NonNullable<AgentOptions<AFSRenameInput, AFSRenameOutput>["afs"]>;
+}
+export declare class AFSRenameAgent extends Agent<AFSRenameInput, AFSRenameOutput> {
+    constructor(options: AFSRenameAgentOptions);
+    process(input: AFSRenameInput, _options: AgentInvokeOptions): Promise<AFSRenameOutput>;
+}

package/lib/cjs/prompt/skills/afs/rename.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSRenameAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSRenameAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_rename",
+            description: "Rename or move files and directories. Use when reorganizing files, changing names, or moving to different locations.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                oldPath: zod_1.z.string().describe("Absolute current file or directory path"),
+                newPath: zod_1.z.string().describe("Absolute new file or directory path"),
+                overwrite: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Overwrite if destination exists (default: false)"),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                oldPath: zod_1.z.string(),
+                newPath: zod_1.z.string(),
+                message: zod_1.z.string().optional(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const result = await this.afs.rename(input.oldPath, input.newPath, {
+            overwrite: input.overwrite ?? false,
+        });
+        return {
+            status: "success",
+            tool: "afs_rename",
+            oldPath: input.oldPath,
+            newPath: input.newPath,
+            ...result,
+        };
+    }
+}
+exports.AFSRenameAgent = AFSRenameAgent;

package/lib/cjs/prompt/skills/afs/search.d.ts

@@ -0,0 +1,23 @@
+import type { AFSEntry, AFSSearchOptions } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSSearchInput extends Message {
+    path: string;
+    query: string;
+    options?: AFSSearchOptions;
+}
+export interface AFSSearchOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    query: string;
+    options?: AFSSearchOptions;
+    list: AFSEntry[];
+    message?: string;
+}
+export interface AFSSearchAgentOptions extends AgentOptions<AFSSearchInput, AFSSearchOutput> {
+    afs: NonNullable<AgentOptions<AFSSearchInput, AFSSearchOutput>["afs"]>;
+}
+export declare class AFSSearchAgent extends Agent<AFSSearchInput, AFSSearchOutput> {
+    constructor(options: AFSSearchAgentOptions);
+    process(input: AFSSearchInput, _options: AgentInvokeOptions): Promise<AFSSearchOutput>;
+}

package/lib/cjs/prompt/skills/afs/search.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSSearchAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSSearchAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_search",
+            description: "Search file contents by keywords. Use when finding files containing specific text or code patterns.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute directory path to search in"),
+                query: zod_1.z.string().describe("Search keywords or patterns"),
+                options: zod_1.z
+                    .object({
+                    limit: zod_1.z.number().optional().describe("Max results to return"),
+                    caseSensitive: zod_1.z
+                        .boolean()
+                        .optional()
+                        .describe("Case-sensitive search (default: false)"),
+                })
+                    .optional(),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                query: zod_1.z.string(),
+                options: zod_1.z
+                    .object({
+                    limit: zod_1.z.number().optional(),
+                    caseSensitive: zod_1.z.boolean().optional(),
+                })
+                    .optional(),
+                list: zod_1.z.array(zod_1.z.custom()),
+                message: zod_1.z.string().optional(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const result = await this.afs.search(input.path, input.query, input.options);
+        return {
+            status: "success",
+            tool: "afs_search",
+            path: input.path,
+            query: input.query,
+            options: input.options,
+            ...result,
+        };
+    }
+}
+exports.AFSSearchAgent = AFSSearchAgent;

package/lib/cjs/prompt/skills/afs/write.d.ts

@@ -0,0 +1,19 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSWriteInput extends Message {
+    path: string;
+    content: string;
+    append?: boolean;
+}
+export interface AFSWriteOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    message?: string;
+}
+export interface AFSWriteAgentOptions extends AgentOptions<AFSWriteInput, AFSWriteOutput> {
+    afs: NonNullable<AgentOptions<AFSWriteInput, AFSWriteOutput>["afs"]>;
+}
+export declare class AFSWriteAgent extends Agent<AFSWriteInput, AFSWriteOutput> {
+    constructor(options: AFSWriteAgentOptions);
+    process(input: AFSWriteInput, _options: AgentInvokeOptions): Promise<AFSWriteOutput>;
+}

package/lib/cjs/prompt/skills/afs/write.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSWriteAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSWriteAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_write",
+            description: "Create new file or append content to existing file. Use when creating files, rewriting entire files, or appending to files.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to write"),
+                content: zod_1.z.string().describe("Complete file content or content to append"),
+                append: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Append mode: add content to end of file (default: false, overwrites file)"),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                message: zod_1.z.string().optional(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const result = await this.afs.write(input.path, {
+            content: input.content,
+        }, {
+            append: input.append ?? false,
+        });
+        return {
+            status: "success",
+            tool: "afs_write",
+            path: input.path,
+            ...result,
+        };
+    }
+}
+exports.AFSWriteAgent = AFSWriteAgent;

package/lib/cjs/utils/event-stream.js

@@ -5,6 +5,7 @@ const eventsource_parser_1 = require("eventsource-parser");
 const immer_1 = require("immer");
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
+(0, immer_1.setAutoFreeze)(false);
 class EventStreamParser extends TransformStream {
     constructor() {
         let parser;

package/lib/dts/agents/agent.d.ts

@@ -938,4 +938,4 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
  * @param context Execution context
  * @returns Processing result, can be synchronous or asynchronous
  */
-export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any, A extends FunctionAgent<I, O> = FunctionAgent<I, O>> = (this: A, input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;

package/lib/dts/aigne/aigne.d.ts

@@ -113,6 +113,10 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * @hidden
      */
     readonly messageQueue: MessageQueue;
+    /**
+     * Collection of all context IDs created by this AIGNE instance.
+     */
+    readonly contextIds: Set<string>;
     /**
      * Collection of skill agents available to this AIGNE instance.
      * Provides indexed access by skill name.
@@ -324,7 +328,8 @@ export declare class AIGNE<U extends UserContext = UserContext> {
     [Symbol.asyncDispose](): Promise<void>;
     /**
      * Initializes handlers for process exit events to ensure clean shutdown.
-     * This registers handlers for SIGINT and exit events to properly terminate all agents.
+     * This registers handlers for SIGINT/SIGTERM to properly terminate all agents.
+     * Note: 'exit' event cannot run async code, so we handle cleanup in signal handlers.
      */
     private initProcessExitHandler;
 }

package/lib/dts/aigne/context.d.ts

@@ -149,7 +149,6 @@ export interface Context<U extends UserContext = UserContext> extends TypedEvent
  * @hidden
  */
 export declare class AIGNEContext implements Context {
-    static exitCount: number;
     constructor(parent?: ConstructorParameters<typeof AIGNEContextShared>[0], { reset }?: {
         reset?: boolean;
     });
@@ -183,7 +182,6 @@ export declare class AIGNEContext implements Context {
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
     emit<K extends keyof ContextEmitEventMap>(eventName: K, ...args: Args<K, ContextEmitEventMap>): boolean;
-    initProcessExitHandler(): void;
     private trace;
     on<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
     once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
@@ -194,6 +192,7 @@ declare class AIGNEContextShared {
     constructor(parent?: (Pick<Context, "model" | "imageModel" | "agents" | "skills" | "limits" | "observer" | "metadata"> & {
         messageQueue?: MessageQueue;
         events?: Emitter<any>;
+        contextIds?: Set<string>;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: Emitter<any>;
@@ -205,6 +204,7 @@ declare class AIGNEContextShared {
     get metadata(): AIGNEMetadata | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
+    contextIds: Set<string>;
     userContext: Context["userContext"];
     memories: Context["memories"];
     hooks: AgentHooks[];

package/lib/dts/loader/agent-js.d.ts

@@ -1 +1,2 @@
-export declare function loadAgentFromJsFile(path: string): Promise<import("../index.js").Agent<any, any> | import("./agent-yaml.js").AgentSchema>;
+import type { LoadOptions } from "./index.js";
+export declare function loadAgentFromJsFile(path: string, options: LoadOptions): Promise<import("../index.js").Agent<any, any> | import("./agent-yaml.js").AgentSchema>;