@aigne/core 1.34.0 → 1.37.0

package/lib/esm/agents/agent.js

@@ -2,9 +2,17 @@ import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { ZodObject, z } from "zod";
 import { logger } from "../utils/logger.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
-import { checkArguments, createAccessorArray, flat, isEmpty, isRecord, } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray, flat, isEmpty, isNil, isRecord, } from "../utils/type-utils.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export * from "./types.js";
+export const DEFAULT_INPUT_ACTION_GET = "$get";
+const hooksSchema = z.object({
+    onStart: z.custom().optional(),
+    onEnd: z.custom().optional(),
+    onSkillStart: z.custom().optional(),
+    onSkillEnd: z.custom().optional(),
+    onHandoff: z.custom().optional(),
+});
 export const agentOptionsSchema = z.object({
     subscribeTopic: z.union([z.string(), z.array(z.string())]).optional(),
     publishTopic: z
@@ -13,21 +21,14 @@ export const agentOptionsSchema = z.object({
     name: z.string().optional(),
     description: z.string().optional(),
     inputSchema: z.custom().optional(),
+    defaultInput: z.record(z.any()).optional(),
     outputSchema: z.custom().optional(),
     includeInputInOutput: z.boolean().optional(),
     skills: z.array(z.union([z.custom(), z.custom()])).optional(),
     disableEvents: z.boolean().optional(),
     memory: z.union([z.custom(), z.array(z.custom())]).optional(),
     maxRetrieveMemoryCount: z.number().optional(),
-    hooks: z
-        .object({
-        onStart: z.custom().optional(),
-        onEnd: z.custom().optional(),
-        onSkillStart: z.custom().optional(),
-        onSkillEnd: z.custom().optional(),
-        onHandoff: z.custom().optional(),
-    })
-        .optional(),
+    hooks: z.union([z.array(hooksSchema), hooksSchema]).optional(),
     guideRails: z.array(z.custom()).optional(),
 });
 /**
@@ -62,6 +63,7 @@ export class Agent {
         if (outputSchema)
             checkAgentInputOutputSchema(outputSchema);
         this._inputSchema = inputSchema;
+        this.defaultInput = options.defaultInput;
         this._outputSchema = outputSchema;
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
@@ -76,7 +78,7 @@ export class Agent {
             this.memories.push(options.memory);
         }
         this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
-        this.hooks = options.hooks ?? {};
+        this.hooks = flat(options.hooks);
         this.guideRails = options.guideRails;
     }
     /**
@@ -142,6 +144,7 @@ export class Agent {
      */
     description;
     _inputSchema;
+    defaultInput;
     _outputSchema;
     /**
      * Get the input data schema for this agent
@@ -291,17 +294,23 @@ export class Agent {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
+        input = this.mergeDefaultInput(input);
         logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
             opts.context.emit("agentStarted", { agent: this, input });
         try {
-            let parsedInput = (await this.hooks.onStart?.({ context: opts.context, input }))?.input ?? input;
-            parsedInput = checkArguments(`Agent ${this.name} input`, this.inputSchema, input);
-            await this.preprocess(parsedInput, opts);
+            let response;
+            const s = await this.callHooks("onStart", { input }, opts);
+            if (s?.input)
+                input = s.input;
+            input = checkArguments(`Agent ${this.name} input`, this.inputSchema, input);
+            await this.preprocess(input, opts);
             this.checkContextStatus(opts);
-            let response = await this.process(parsedInput, opts);
-            if (response instanceof Agent) {
-                response = transferToAgentOutput(response);
+            if (!response) {
+                response = await this.process(input, opts);
+                if (response instanceof Agent) {
+                    response = transferToAgentOutput(response);
+                }
             }
             if (opts.streaming) {
                 const stream = response instanceof ReadableStream
@@ -311,29 +320,62 @@ export class Agent {
                         : objectToAgentResponseStream(response);
                 return this.checkResponseByGuideRails(input, onAgentResponseStreamEnd(stream, {
                     onResult: async (result) => {
-                        return await this.processAgentOutput(parsedInput, result, opts);
+                        return await this.processAgentOutput(input, result, opts);
                     },
                     onError: async (error) => {
                         return await this.processAgentError(input, error, opts);
                     },
                 }), opts);
             }
-            return await this.checkResponseByGuideRails(input, this.processAgentOutput(parsedInput, await agentProcessResultToObject(response), opts), opts);
+            return await this.checkResponseByGuideRails(input, this.processAgentOutput(input, await agentProcessResultToObject(response), opts), opts);
         }
         catch (error) {
             throw await this.processAgentError(input, error, opts);
         }
     }
+    async callHooks(hook, input, options) {
+        const { context } = options;
+        const result = {};
+        for (const hooks of flat(options.hooks, this.hooks)) {
+            const h = hooks[hook];
+            if (!h)
+                continue;
+            if (typeof h === "function") {
+                Object.assign(result, await h({ ...input, context }));
+            }
+            else {
+                Object.assign(result, await context.invoke(h, input));
+            }
+        }
+        return result;
+    }
+    mergeDefaultInput(input) {
+        const defaultInput = Object.fromEntries(Object.entries(this.defaultInput ?? {}).filter(([, v]) => !(typeof v === "object" && DEFAULT_INPUT_ACTION_GET in v)));
+        input = { ...defaultInput, ...input };
+        for (const key of Object.keys(this.defaultInput ?? {})) {
+            const v = this.defaultInput?.[key];
+            if (v &&
+                typeof v === "object" &&
+                DEFAULT_INPUT_ACTION_GET in v &&
+                typeof v[DEFAULT_INPUT_ACTION_GET] === "string" &&
+                isNil(input[key])) {
+                const value = input[v[DEFAULT_INPUT_ACTION_GET]];
+                if (!isNil(value))
+                    Object.assign(input, { [key]: value });
+            }
+        }
+        return input;
+    }
     async invokeSkill(skill, input, options) {
         const { context } = options;
-        await this.hooks.onSkillStart?.({ context, skill, input });
+        await this.callHooks("onSkillStart", { skill, input }, options);
         try {
             const output = await context.invoke(skill, input);
-            await this.hooks.onSkillEnd?.({ context, skill, input, output });
+            await this.callHooks("onSkillEnd", { skill, input, output }, options);
             return output;
         }
         catch (error) {
-            await this.hooks.onSkillEnd?.({ context, skill, input, error });
+            await this.callHooks("onSkillEnd", { skill, input, error }, options);
             throw error;
         }
     }
@@ -353,14 +395,17 @@ export class Agent {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
         }
         const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
-        const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
+        let finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         await this.postprocess(input, finalOutput, options);
         logger.debug("Invoke agent %s succeed with output: %O", this.name, finalOutput);
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
-        const o = (await this.hooks.onEnd?.({ context, input, output: finalOutput }))?.output;
-        if (o)
-            return o;
+        let o = await this.callHooks("onSuccess", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
+        o = await this.callHooks("onEnd", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
         return finalOutput;
     }
     /**
@@ -375,8 +420,8 @@ export class Agent {
         logger.error("Invoke agent %s failed with error: %O", this.name, error);
         if (!this.disableEvents)
             options.context.emit("agentFailed", { agent: this, error });
-        const { context } = options;
-        await this.hooks.onEnd?.({ context, input, error });
+        await this.callHooks("onError", { input, error }, options);
+        await this.callHooks("onEnd", { input, error }, options);
         return error;
     }
     /**

package/lib/esm/agents/ai-agent.js

@@ -240,7 +240,7 @@ export class AIAgent extends Agent {
         const outputKey = this.outputKey;
         for (;;) {
             const modelOutput = {};
-            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { ...options, streaming: true });
             if (this.structuredStreamMode) {
                 const { metadataStart, metadataEnd, parse } = this.customStructuredStreamInstructions || STRUCTURED_STREAM_INSTRUCTIONS;
                 stream = stream.pipeThrough(new ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
@@ -315,14 +315,17 @@ export class AIAgent extends Agent {
      * @protected
      */
     async *_processRouter(input, model, modelInput, options, toolsMap) {
-        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput);
+        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput, {
+            ...options,
+            streaming: false,
+        });
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
         const tool = toolsMap.get(call.function.name);
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
-        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
+        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { ...options, streaming: true, sourceAgent: this });
         return yield* stream;
     }
 }

package/lib/esm/agents/team-agent.d.ts

@@ -22,6 +22,73 @@ export declare enum ProcessMode {
      */
     parallel = "parallel"
 }
+export declare const DEFAULT_REFLECTION_MAX_ITERATIONS = 3;
+/**
+ * Configuration for reflection mode processing in TeamAgent.
+ *
+ * Reflection mode enables iterative refinement of agent outputs through a review process.
+ * The team agent will repeatedly process the input and have a reviewer agent evaluate
+ * the output until it meets approval criteria or reaches the maximum iteration limit.
+ *
+ * This is particularly useful for:
+ * - Quality assurance workflows where outputs need validation
+ * - Iterative improvement processes where initial results can be refined
+ * - Self-correcting agent systems that learn from feedback
+ */
+export interface ReflectionMode {
+    /**
+     * The agent responsible for reviewing and providing feedback on the team's output.
+     *
+     * The reviewer agent receives the combined output from the team's processing
+     * and should provide feedback or evaluation that can be used to determine
+     * whether the output meets the required standards.
+     */
+    reviewer: Agent;
+    /**
+     * Function that determines whether the reviewer's output indicates approval.
+     *
+     * This function receives the reviewer agent's output message and should return:
+     * - `true` or truthy value: The output is approved and processing should stop
+     * - `false` or falsy value: The output needs improvement and another iteration should run
+     *
+     * The function can be synchronous or asynchronous, allowing for complex approval logic
+     * including external validation, scoring systems, or human-in-the-loop approval.
+     *
+     * @param output - The message output from the reviewer agent
+     * @returns A boolean or truthy/falsy value indicating approval status
+     */
+    isApproved: (output: Message) => PromiseOrValue<boolean | unknown>;
+    /**
+     * Maximum number of reflection iterations before giving up.
+     *
+     * This prevents infinite loops when the approval criteria cannot be met.
+     * If the maximum iterations are reached without approval, the process will
+     * throw an error indicating the reflection failed to converge.
+     *
+     * @default 3
+     */
+    maxIterations?: number;
+    /**
+     * Controls the behavior when maximum iterations are reached without approval.
+     *
+     * When set to `true`, the TeamAgent will return the last generated output
+     * instead of throwing an error when the maximum number of reflection iterations
+     * is reached without the reviewer's approval.
+     *
+     * When set to `false` or undefined, the TeamAgent will throw an error
+     * indicating that the reflection process failed to converge within the
+     * maximum iteration limit.
+     *
+     * This option is useful for scenarios where:
+     * - You want to get the best available result even if it's not perfect
+     * - The approval criteria might be too strict for the given context
+     * - You prefer graceful degradation over complete failure
+     * - You want to implement custom error handling based on the returned result
+     *
+     * @default false
+     */
+    returnLastOnMaxIterations?: boolean;
+}
 /**
  * Configuration options for creating a TeamAgent.
  *
@@ -33,6 +100,21 @@ export interface TeamAgentOptions<I extends Message, O extends Message> extends
      * @default {ProcessMode.sequential}
      */
     mode?: ProcessMode;
+    /**
+     * Configuration for reflection mode processing.
+     *
+     * When enabled, the TeamAgent will use an iterative refinement process where:
+     * 1. The team processes the input normally
+     * 2. A reviewer agent evaluates the output
+     * 3. If not approved, the process repeats with the previous output as context
+     * 4. This continues until approval or maximum iterations are reached
+     *
+     * This enables self-improving agent workflows that can iteratively refine
+     * their outputs based on feedback from a specialized reviewer agent.
+     *
+     * @see ReflectionMode for detailed configuration options
+     */
+    reflection?: ReflectionMode;
     /**
      * Specifies which input field should be treated as an array for iterative processing.
      *
@@ -116,6 +198,14 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * This can be either sequential (one after another) or parallel (all at once).
      */
     mode: ProcessMode;
+    /**
+     * The reflection mode configuration with guaranteed maxIterations value.
+     *
+     * This is the internal representation after processing the user-provided
+     * reflection configuration, ensuring that maxIterations always has a value
+     * (defaulting to DEFAULT_REFLECTION_MAX_ITERATIONS if not specified).
+     */
+    reflection?: ReflectionMode & Required<Pick<ReflectionMode, "maxIterations">>;
     /**
      * The input field key to iterate over when processing array inputs.
      *
@@ -148,8 +238,10 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * @returns A stream of message chunks that collectively form the response
      */
     process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    private _processNonReflection;
+    private _processReflection;
     private _processIterator;
-    private _process;
+    private _processNonIterator;
     /**
      * Process input sequentially through each agent in the team.
      *

package/lib/esm/agents/team-agent.js

@@ -26,6 +26,7 @@ export var ProcessMode;
      */
     ProcessMode["parallel"] = "parallel";
 })(ProcessMode || (ProcessMode = {}));
+export const DEFAULT_REFLECTION_MAX_ITERATIONS = 3;
 /**
  * TeamAgent coordinates a group of agents working together to accomplish tasks.
  *
@@ -70,6 +71,10 @@ export class TeamAgent extends Agent {
     constructor(options) {
         super(options);
         this.mode = options.mode ?? ProcessMode.sequential;
+        this.reflection = options.reflection && {
+            ...options.reflection,
+            maxIterations: options.reflection.maxIterations ?? DEFAULT_REFLECTION_MAX_ITERATIONS,
+        };
         this.iterateOn = options.iterateOn;
         this.iterateWithPreviousOutput = options.iterateWithPreviousOutput;
     }
@@ -79,6 +84,14 @@ export class TeamAgent extends Agent {
      * This can be either sequential (one after another) or parallel (all at once).
      */
     mode;
+    /**
+     * The reflection mode configuration with guaranteed maxIterations value.
+     *
+     * This is the internal representation after processing the user-provided
+     * reflection configuration, ensuring that maxIterations always has a value
+     * (defaulting to DEFAULT_REFLECTION_MAX_ITERATIONS if not specified).
+     */
+    reflection;
     /**
      * The input field key to iterate over when processing array inputs.
      *
@@ -113,10 +126,35 @@ export class TeamAgent extends Agent {
     process(input, options) {
         if (!this.skills.length)
             throw new Error("TeamAgent must have at least one skill defined.");
+        if (this.reflection)
+            return this._processReflection(input, options);
+        return this._processNonReflection(input, options);
+    }
+    _processNonReflection(input, options) {
         if (this.iterateOn) {
             return this._processIterator(this.iterateOn, input, options);
         }
-        return this._process(input, options);
+        return this._processNonIterator(input, options);
+    }
+    async _processReflection(input, options) {
+        assert(this.reflection, "Reflection mode must be defined for reflection processing");
+        let iterations = 0;
+        const previousOutput = { ...input };
+        for (;;) {
+            const output = await agentProcessResultToObject(await this._processNonReflection(previousOutput, options));
+            Object.assign(previousOutput, output);
+            const reviewOutput = await options.context.invoke(this.reflection.reviewer, previousOutput);
+            Object.assign(previousOutput, reviewOutput);
+            const approved = await this.reflection.isApproved(reviewOutput);
+            if (approved)
+                return output;
+            if (++iterations >= this.reflection.maxIterations) {
+                if (this.reflection.returnLastOnMaxIterations)
+                    return output;
+                break;
+            }
+        }
+        throw new Error(`Reflection mode exceeded max iterations ${this.reflection.maxIterations}. Please review the feedback and try again.`);
     }
     async *_processIterator(key, input, options) {
         assert(this.iterateOn, "iterateInputKey must be defined for iterator processing");
@@ -127,7 +165,7 @@ export class TeamAgent extends Agent {
             const item = arr[i];
             if (!isRecord(item))
                 throw new TypeError(`Expected ${String(key)} to be an object, got ${typeof item}`);
-            const res = await agentProcessResultToObject(await this._process({ ...input, [key]: arr, ...item }, { ...options, streaming: false }));
+            const res = await agentProcessResultToObject(await this._processNonIterator({ ...input, [key]: arr, ...item }, { ...options, streaming: false }));
             // Merge the item result with the original item used for next iteration
             if (this.iterateWithPreviousOutput) {
                 arr = produce(arr, (draft) => {
@@ -140,7 +178,7 @@ export class TeamAgent extends Agent {
             yield { delta: { json: { [key]: result } } };
         }
     }
-    _process(input, options) {
+    _processNonIterator(input, options) {
         switch (this.mode) {
             case ProcessMode.sequential:
                 return this._processSequential(input, options);
@@ -165,19 +203,13 @@ export class TeamAgent extends Agent {
      */
     async *_processSequential(input, options) {
         const output = {};
-        // Clone the agents to run, so that we can update the agents list during the loop
-        const agents = [...this.skills];
-        const newAgents = [];
-        for (const agent of agents) {
-            const [o, transferToAgent] = await options.context.invoke(agent, { ...input, ...output }, { returnActiveAgent: true, streaming: true });
+        for (const agent of this.skills) {
+            const o = await options.context.invoke(agent, { ...input, ...output }, { ...options, streaming: true });
             for await (const chunk of o) {
                 yield chunk;
                 mergeAgentResponseChunk(output, chunk);
             }
-            newAgents.push(await transferToAgent);
         }
-        this.skills.splice(0);
-        this.skills.push(...newAgents);
     }
     /**
      * Process input in parallel through all agents in the team.
@@ -194,8 +226,7 @@ export class TeamAgent extends Agent {
      * @private
      */
     async *_processParallel(input, options) {
-        const result = await Promise.all(this.skills.map((agent) => options.context.invoke(agent, input, { returnActiveAgent: true, streaming: true })));
-        const streams = result.map((i) => i[0]);
+        const streams = await Promise.all(this.skills.map((agent) => options.context.invoke(agent, input, { ...options, streaming: true })));
         const read = async (index, reader) => {
             const promise = reader.read();
             return promise.then((result) => ({ ...result, reader, index }));
@@ -230,8 +261,5 @@ export class TeamAgent extends Agent {
                     yield { delta: { ...delta, text } };
             }
         }
-        const agents = await Promise.all(result.map((i) => i[1]));
-        this.skills.splice(0);
-        this.skills.push(...agents);
     }
 }

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

@@ -180,6 +180,7 @@ declare class AIGNEContextShared {
     span?: Span;
     constructor(parent?: (Pick<Context, "model" | "skills" | "limits" | "observer"> & {
         messageQueue?: MessageQueue;
+        events?: Emitter<any>;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: Emitter<any>;

package/lib/esm/aigne/context.js

@@ -34,7 +34,7 @@ export class AIGNEContext {
             }
         }
         else {
-            this.internal = new AIGNEContextShared(parent);
+            this.internal = new AIGNEContextShared(parent instanceof AIGNEContext ? parent.internal : parent);
             this.span = tracer?.startSpan("AIGNEContext");
             // 修改了 rootId 是否会之前的有影响？，之前为 this.id
             this.rootId = this.span?.spanContext?.().traceId ?? v7();
@@ -265,9 +265,10 @@ class AIGNEContextShared {
     constructor(parent) {
         this.parent = parent;
         this.messageQueue = this.parent?.messageQueue ?? new MessageQueue();
+        this.events = this.parent?.events ?? new Emitter();
     }
     messageQueue;
-    events = new Emitter();
+    events;
     get model() {
         return this.parent?.model;
     }
@@ -302,21 +303,35 @@ class AIGNEContextShared {
         this.initTimeout();
         return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
     }
-    async *invokeAgent(agent, input, context, options) {
+    async *invokeAgent(agent, input, context, options = {}) {
         const startedAt = Date.now();
         try {
             let activeAgent = agent;
             for (;;) {
                 const result = {};
                 if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
-                    options.sourceAgent.hooks.onHandoff?.({
-                        context,
-                        source: options.sourceAgent,
-                        target: activeAgent,
-                        input,
-                    });
+                    for (const { onHandoff } of [options.hooks ?? {}, ...options.sourceAgent.hooks]) {
+                        if (!onHandoff)
+                            continue;
+                        await (typeof onHandoff === "function"
+                            ? onHandoff({
+                                context,
+                                source: options.sourceAgent,
+                                target: activeAgent,
+                                input,
+                            })
+                            : context.invoke(onHandoff, {
+                                source: options.sourceAgent,
+                                target: activeAgent,
+                                input,
+                            }));
+                    }
                 }
-                const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
+                const stream = await activeAgent.invoke(input, {
+                    hooks: options.hooks,
+                    context,
+                    streaming: true,
+                });
                 for await (const value of stream) {
                     if (isAgentResponseDelta(value)) {
                         if (value.delta.json) {

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

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

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

@@ -1,26 +1,17 @@
-import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
-import camelize from "camelize-ts";
-import { z } from "zod";
 import { Agent } from "../agents/agent.js";
 import { tryOrThrow } from "../utils/type-utils.js";
-import { inputOutputSchema, optionalize } from "./schema.js";
+import { parseAgentFile } from "./agent-yaml.js";
 export async function loadAgentFromJsFile(path) {
-    const agentJsFileSchema = z.object({
-        name: z.string(),
-        description: optionalize(z.string()),
-        inputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
-        outputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
-        process: z.custom(),
-    });
     const { default: agent } = await tryOrThrow(() => import(/* @vite-ignore */ path), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     if (agent instanceof Agent)
         return agent;
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return tryOrThrow(() => agentJsFileSchema.parseAsync(camelize({
+    return tryOrThrow(() => parseAgentFile(path, {
         ...agent,
+        type: "function",
         name: agent.agent_name || agent.agentName || agent.name,
         process: agent,
-    })), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
 }