@aigne/core 1.10.0 → 1.12.0

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

@@ -3,29 +3,29 @@ import { Agent } from "../agents/agent.js";
 import { load } from "../loader/index.js";
 import { ChatModel } from "../models/chat-model.js";
 import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
-import { ExecutionContext } from "./context.js";
+import { AIGNEContext } from "./context.js";
 import { MessageQueue } from "./message-queue.js";
-export class ExecutionEngine {
+export class AIGNE {
     static async load({ path, ...options }) {
-        const { model, agents, tools, ...aigne } = await load({ path });
-        return new ExecutionEngine({
+        const { model, agents, skills, ...aigne } = await load({ path });
+        return new AIGNE({
             ...options,
             model: options.model || model,
             name: options.name || aigne.name || undefined,
             description: options.description || aigne.description || undefined,
             agents: agents.concat(options.agents ?? []),
-            tools: tools.concat(options.tools ?? []),
+            skills: skills.concat(options.skills ?? []),
         });
     }
     constructor(options) {
         if (options)
-            checkArguments("ExecutionEngine", executionEngineOptionsSchema, options);
+            checkArguments("AIGNE", aigneOptionsSchema, options);
         this.name = options?.name;
         this.description = options?.description;
         this.model = options?.model;
         this.limits = options?.limits;
-        if (options?.tools?.length)
-            this.tools.push(...options.tools);
+        if (options?.skills?.length)
+            this.skills.push(...options.skills);
         if (options?.agents?.length)
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
@@ -34,24 +34,24 @@ export class ExecutionEngine {
     description;
     messageQueue = new MessageQueue();
     model;
-    tools = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
+    skills = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     agents = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     limits;
     addAgent(...agents) {
-        checkArguments("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);
+        checkArguments("AIGNE.addAgent", aigneAddAgentArgsSchema, agents);
         for (const agent of agents) {
             this.agents.push(agent);
             agent.attach(this);
         }
     }
     newContext() {
-        return new ExecutionContext(this);
+        return new AIGNEContext(this);
     }
     publish = ((...args) => {
-        return new ExecutionContext(this).publish(...args);
+        return new AIGNEContext(this).publish(...args);
     });
-    call = ((...args) => {
-        return new ExecutionContext(this).call(...args);
+    invoke = ((...args) => {
+        return new AIGNEContext(this).invoke(...args);
     });
     subscribe = ((...args) => {
         return this.messageQueue.subscribe(...args);
@@ -60,7 +60,7 @@ export class ExecutionEngine {
         this.messageQueue.unsubscribe(...args);
     });
     async shutdown() {
-        for (const tool of this.tools) {
+        for (const tool of this.skills) {
             await tool.shutdown();
         }
         for (const agent of this.agents) {
@@ -73,9 +73,9 @@ export class ExecutionEngine {
         process.on("exit", shutdownAndExit);
     }
 }
-const executionEngineOptionsSchema = z.object({
+const aigneOptionsSchema = z.object({
     model: z.instanceof(ChatModel).optional(),
-    tools: z.array(z.instanceof(Agent)).optional(),
+    skills: z.array(z.instanceof(Agent)).optional(),
     agents: z.array(z.instanceof(Agent)).optional(),
 });
-const executionEngineAddAgentArgsSchema = z.array(z.instanceof(Agent));
+const aigneAddAgentArgsSchema = z.array(z.instanceof(Agent));

package/lib/esm/{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/esm/{execution-engine → aigne}/context.js

@@ -16,14 +16,14 @@ export function createPublishMessage(message, from) {
         message: createMessage(message),
     };
 }
-export class ExecutionContext {
+export 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;
@@ -32,8 +32,8 @@ export 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;
@@ -46,11 +46,11 @@ export 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) => {
-        checkArguments("ExecutionContext.call", executionContextCallArgsSchema, {
+    invoke = ((agent, message, options) => {
+        checkArguments("AIGNEContext.invoke", aigneContextInvokeArgsSchema, {
             agent,
             message,
             options,
@@ -63,10 +63,10 @@ export class ExecutionContext {
         }
         const newContext = this.newContext();
         const msg = 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 agentResponseStreamToObject(response);
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 if (options?.returnActiveAgent) {
                     return [output, activeAgent];
                 }
@@ -74,7 +74,7 @@ export class ExecutionContext {
             }
             const activeAgentPromise = Promise.withResolvers();
             const stream = onAgentResponseStreamEnd(asyncGeneratorToReadableStream(response), async ({ __activeAgent__: activeAgent, ...output }) => {
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 activeAgentPromise.resolve(activeAgent);
             }, {
                 processChunk(chunk) {
@@ -96,7 +96,7 @@ export class ExecutionContext {
             return stream;
         });
     });
-    async onCallSuccess(activeAgent, output, context) {
+    async onInvokeSuccess(activeAgent, output, context) {
         if (activeAgent instanceof Agent) {
             const publishTopics = typeof activeAgent.publishTopic === "function"
                 ? await activeAgent.publishTopic(output)
@@ -138,7 +138,7 @@ export class ExecutionContext {
         return this;
     }
 }
-class ExecutionContextInternal {
+class AIGNEContextInternal {
     parent;
     constructor(parent) {
         this.parent = parent;
@@ -149,8 +149,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;
@@ -171,33 +171,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 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 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) {
-                activeAgent = result;
-                continue;
             }
             if (!options?.disableTransfer) {
                 const transferToAgent = isTransferAgentOutput(result)
@@ -242,7 +232,7 @@ async function* withAbortSignal(signal, error, fn) {
         signal.removeEventListener("abort", listener);
     }
 }
-const executionContextCallArgsSchema = z.object({
+const aigneContextInvokeArgsSchema = z.object({
     agent: z.union([z.function(), z.instanceof(Agent)]),
     message: z.union([z.record(z.unknown()), z.string()]).optional(),
     options: z.object({ returnActiveAgent: z.boolean().optional() }).optional(),

package/lib/esm/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/esm/aigne/index.js

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

package/lib/esm/{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/esm/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/esm/client/client.js

@@ -0,0 +1,45 @@
+import { AgentResponseStreamParser, EventStreamParser } from "../utils/event-stream.js";
+import { tryOrThrow } from "../utils/type-utils.js";
+export 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 EventStreamParser())
+            .pipeThrough(new AgentResponseStreamParser());
+    }
+    async fetch(...args) {
+        const result = await globalThis.fetch(...args);
+        if (!result.ok) {
+            let message;
+            try {
+                const text = await result.text();
+                const json = 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;
+    }
+}

package/lib/esm/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/esm/index.js

@@ -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/esm/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/esm/loader/agent-js.js

@@ -1,5 +1,6 @@
 import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
 import { z } from "zod";
+import { customCamelize } from "../utils/camelize.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { inputOutputSchema } from "./schema.js";
 const agentJsFileSchema = z.object({
@@ -21,11 +22,9 @@ export async function loadAgentFromJsFile(path) {
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return tryOrThrow(() => agentJsFileSchema.parse({
+    return tryOrThrow(() => 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/esm/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/esm/loader/agent-yaml.js

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
 import { parse } from "yaml";
 import { z } from "zod";
+import { customCamelize } from "../utils/camelize.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { inputOutputSchema } from "./schema.js";
 const agentFileSchema = z.discriminatedUnion("type", [
@@ -26,7 +27,7 @@ const agentFileSchema = z.discriminatedUnion("type", [
             .string()
             .nullish()
             .transform((v) => v ?? undefined),
-        tools: z
+        skills: z
             .array(z.string())
             .nullish()
             .transform((v) => v ?? undefined),
@@ -34,6 +35,18 @@ const agentFileSchema = z.discriminatedUnion("type", [
             .union([z.literal("auto"), z.literal("none"), z.literal("required"), z.literal("router")])
             .nullish()
             .transform((v) => v ?? undefined),
+        memory: z
+            .union([
+            z.boolean(),
+            z.object({
+                subscribe_topic: z
+                    .array(z.string())
+                    .nullish()
+                    .transform((v) => v ?? undefined),
+            }),
+        ])
+            .nullish()
+            .transform((v) => v || undefined),
     }),
     z.object({
         type: z.literal("mcp"),
@@ -54,6 +67,12 @@ 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 json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = tryOrThrow(() => agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    const agent = tryOrThrow(() => 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;
 }