@aigne/core 1.16.0 → 1.18.0

package/lib/esm/aigne/context.js

@@ -1,8 +1,8 @@
-import EventEmitter from "node:events";
+import { Emitter } from "strict-event-emitter";
 import { v7 } from "uuid";
 import { z } from "zod";
 import { Agent, } from "../agents/agent.js";
-import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
+import { isTransferAgentOutput, transferAgentOutputKey, } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
@@ -13,13 +13,13 @@ import { newEmptyContextUsage } from "./usage.js";
  * @hidden
  */
 export class AIGNEContext {
-    constructor(parent) {
+    constructor(...[parent, ...args]) {
         if (parent instanceof AIGNEContext) {
             this.parentId = parent.id;
             this.internal = parent.internal;
         }
         else {
-            this.internal = new AIGNEContextInternal(parent);
+            this.internal = new AIGNEContextShared(parent, ...args);
         }
     }
     parentId;
@@ -40,9 +40,15 @@ export class AIGNEContext {
     get usage() {
         return this.internal.usage;
     }
+    get userContext() {
+        return this.internal.userContext;
+    }
+    set userContext(userContext) {
+        this.internal.userContext = userContext;
+    }
     newContext({ reset } = {}) {
         if (reset)
-            return new AIGNEContext(this.internal);
+            return new AIGNEContext(this, { userContext: {} });
         return new AIGNEContext(this);
     }
     invoke = ((agent, message, options) => {
@@ -51,6 +57,8 @@ export class AIGNEContext {
             message,
             options,
         });
+        if (options?.userContext)
+            Object.assign(this.userContext, options.userContext);
         if (isNil(message)) {
             return UserAgent.from({
                 context: this,
@@ -90,7 +98,9 @@ export class AIGNEContext {
             return stream;
         });
     });
-    publish = ((topic, payload) => {
+    publish = ((topic, payload, options) => {
+        if (options?.userContext)
+            Object.assign(this.userContext, options.userContext);
         return this.internal.messageQueue.publish(topic, {
             ...toMessagePayload(payload),
             context: this,
@@ -125,14 +135,16 @@ export class AIGNEContext {
         return this;
     }
 }
-class AIGNEContextInternal {
+class AIGNEContextShared {
     parent;
-    constructor(parent) {
+    constructor(parent, overrides) {
         this.parent = parent;
         this.messageQueue = this.parent?.messageQueue ?? new MessageQueue();
+        this.userContext = overrides?.userContext ?? {};
     }
     messageQueue;
-    events = new EventEmitter();
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    events = new Emitter();
     get model() {
         return this.parent?.model;
     }
@@ -143,6 +155,7 @@ class AIGNEContextInternal {
         return this.parent?.limits;
     }
     usage = newEmptyContextUsage();
+    userContext;
     abortController = new AbortController();
     timer;
     initTimeout() {
@@ -169,12 +182,13 @@ class AIGNEContextInternal {
             const result = {};
             if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
                 options.sourceAgent.hooks.onHandoff?.({
+                    context,
                     source: options.sourceAgent,
                     target: activeAgent,
                     input,
                 });
             }
-            const stream = await activeAgent.invoke(input, context, { streaming: true });
+            const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
             for await (const value of stream) {
                 if (value.delta.text) {
                     yield { delta: { text: value.delta.text } };

package/lib/esm/aigne/message-queue.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "node:events";
+import { Emitter, type EventMap } from "strict-event-emitter";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
 /**
@@ -30,11 +30,14 @@ export type MessageQueueListener = (message: MessagePayload) => void;
  * @hidden
  */
 export type Unsubscribe = () => void;
+interface MessageQueueEventMap extends EventMap {
+    [key: string]: any[];
+}
 /**
  * @hidden
  */
 export declare class MessageQueue {
-    events: EventEmitter<[never]>;
+    events: Emitter<MessageQueueEventMap>;
     publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
     subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
@@ -42,3 +45,4 @@ export declare class MessageQueue {
     subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
 }
+export {};

package/lib/esm/aigne/message-queue.js

@@ -1,4 +1,4 @@
-import { EventEmitter } from "node:events";
+import { Emitter } from "strict-event-emitter";
 import { z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { checkArguments, isNil, orArrayToArray } from "../utils/type-utils.js";
@@ -36,7 +36,7 @@ export function toMessagePayload(payload, options) {
  * @hidden
  */
 export class MessageQueue {
-    events = new EventEmitter();
+    events = new Emitter();
     publish(topic, payload) {
         checkArguments("MessageQueue.publish", publishArgsSchema, {
             topic,

package/lib/esm/index.d.ts

@@ -1,10 +1,12 @@
 export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
+export * from "./agents/chat-model.js";
+export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./agents/chat-model.js";
+export * from "./memory/index.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/esm/index.js

@@ -1,10 +1,12 @@
 export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
+export * from "./agents/chat-model.js";
+export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./agents/chat-model.js";
+export * from "./memory/index.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

@@ -1,8 +1,8 @@
 import { type ZodObject, type ZodType, z } from "zod";
 import type { Message } from "../agents/agent.js";
 export declare function loadAgentFromJsFile(path: string): Promise<{
-    name: string;
     process: (args_0: Message) => Message;
+    name: string;
     description?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;

package/lib/esm/loader/agent-yaml.d.ts

@@ -5,10 +5,11 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     name: string;
     description?: string | undefined;
     skills?: string[] | undefined;
+    instructions?: string | undefined;
     memory?: true | {
+        provider: string;
         subscribeTopic?: string[] | undefined;
     } | undefined;
-    instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
@@ -24,6 +25,6 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
 } | {
     type: "mcp";
     url?: string | undefined;
-    command?: string | undefined;
     args?: string[] | undefined;
+    command?: string | undefined;
 }>;

package/lib/esm/loader/agent-yaml.js

@@ -1,9 +1,9 @@
-import { readFile } from "node:fs/promises";
 import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
 import { parse } from "yaml";
 import { z } from "zod";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { customCamelize } from "../utils/camelize.js";
+import { nodejs } from "../utils/nodejs.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { inputOutputSchema } from "./schema.js";
 const agentFileSchema = z.discriminatedUnion("type", [
@@ -40,6 +40,7 @@ const agentFileSchema = z.discriminatedUnion("type", [
             .union([
             z.boolean(),
             z.object({
+                provider: z.string(),
                 subscribe_topic: z
                     .array(z.string())
                     .nullish()
@@ -66,7 +67,7 @@ const agentFileSchema = z.discriminatedUnion("type", [
     }),
 ]);
 export async function loadAgentFromYamlFile(path) {
-    const raw = await tryOrThrow(() => readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
     const agent = tryOrThrow(() => customCamelize(agentFileSchema.parse({
         ...json,

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

@@ -2,6 +2,7 @@ import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
 import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
+import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
 export interface LoadOptions {
     models: {
         new (parameters: {
@@ -9,6 +10,9 @@ export interface LoadOptions {
             modelOptions?: ChatModelOptions;
         }): ChatModel;
     }[];
+    memories?: {
+        new (parameters?: MemoryAgentOptions): MemoryAgent;
+    }[];
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<{
@@ -26,7 +30,7 @@ export declare function load(options: LoadOptions): Promise<{
         presence_penalty?: number | null | undefined;
     } | null | undefined;
 }>;
-export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadAgent(path: string, options?: LoadOptions): Promise<Agent>;
 export declare function loadModel(models: LoadOptions["models"], model?: Camelize<z.infer<typeof aigneFileSchema>["chat_model"]>, modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/lib/esm/loader/index.js

@@ -1,21 +1,19 @@
-import { readFile, stat } from "node:fs/promises";
-import { dirname, extname, join } from "node:path";
 import { parse } from "yaml";
 import { z } from "zod";
 import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
+import { nodejs } from "../utils/nodejs.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 export async function load(options) {
-    const { path } = options;
-    const aigneFilePath = await getAIGNEFilePath(path);
-    const rootDir = dirname(aigneFilePath);
+    const aigneFilePath = await getAIGNEFilePath(options.path);
+    const rootDir = nodejs.path.dirname(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
-    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(join(rootDir, filename))));
-    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(nodejs.path.join(rootDir, filename))));
+    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(nodejs.path.join(rootDir, filename))));
     return {
         ...aigne,
         model: await loadModel(options.models, aigne.chat_model),
@@ -23,18 +21,21 @@ export async function load(options) {
         skills,
     };
 }
-export async function loadAgent(path) {
-    if (extname(path) === ".js") {
+export async function loadAgent(path, options) {
+    if (nodejs.path.extname(path) === ".js") {
         const agent = await loadAgentFromJsFile(path);
         return FunctionAgent.from(agent);
     }
-    if (extname(path) === ".yaml" || extname(path) === ".yml") {
+    if (nodejs.path.extname(path) === ".yaml" || nodejs.path.extname(path) === ".yml") {
         const agent = await loadAgentFromYamlFile(path);
         if (agent.type === "ai") {
             return AIAgent.from({
                 ...agent,
+                memory: !options?.memories?.length || !agent.memory
+                    ? undefined
+                    : await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {}),
                 skills: agent.skills &&
-                    (await Promise.all(agent.skills.map((filename) => loadAgent(join(dirname(path), filename))))),
+                    (await Promise.all(agent.skills.map((filename) => loadAgent(nodejs.path.join(nodejs.path.dirname(path), filename))))),
             });
         }
         if (agent.type === "mcp") {
@@ -54,7 +55,15 @@ export async function loadAgent(path) {
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-const { MODEL_PROVIDER, MODEL_NAME } = process.env;
+async function loadMemory(memories, provider, options) {
+    const M = !provider
+        ? memories[0]
+        : memories.find((i) => i.name.toLowerCase().includes(provider.toLowerCase()));
+    if (!M)
+        throw new Error(`Unsupported memory: ${provider}`);
+    return new M(options);
+}
+const { MODEL_PROVIDER, MODEL_NAME } = nodejs.env;
 const DEFAULT_MODEL_PROVIDER = "openai";
 export async function loadModel(models, model, modelOptions) {
     const params = {
@@ -92,17 +101,17 @@ const aigneFileSchema = z.object({
     skills: z.array(z.string()).nullish(),
 });
 export async function loadAIGNEFile(path) {
-    const raw = await tryOrThrow(() => readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
     const agent = tryOrThrow(() => aigneFileSchema.parse({ ...json, skills: json.skills ?? json.tools }), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
     return agent;
 }
 async function getAIGNEFilePath(path) {
-    const s = await stat(path);
+    const s = await nodejs.fs.stat(path);
     if (s.isDirectory()) {
         for (const file of AIGNE_FILE_NAME) {
-            const filePath = join(path, file);
-            if ((await stat(filePath)).isFile())
+            const filePath = nodejs.path.join(path, file);
+            if ((await nodejs.fs.stat(filePath)).isFile())
                 return filePath;
         }
     }

package/lib/esm/memory/memory.d.ts

@@ -1,10 +1,11 @@
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../agents/agent.js";
 import type { Context } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryRecorder, MemoryRecorderInput, MemoryRecorderOutput } from "./recorder.js";
 import type { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOutput } from "./retriever.js";
 export interface Memory {
     id: string;
+    sessionId?: string | null;
     content: unknown;
     createdAt: string;
 }
@@ -62,7 +63,7 @@ export declare class MemoryAgent extends Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    process(_input: Message, _context: Context): Promise<Message>;
+    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
     /**
      * Retrieves memories based on the provided input criteria.
      *

package/lib/esm/memory/memory.js

@@ -1,6 +1,6 @@
 import { v7 } from "uuid";
 import { z } from "zod";
-import { Agent } from "../agents/agent.js";
+import { Agent, } from "../agents/agent.js";
 import { checkArguments, remove } from "../utils/type-utils.js";
 export const newMemoryId = () => v7();
 /**
@@ -81,7 +81,7 @@ export class MemoryAgent extends Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    async process(_input, _context) {
+    async process(_input, _options) {
         throw new Error("Method not implemented.");
     }
     /**

package/lib/esm/memory/retriever.d.ts

@@ -39,11 +39,11 @@ export declare const memoryRetrieverInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     search: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    search?: string | undefined;
     limit?: number | undefined;
-}, {
     search?: string | undefined;
+}, {
     limit?: number | undefined;
+    search?: string | undefined;
 }>;
 /**
  * @hidden

package/lib/esm/prompt/prompt-builder.d.ts

@@ -1,19 +1,21 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
-import type { Context } from "../aigne/context.js";
-import type { MemoryAgent } from "../memory/memory.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<I extends Message>(message: string | I): I;
+export declare function createMessage<V extends Message>(message: string, variables?: V): {
+    [MESSAGE_KEY]: string;
+} & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
+    [MESSAGE_KEY]: string;
+} | I) & typeof variables;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuildOptions {
-    memory?: MemoryAgent | MemoryAgent[];
-    context: Context;
+export interface PromptBuildOptions extends AgentInvokeOptions {
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;

package/lib/esm/prompt/prompt-builder.js

@@ -1,16 +1,16 @@
-import { readFile } from "node:fs/promises";
 import { stringify } from "yaml";
 import { ZodObject } from "zod";
 import { Agent } from "../agents/agent.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { isNil, orArrayToArray, unique } from "../utils/type-utils.js";
+import { nodejs } from "../utils/nodejs.js";
+import { isNil, unique } from "../utils/type-utils.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export const MESSAGE_KEY = "$message";
-export function createMessage(message) {
-    return typeof message === "string"
-        ? { [MESSAGE_KEY]: message }
-        : { ...message };
+export function createMessage(message, variables) {
+    return (typeof message === "string"
+        ? { [MESSAGE_KEY]: message, ...variables }
+        : { ...message, ...variables });
 }
 export function getMessage(input) {
     const userInputMessage = input[MESSAGE_KEY];
@@ -31,7 +31,7 @@ export class PromptBuilder {
         throw new Error(`Invalid instructions ${instructions}`);
     }
     static async fromFile(path) {
-        const text = await readFile(path, "utf-8");
+        const text = await nodejs.fs.readFile(path, "utf-8");
         return PromptBuilder.from(text);
     }
     static fromMCPPromptResult(result) {
@@ -78,11 +78,15 @@ export class PromptBuilder {
         const messages = (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
-        for (const memory of orArrayToArray(options.memory ?? options.agent?.memories)) {
-            const memories = (await memory.retrieve({ search: input && getMessage(input) }, options.context))?.memories;
-            if (memories?.length)
-                messages.push(...this.convertMemoriesToMessages(memories, options));
+        const memories = [];
+        if (options.agent) {
+            memories.push(...(await options.agent.retrieveMemories({ search: options.input }, options)));
         }
+        if (options.memories?.length) {
+            memories.push(...options.memories);
+        }
+        if (memories.length)
+            messages.push(...this.convertMemoriesToMessages(memories, options));
         const content = input && getMessage(input);
         // add user input if it's not the same as the last message
         if (content && messages.at(-1)?.content !== content) {

package/lib/esm/prompt/template.js

@@ -1,7 +1,5 @@
-import { inspect } from "node:util";
 import Mustache from "mustache";
 import { z } from "zod";
-import { tryOrThrow } from "../utils/type-utils.js";
 export class PromptTemplate {
     template;
     static from(template) {
@@ -80,7 +78,7 @@ export class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content, toolCallId, name) {
         super("tool", typeof content === "string"
             ? content
-            : tryOrThrow(() => JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), `Failed to stringify tool content. toolCallId: ${toolCallId}, content: ${inspect(content)}`), name);
+            : JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), name);
         this.toolCallId = toolCallId;
     }
     format(variables) {

package/lib/esm/utils/logger.js

@@ -1,5 +1,5 @@
-import { isatty } from "node:tty";
 import debug from "debug";
+import { nodejs } from "./nodejs.js";
 export var LogLevel;
 (function (LogLevel) {
     LogLevel["ERROR"] = "error";
@@ -17,13 +17,13 @@ export class Logger {
         this.errorLogger = debug(`${options.ns}:error`);
         for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
             // @ts-ignore
-            logger.useColors = isatty(process.stdout.fd);
+            logger.useColors = nodejs.isStdoutATTY;
             logger.enabled = true;
             logger.log = (...args) => this.logMessage(...args);
         }
         this.errorLogger.log = (...args) => this.logError(...args);
         // @ts-ignore
-        this.errorLogger.useColors = isatty(process.stderr.fd);
+        this.errorLogger.useColors = nodejs.isStderrATTY;
         this.errorLogger.enabled = true;
     }
     level;

package/lib/esm/utils/nodejs.d.ts

@@ -0,0 +1,8 @@
+export declare const nodejs: {
+    customInspect: any;
+    isStdoutATTY: boolean;
+    isStderrATTY: boolean;
+    env: NodeJS.ProcessEnv;
+    readonly fs: typeof import("node:fs/promises");
+    readonly path: typeof import("node:path");
+};

package/lib/esm/utils/nodejs.js

@@ -0,0 +1,21 @@
+export const nodejs = {
+    customInspect: isNodejsEnvironment() ? require("node:util").inspect.custom : Symbol("inspect"),
+    isStdoutATTY: isNodejsEnvironment() && process.stdout?.isTTY,
+    isStderrATTY: isNodejsEnvironment() && process.stderr?.isTTY,
+    env: isNodejsEnvironment() ? process.env : {},
+    get fs() {
+        ensureNodejsEnvironment();
+        return require("node:fs/promises");
+    },
+    get path() {
+        ensureNodejsEnvironment();
+        return require("node:path");
+    },
+};
+function isNodejsEnvironment() {
+    return typeof process !== "undefined";
+}
+function ensureNodejsEnvironment() {
+    if (!isNodejsEnvironment())
+        throw new Error("This code must run in a Node.js environment.");
+}

package/lib/esm/utils/type-utils.d.ts

@@ -1,4 +1,4 @@
-import { type ZodType } from "zod";
+import { type ZodType, z } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
@@ -20,6 +20,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
+export declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<T>;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.16.0",
+  "version": "1.18.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -71,16 +71,17 @@
     "eventsource-parser": "^3.0.1",
     "fast-deep-equal": "^3.1.3",
     "immer": "^10.1.1",
-    "inquirer": "^12.6.0",
     "mustache": "^4.2.0",
     "nanoid": "^5.1.5",
     "p-retry": "^6.2.1",
     "raw-body": "^3.0.0",
+    "strict-event-emitter": "^0.5.1",
     "ufo": "^1.6.1",
     "uuid": "^11.1.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.4",
-    "zod-to-json-schema": "^3.24.5"
+    "zod-to-json-schema": "^3.24.5",
+    "@aigne/platform-helpers": "^0.1.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.12",

package/lib/cjs/memory/default-memory.d.ts

@@ -1,16 +0,0 @@
-import { type Memory, MemoryAgent, type MemoryAgentOptions } from "./memory.js";
-export declare const DEFAULT_MAX_MEMORY_COUNT = 10;
-export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
-}
-export declare class DefaultMemory extends MemoryAgent {
-    constructor(options?: DefaultMemoryOptions);
-    storage: Memory[];
-    search(options?: {
-        limit?: number;
-    }): Promise<{
-        result: Memory[];
-    }>;
-    create(memory: Pick<Memory, "content">): Promise<{
-        result: Memory;
-    }>;
-}