@aigne/core 1.10.0 → 1.12.0

package/lib/cjs/{execution-engine → aigne}/context.d.ts

@@ -1,12 +1,11 @@
 import EventEmitter from "node:events";
-import { Agent, type AgentCallOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
 import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
 import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import { type ContextLimits, type ContextUsage } from "./usage.js";
-export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
 export interface AgentEvent {
     parentContextId?: string;
     contextId: string;
@@ -27,53 +26,53 @@ export interface ContextEventMap {
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
-export interface CallOptions extends AgentCallOptions {
+export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
 export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
-    tools?: Agent[];
+    skills?: Agent[];
     usage: ContextUsage;
     limits?: ContextLimits;
     status?: "normal" | "timeout";
     /**
-     * Create a user agent to consistently call an agent
-     * @param agent Agent to call
+     * Create a user agent to consistently invoke an agent
+     * @param agent Agent to invoke
      * @returns User agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
     /**
-     * Call an agent with a message and return the output and the active agent
-     * @param agent Agent to call
+     * Invoke an agent with a message and return the output and the active agent
+     * @param agent Agent to invoke
      * @param message Message to pass to the agent
      * @param options.returnActiveAgent return the active agent
      * @param options.streaming return a stream of the output
      * @returns the output of the agent and the final active agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming?: false;
-    }): Promise<[O, Runnable]>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming: true;
-    }): Promise<[AgentResponseStream<O>, Promise<Runnable>]>;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
     /**
-     * Call an agent with a message
-     * @param agent Agent to call
+     * Invoke an agent with a message
+     * @param agent Agent to invoke
      * @param message Message to pass to the agent
      * @returns the output of the agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Runnable]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I | string, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
     /**
-     * Publish a message to a topic, the engine will call the listeners of the topic
+     * Publish a message to a topic, the aigne will invoke the listeners of the topic
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
@@ -96,21 +95,21 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
     }): Context;
 }
 export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
-export declare class ExecutionContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof ExecutionContextInternal>[0]);
+export declare class AIGNEContext implements Context {
+    constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
     parentId?: string;
     id: string;
-    readonly internal: ExecutionContextInternal;
+    readonly internal: AIGNEContextInternal;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     get status(): "normal" | "timeout";
     get usage(): ContextUsage;
     newContext({ reset }?: {
         reset?: boolean;
-    }): ExecutionContext;
-    call: Context["call"];
-    private onCallSuccess;
+    }): AIGNEContext;
+    invoke: Context["invoke"];
+    private onInvokeSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
@@ -119,24 +118,24 @@ export declare class ExecutionContext implements Context {
     once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
     off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-declare class ExecutionContextInternal {
+declare class AIGNEContextInternal {
     private readonly parent?;
-    constructor(parent?: (Pick<Context, "model" | "tools" | "limits"> & {
+    constructor(parent?: (Pick<Context, "model" | "skills" | "limits"> & {
         messageQueue?: MessageQueue;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
     private abortController;
     private timer?;
     private initTimeout;
     get status(): "normal" | "timeout";
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): AgentProcessAsyncGenerator<O & {
-        __activeAgent__: Runnable;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, input: I, context: Context, options?: InvokeOptions): AgentProcessAsyncGenerator<O & {
+        __activeAgent__: Agent;
     }>;
-    private callAgent;
+    private invokeAgent;
 }
 export {};

package/lib/cjs/{execution-engine → aigne}/context.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionContext = void 0;
+exports.AIGNEContext = void 0;
 exports.createPublishMessage = createPublishMessage;
 const node_events_1 = __importDefault(require("node:events"));
 const uuid_1 = require("uuid");
@@ -23,14 +23,14 @@ function createPublishMessage(message, from) {
         message: (0, prompt_builder_js_1.createMessage)(message),
     };
 }
-class ExecutionContext {
+class AIGNEContext {
     constructor(parent) {
-        if (parent instanceof ExecutionContext) {
+        if (parent instanceof AIGNEContext) {
             this.parentId = parent.id;
             this.internal = parent.internal;
         }
         else {
-            this.internal = new ExecutionContextInternal(parent);
+            this.internal = new AIGNEContextInternal(parent);
         }
     }
     parentId;
@@ -39,8 +39,8 @@ class ExecutionContext {
     get model() {
         return this.internal.model;
     }
-    get tools() {
-        return this.internal.tools;
+    get skills() {
+        return this.internal.skills;
     }
     get limits() {
         return this.internal.limits;
@@ -53,11 +53,11 @@ class ExecutionContext {
     }
     newContext({ reset } = {}) {
         if (reset)
-            return new ExecutionContext(this.internal);
-        return new ExecutionContext(this);
+            return new AIGNEContext(this.internal);
+        return new AIGNEContext(this);
     }
-    call = ((agent, message, options) => {
-        (0, type_utils_js_1.checkArguments)("ExecutionContext.call", executionContextCallArgsSchema, {
+    invoke = ((agent, message, options) => {
+        (0, type_utils_js_1.checkArguments)("AIGNEContext.invoke", aigneContextInvokeArgsSchema, {
             agent,
             message,
             options,
@@ -70,10 +70,10 @@ class ExecutionContext {
         }
         const newContext = this.newContext();
         const msg = (0, prompt_builder_js_1.createMessage)(message);
-        return Promise.resolve(newContext.internal.call(agent, msg, newContext, options)).then(async (response) => {
+        return Promise.resolve(newContext.internal.invoke(agent, msg, newContext, options)).then(async (response) => {
             if (!options?.streaming) {
                 const { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 if (options?.returnActiveAgent) {
                     return [output, activeAgent];
                 }
@@ -81,7 +81,7 @@ class ExecutionContext {
             }
             const activeAgentPromise = Promise.withResolvers();
             const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent, ...output }) => {
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 activeAgentPromise.resolve(activeAgent);
             }, {
                 processChunk(chunk) {
@@ -103,7 +103,7 @@ class ExecutionContext {
             return stream;
         });
     });
-    async onCallSuccess(activeAgent, output, context) {
+    async onInvokeSuccess(activeAgent, output, context) {
         if (activeAgent instanceof agent_js_1.Agent) {
             const publishTopics = typeof activeAgent.publishTopic === "function"
                 ? await activeAgent.publishTopic(output)
@@ -145,8 +145,8 @@ class ExecutionContext {
         return this;
     }
 }
-exports.ExecutionContext = ExecutionContext;
-class ExecutionContextInternal {
+exports.AIGNEContext = AIGNEContext;
+class AIGNEContextInternal {
     parent;
     constructor(parent) {
         this.parent = parent;
@@ -157,8 +157,8 @@ class ExecutionContextInternal {
     get model() {
         return this.parent?.model;
     }
-    get tools() {
-        return this.parent?.tools;
+    get skills() {
+        return this.parent?.skills;
     }
     get limits() {
         return this.parent?.limits;
@@ -179,33 +179,23 @@ class ExecutionContextInternal {
     get status() {
         return this.abortController.signal.aborted ? "timeout" : "normal";
     }
-    call(agent, input, context, options) {
+    invoke(agent, input, context, options) {
         this.initTimeout();
-        return withAbortSignal(this.abortController.signal, new Error("ExecutionContext is timeout"), () => this.callAgent(agent, input, context, options));
+        return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
     }
-    async *callAgent(agent, input, context, options) {
+    async *invokeAgent(agent, input, context, options) {
         let activeAgent = agent;
         let output;
         for (;;) {
-            let result;
-            if (typeof activeAgent === "function") {
-                result = await activeAgent(input, context);
-            }
-            else {
-                result = {};
-                const stream = await activeAgent.call(input, context, { streaming: true });
-                for await (const value of (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream)) {
-                    if (value.delta.text) {
-                        yield { delta: { text: value.delta.text } };
-                    }
-                    if (value.delta.json) {
-                        Object.assign(result, value.delta.json);
-                    }
+            const result = {};
+            const stream = await activeAgent.invoke(input, context, { streaming: true });
+            for await (const value of (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream)) {
+                if (value.delta.text) {
+                    yield { delta: { text: value.delta.text } };
+                }
+                if (value.delta.json) {
+                    Object.assign(result, value.delta.json);
                 }
-            }
-            if (result instanceof agent_js_1.Agent) {
-                activeAgent = result;
-                continue;
             }
             if (!options?.disableTransfer) {
                 const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
@@ -250,7 +240,7 @@ async function* withAbortSignal(signal, error, fn) {
         signal.removeEventListener("abort", listener);
     }
 }
-const executionContextCallArgsSchema = zod_1.z.object({
+const aigneContextInvokeArgsSchema = zod_1.z.object({
     agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),
     message: zod_1.z.union([zod_1.z.record(zod_1.z.unknown()), zod_1.z.string()]).optional(),
     options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),

package/lib/cjs/aigne/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./context.js";
+export * from "./aigne.js";
+export * from "./message-queue.js";
+export * from "./usage.js";

package/lib/cjs/{execution-engine → aigne}/index.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./context.js"), exports);
-__exportStar(require("./execution-engine.js"), exports);
+__exportStar(require("./aigne.js"), exports);
 __exportStar(require("./message-queue.js"), exports);
-__exportStar(require("./utils.js"), exports);
+__exportStar(require("./usage.js"), exports);

package/lib/cjs/{execution-engine → aigne}/usage.d.ts

@@ -6,6 +6,6 @@ export interface ContextUsage {
 export declare function newEmptyContextUsage(): ContextUsage;
 export interface ContextLimits {
     maxTokens?: number;
-    maxAgentCalls?: number;
+    maxAgentInvokes?: number;
     timeout?: number;
 }

package/lib/cjs/client/client.d.ts

@@ -0,0 +1,19 @@
+import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
+export interface AIGNEClientOptions {
+    url: string;
+}
+export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
+    fetchOptions?: Partial<RequestInit>;
+}
+export declare class AIGNEClient {
+    options: AIGNEClientOptions;
+    constructor(options: AIGNEClientOptions);
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
+    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+}

package/lib/cjs/client/client.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNEClient = void 0;
+const event_stream_js_1 = require("../utils/event-stream.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+class AIGNEClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async invoke(agent, input, options) {
+        const response = await this.fetch(this.options.url, {
+            ...options?.fetchOptions,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.fetchOptions?.headers,
+            },
+            body: JSON.stringify({ agent, input, options }),
+        });
+        if (!options?.streaming) {
+            return await response.json();
+        }
+        const stream = response.body;
+        if (!stream)
+            throw new Error("Response body is not a stream");
+        return stream
+            .pipeThrough(new TextDecoderStream())
+            .pipeThrough(new event_stream_js_1.EventStreamParser())
+            .pipeThrough(new event_stream_js_1.AgentResponseStreamParser());
+    }
+    async fetch(...args) {
+        const result = await globalThis.fetch(...args);
+        if (!result.ok) {
+            let message;
+            try {
+                const text = await result.text();
+                const json = (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(text));
+                message = json?.error?.message || text;
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`Failed to fetch url ${args[0]} with status ${result.status}: ${message}`);
+        }
+        return result;
+    }
+}
+exports.AIGNEClient = AIGNEClient;

package/lib/cjs/index.d.ts

@@ -2,9 +2,10 @@ export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/memory.js";
+export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
-export * from "./execution-engine/index.js";
+export * from "./aigne/index.js";
 export * from "./models/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/cjs/index.js

@@ -18,9 +18,10 @@ __exportStar(require("./agents/agent.js"), exports);
 __exportStar(require("./agents/ai-agent.js"), exports);
 __exportStar(require("./agents/mcp-agent.js"), exports);
 __exportStar(require("./agents/memory.js"), exports);
+__exportStar(require("./agents/team-agent.js"), exports);
 __exportStar(require("./agents/types.js"), exports);
 __exportStar(require("./agents/user-agent.js"), exports);
-__exportStar(require("./execution-engine/index.js"), exports);
+__exportStar(require("./aigne/index.js"), exports);
 __exportStar(require("./models/chat-model.js"), exports);
 __exportStar(require("./prompt/prompt-builder.js"), exports);
 __exportStar(require("./prompt/template.js"), exports);

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

@@ -4,12 +4,12 @@ export declare function loadAgentFromJsFile(path: string): Promise<{
     name: string;
     fn: (args_0: Message) => Message;
     description?: string | undefined;
-    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;

package/lib/cjs/loader/agent-js.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAgentFromJsFile = loadAgentFromJsFile;
 const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
 const zod_1 = require("zod");
+const camelize_js_1 = require("../utils/camelize.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
 const agentJsFileSchema = zod_1.z.object({
@@ -57,11 +58,9 @@ async function loadAgentFromJsFile(path) {
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return (0, type_utils_js_1.tryOrThrow)(() => agentJsFileSchema.parse({
+    return (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentJsFileSchema.parse({
+        ...agent,
         name: agent.agent_name || agent.name,
-        description: agent.description,
-        input_schema: agent.input_schema,
-        output_schema: agent.output_schema,
         fn: agent,
-    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+    }), { shallowKeys: ["input_schema", "output_schema"] }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
 }

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

@@ -3,20 +3,23 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     type: "ai";
     name: string;
     description?: string | undefined;
-    tools?: string[] | undefined;
+    memory?: true | {
+        subscribeTopic?: string[] | undefined;
+    } | undefined;
+    skills?: string[] | undefined;
     instructions?: string | undefined;
-    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    tool_choice?: "auto" | "none" | "required" | "router" | undefined;
-    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    toolChoice?: "auto" | "none" | "required" | "router" | undefined;
+    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    output_key?: string | undefined;
+    outputKey?: string | undefined;
 } | {
     type: "mcp";
     url?: string | undefined;

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

@@ -5,6 +5,7 @@ const promises_1 = require("node:fs/promises");
 const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
+const camelize_js_1 = require("../utils/camelize.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
 const agentFileSchema = zod_1.z.discriminatedUnion("type", [
@@ -29,7 +30,7 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .string()
             .nullish()
             .transform((v) => v ?? undefined),
-        tools: zod_1.z
+        skills: zod_1.z
             .array(zod_1.z.string())
             .nullish()
             .transform((v) => v ?? undefined),
@@ -37,6 +38,18 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .union([zod_1.z.literal("auto"), zod_1.z.literal("none"), zod_1.z.literal("required"), zod_1.z.literal("router")])
             .nullish()
             .transform((v) => v ?? undefined),
+        memory: zod_1.z
+            .union([
+            zod_1.z.boolean(),
+            zod_1.z.object({
+                subscribe_topic: zod_1.z
+                    .array(zod_1.z.string())
+                    .nullish()
+                    .transform((v) => v ?? undefined),
+            }),
+        ])
+            .nullish()
+            .transform((v) => v || undefined),
     }),
     zod_1.z.object({
         type: zod_1.z.literal("mcp"),
@@ -57,6 +70,12 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
 async function loadAgentFromYamlFile(path) {
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = (0, type_utils_js_1.tryOrThrow)(() => agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentFileSchema.parse({
+        ...json,
+        type: json.type ?? "ai",
+        skills: json.skills ?? json.tools,
+    }), {
+        shallowKeys: ["input_schema", "output_schema"],
+    }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
     return agent;
 }

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

@@ -7,7 +7,7 @@ export interface LoadOptions {
 export declare function load(options: LoadOptions): Promise<{
     model: ChatModel | undefined;
     agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
-    tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+    skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     description?: string | null | undefined;
     name?: string | null | undefined;
     chat_model?: {
@@ -61,11 +61,11 @@ declare const aigneFileSchema: z.ZodObject<{
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    skills: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -77,8 +77,8 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -91,8 +91,8 @@ declare const aigneFileSchema: z.ZodObject<{
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;

package/lib/cjs/loader/index.js

@@ -28,37 +28,26 @@ async function load(options) {
     const rootDir = (0, node_path_1.dirname)(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
     const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
-    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
+    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
     return {
         ...aigne,
         model: await loadModel(aigne.chat_model),
         agents,
-        tools,
+        skills,
     };
 }
 async function loadAgent(path) {
     if ((0, node_path_1.extname)(path) === ".js") {
         const agent = await (0, agent_js_js_1.loadAgentFromJsFile)(path);
-        return agent_js_1.FunctionAgent.from({
-            name: agent.name,
-            description: agent.description,
-            inputSchema: agent.input_schema,
-            outputSchema: agent.output_schema,
-            fn: agent.fn,
-        });
+        return agent_js_1.FunctionAgent.from(agent);
     }
     if ((0, node_path_1.extname)(path) === ".yaml" || (0, node_path_1.extname)(path) === ".yml") {
         const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
         if (agent.type === "ai") {
             return ai_agent_js_1.AIAgent.from({
-                name: agent.name,
-                description: agent.description,
-                instructions: agent.instructions,
-                inputSchema: agent.input_schema,
-                outputSchema: agent.output_schema,
-                outputKey: agent.output_key,
-                tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename)))),
-                toolChoice: agent.tool_choice,
+                ...agent,
+                skills: agent.skills &&
+                    (await Promise.all(agent.skills.map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename))))),
             });
         }
         if (agent.type === "mcp") {
@@ -123,12 +112,12 @@ const aigneFileSchema = zod_1.z.object({
         .nullish()
         .transform((v) => (typeof v === "string" ? { name: v } : v)),
     agents: zod_1.z.array(zod_1.z.string()).nullish(),
-    tools: zod_1.z.array(zod_1.z.string()).nullish(),
+    skills: zod_1.z.array(zod_1.z.string()).nullish(),
 });
 async function loadAIGNEFile(path) {
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
-    const agent = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.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) {