@aigne/core 1.72.0-beta.2 → 1.72.0-beta.23

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

@@ -1,4 +1,4 @@
-import { type ZodObject, type ZodType } from "zod";
+import z, { type ZodObject, type ZodType } from "zod";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "./agent.js";
 import { type ImageModelOutput } from "./image-model.js";
@@ -13,6 +13,22 @@ export declare const imageAgentOptionsSchema: ZodObject<{
 }>;
 export declare class ImageAgent<I extends Message = any, O extends ImageModelOutput = any> extends Agent<I, O> {
     tag: string;
+    static schema({ filepath }: {
+        filepath: string;
+    }): z.ZodObject<{
+        instructions: z.ZodType<import("../loader/schema.js").Instructions, z.ZodTypeDef, import("../loader/schema.js").Instructions>;
+        inputFileKey: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    }, "strip", z.ZodTypeAny, {
+        instructions: import("../loader/schema.js").Instructions;
+        inputFileKey?: string | undefined;
+    }, {
+        instructions: import("../loader/schema.js").Instructions;
+        inputFileKey?: string | undefined;
+    }>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     static from<I extends Message = any, O extends ImageModelOutput = any>(options: ImageAgentOptions<I, O>): ImageAgent<I, O>;
     constructor(options: ImageAgentOptions<I, O>);
     instructions: PromptBuilder;

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

@@ -1,4 +1,5 @@
 import z from "zod";
+import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize, } from "../loader/schema.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { checkArguments } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, } from "./agent.js";
@@ -10,6 +11,21 @@ export const imageAgentOptionsSchema = agentOptionsSchema.extend({
 });
 export class ImageAgent extends Agent {
     tag = "ImageAgent";
+    static schema({ filepath }) {
+        const instructionsSchema = getInstructionsSchema({ filepath });
+        return camelizeSchema(z.object({
+            instructions: instructionsSchema,
+            inputFileKey: optionalize(z.string()),
+        }));
+    }
+    static async load(options) {
+        const valid = await ImageAgent.schema({ filepath: options.filepath }).parseAsync(options.parsed);
+        return new ImageAgent({
+            ...options.parsed,
+            ...valid,
+            instructions: instructionsToPromptBuilder(valid.instructions),
+        });
+    }
     static from(options) {
         return new ImageAgent(options);
     }

package/lib/esm/agents/image-model.d.ts

@@ -107,8 +107,8 @@ export declare const imageModelInputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[] | undefined;
-    outputFileType?: "local" | "file" | "url" | undefined;
     n?: number | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
 }, {
     prompt: string;
     modelOptions?: Record<string, unknown> | undefined;
@@ -128,8 +128,8 @@ export declare const imageModelInputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[] | undefined;
-    outputFileType?: "local" | "file" | "url" | undefined;
     n?: number | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
 }>;
 export interface ImageModelOutput extends Message {
     images: FileUnionContent[];
@@ -196,16 +196,22 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         inputTokens: z.ZodNumber;
         outputTokens: z.ZodNumber;
         aigneHubCredits: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+        cacheCreationInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+        cacheReadInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
         creditPrefix: ZodType<"$" | "€" | "¥" | undefined, z.ZodTypeDef, "$" | "€" | "¥" | undefined>;
     }, "strip", z.ZodTypeAny, {
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     }, {
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     }>>;
     model: z.ZodOptional<z.ZodString>;
@@ -231,6 +237,8 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
 }, {
@@ -255,6 +263,8 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
 }>;

package/lib/esm/agents/image-model.js

@@ -67,7 +67,7 @@ export class ImageModel extends Model {
             const images = z.array(fileUnionContentSchema).parse(output.images);
             output = {
                 ...output,
-                images: await Promise.all(images.map((image) => this.transformFileType(input.outputFileType, image, options))),
+                images: await Promise.all(images.map((image) => this.transformFileType(input.outputFileType, image))),
             };
         }
         return super.processAgentOutput(input, output, options);

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

@@ -58,6 +58,23 @@ export type SSEServerParameters = {
  */
 export declare class MCPAgent extends Agent {
     tag: string;
+    static schema(): z.ZodObject<{
+        url: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+        command: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+        args: ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
+    }, "strip", z.ZodTypeAny, {
+        url?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+    }, {
+        url?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+    }>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     /**
      * Create an MCPAgent from a connection to an SSE server.
      *

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

@@ -5,6 +5,7 @@ import { SSEClientTransport, } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
 import { z } from "zod";
+import { optionalize } from "../loader/schema.js";
 import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
 import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
@@ -49,6 +50,23 @@ function getMCPServerString(options) {
  */
 export class MCPAgent extends Agent {
     tag = "MCPAgent";
+    static schema() {
+        return z.object({
+            url: optionalize(z.string()),
+            command: optionalize(z.string()),
+            args: optionalize(z.array(z.string())),
+        });
+    }
+    static async load(options) {
+        const valid = await MCPAgent.schema().parseAsync(options.parsed);
+        if (!valid.url && !valid.command) {
+            throw new Error(`Missing url or command in mcp agent: ${options.filepath}`);
+        }
+        return MCPAgent.from({
+            ...options.parsed,
+            ...valid,
+        });
+    }
     static from(options) {
         checkArguments("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {

package/lib/esm/agents/model.d.ts

@@ -17,9 +17,9 @@ export declare abstract class Model<I extends Message = any, O extends Message =
      */
     getModelOptions(input: Message, options: AgentInvokeOptions): Promise<Record<string, unknown>>;
     protected preprocess(input: I, options: AgentInvokeOptions): Promise<void>;
-    transformFileType(fileType: "file", data: FileUnionContent, options: AgentInvokeOptions): Promise<FileContent>;
-    transformFileType(fileType: "local" | undefined, data: FileUnionContent, options: AgentInvokeOptions): Promise<LocalContent>;
-    transformFileType(fileType: FileType | undefined, data: FileUnionContent, options: AgentInvokeOptions): Promise<FileUnionContent>;
+    transformFileType(fileType: "file", data: FileUnionContent): Promise<FileContent>;
+    transformFileType(fileType: "local" | undefined, data: FileUnionContent): Promise<LocalContent>;
+    transformFileType(fileType: FileType | undefined, data: FileUnionContent): Promise<FileUnionContent>;
     static getFileExtension(type: string): Promise<string | undefined>;
     static getMimeType(filename: string): Promise<string | undefined>;
     downloadFile(url: string): Promise<Response>;

package/lib/esm/agents/model.js

@@ -53,13 +53,13 @@ export class Model extends Agent {
         Object.assign(input, { modelOptions: await this.getModelOptions(input, options) });
         return super.preprocess(input, options);
     }
-    async transformFileType(fileType = "local", data, options) {
+    async transformFileType(fileType = "local", data) {
         if (fileType === data.type)
             return data;
         const common = pick(data, "filename", "mimeType");
         switch (fileType) {
             case "local": {
-                const dir = nodejs.path.join(nodejs.os.tmpdir(), options.context.id);
+                const dir = nodejs.path.join(nodejs.os.tmpdir(), v7());
                 await nodejs.fs.mkdir(dir, { recursive: true });
                 const ext = await Model.getFileExtension(data.mimeType || data.filename || "");
                 const id = v7();

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

@@ -1,3 +1,5 @@
+import { z } from "zod";
+import type { AgentLoadOptions } from "../loader/index.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type Message } from "./agent.js";
 /**
@@ -200,6 +202,59 @@ export interface TeamAgentOptions<I extends Message, O extends Message> extends
  */
 export declare class TeamAgent<I extends Message, O extends Message> extends Agent<I, O> {
     tag: string;
+    static schema({ filepath }: {
+        filepath: string;
+    }): z.ZodObject<{
+        mode: z.ZodType<ProcessMode | undefined, z.ZodTypeDef, ProcessMode | undefined>;
+        iterateOn: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+        concurrency: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+        iterateWithPreviousOutput: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+        includeAllStepsOutput: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+        reflection: z.ZodType<{
+            reviewer: import("../loader/agent-yaml.js").NestAgentSchema;
+            isApproved: string;
+            maxIterations?: number | undefined;
+            returnLastOnMaxIterations?: boolean | undefined;
+            customErrorMessage?: string | undefined;
+        } | undefined, z.ZodTypeDef, {
+            reviewer: import("../loader/agent-yaml.js").NestAgentSchema;
+            isApproved: string;
+            maxIterations?: number | undefined;
+            returnLastOnMaxIterations?: boolean | undefined;
+            customErrorMessage?: string | undefined;
+        } | undefined>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: ProcessMode | undefined;
+        reflection?: {
+            reviewer: import("../loader/agent-yaml.js").NestAgentSchema;
+            isApproved: string;
+            maxIterations?: number | undefined;
+            returnLastOnMaxIterations?: boolean | undefined;
+            customErrorMessage?: string | undefined;
+        } | undefined;
+        iterateOn?: string | undefined;
+        concurrency?: number | undefined;
+        iterateWithPreviousOutput?: boolean | undefined;
+        includeAllStepsOutput?: boolean | undefined;
+    }, {
+        mode?: ProcessMode | undefined;
+        reflection?: {
+            reviewer: import("../loader/agent-yaml.js").NestAgentSchema;
+            isApproved: string;
+            maxIterations?: number | undefined;
+            returnLastOnMaxIterations?: boolean | undefined;
+            customErrorMessage?: string | undefined;
+        } | undefined;
+        iterateOn?: string | undefined;
+        concurrency?: number | undefined;
+        iterateWithPreviousOutput?: boolean | undefined;
+        includeAllStepsOutput?: boolean | undefined;
+    }>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+        options: AgentLoadOptions;
+    }): Promise<Agent<I, O>>;
     /**
      * Create a TeamAgent from the provided options.
      *

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

@@ -1,5 +1,8 @@
 import assert from "node:assert";
 import { produce } from "immer";
+import { z } from "zod";
+import { getNestAgentSchema } from "../loader/agent-yaml.js";
+import { camelizeSchema, optionalize } from "../loader/schema.js";
 import * as fastq from "../utils/queue.js";
 import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { isEmpty, isNil, isRecord, omit } from "../utils/type-utils.js";
@@ -47,6 +50,34 @@ export const DEFAULT_REFLECTION_MAX_ITERATIONS = 3;
  */
 export class TeamAgent extends Agent {
     tag = "TeamAgent";
+    static schema({ filepath }) {
+        const nestAgentSchema = getNestAgentSchema({ filepath });
+        return z.object({
+            mode: optionalize(z.nativeEnum(ProcessMode)),
+            iterateOn: optionalize(z.string()),
+            concurrency: optionalize(z.number().int().min(1)),
+            iterateWithPreviousOutput: optionalize(z.boolean()),
+            includeAllStepsOutput: optionalize(z.boolean()),
+            reflection: camelizeSchema(optionalize(z.object({
+                reviewer: nestAgentSchema,
+                isApproved: z.string(),
+                maxIterations: optionalize(z.number().int().min(1)),
+                returnLastOnMaxIterations: optionalize(z.boolean()),
+                customErrorMessage: optionalize(z.string()),
+            }))),
+        });
+    }
+    static async load(options) {
+        const valid = await TeamAgent.schema({ filepath: options.filepath }).parseAsync(options.parsed);
+        return TeamAgent.from({
+            ...options.parsed,
+            ...valid,
+            reflection: valid.reflection && {
+                ...valid.reflection,
+                reviewer: await options.options.loadNestAgent(options.filepath, valid.reflection.reviewer, options.options),
+            },
+        });
+    }
     /**
      * Create a TeamAgent from the provided options.
      *

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 /**
  * Configuration options for TransformAgent
@@ -47,6 +48,17 @@ export interface TransformAgentOptions<I extends Message, O extends Message> ext
  */
 export declare class TransformAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static type: string;
+    static schema(): z.ZodObject<{
+        jsonata: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        jsonata: string;
+    }, {
+        jsonata: string;
+    }>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     /**
      * Factory method to create a new TransformAgent instance
      *

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

@@ -1,4 +1,5 @@
 import jsonata from "jsonata";
+import { z } from "zod";
 import { Agent } from "./agent.js";
 /**
  * TransformAgent - A specialized agent for data transformation using JSONata expressions
@@ -17,6 +18,18 @@ import { Agent } from "./agent.js";
  */
 export class TransformAgent extends Agent {
     static type = "TransformAgent";
+    static schema() {
+        return z.object({
+            jsonata: z.string(),
+        });
+    }
+    static async load(options) {
+        const parsed = await TransformAgent.schema().parseAsync(options.parsed);
+        return TransformAgent.from({
+            ...options.parsed,
+            ...parsed,
+        });
+    }
     /**
      * Factory method to create a new TransformAgent instance
      *

package/lib/esm/agents/video-model.d.ts

@@ -203,16 +203,22 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         inputTokens: z.ZodNumber;
         outputTokens: z.ZodNumber;
         aigneHubCredits: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+        cacheCreationInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+        cacheReadInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
         creditPrefix: ZodType<"$" | "€" | "¥" | undefined, z.ZodTypeDef, "$" | "€" | "¥" | undefined>;
     }, "strip", z.ZodTypeAny, {
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     }, {
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     }>>;
     model: z.ZodOptional<z.ZodString>;
@@ -239,6 +245,8 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
     seconds?: number | undefined;
@@ -264,6 +272,8 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         inputTokens: number;
         outputTokens: number;
         aigneHubCredits?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
     seconds?: number | undefined;

package/lib/esm/agents/video-model.js

@@ -40,7 +40,7 @@ export class VideoModel extends Model {
             const videos = z.array(fileUnionContentSchema).parse(output.videos);
             output = {
                 ...output,
-                videos: await Promise.all(videos.map((video) => this.transformFileType(input.outputFileType, video, options))),
+                videos: await Promise.all(videos.map((video) => this.transformFileType(input.outputFileType, video))),
             };
         }
         return super.processAgentOutput(input, output, options);

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

@@ -159,7 +159,7 @@ export declare class AIGNEContext implements Context {
     readonly internal: AIGNEContextShared;
     get messageQueue(): MessageQueue;
     get model(): ChatModel | undefined;
-    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
+    get imageModel(): ImageModel<import("../index.js").ImageModelInput, import("../index.js").ImageModelOutput> | undefined;
     get skills(): Agent<any, any>[] | undefined;
     get agents(): Agent<any, any>[];
     get observer(): AIGNEObserver | undefined;
@@ -197,7 +197,7 @@ declare class AIGNEContextShared {
     readonly messageQueue: MessageQueue;
     readonly events: Emitter<any>;
     get model(): ChatModel | undefined;
-    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
+    get imageModel(): ImageModel<import("../index.js").ImageModelInput, import("../index.js").ImageModelOutput> | undefined;
     get skills(): Agent<any, any>[] | undefined;
     get agents(): Agent<any, any>[];
     get observer(): AIGNEObserver | undefined;

package/lib/esm/aigne/context.js

@@ -10,7 +10,7 @@ import { AgentResponseProgressStream } from "../utils/event-stream.js";
 import { logger } from "../utils/logger.js";
 import { promiseWithResolvers } from "../utils/promise.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, mergeReadableStreams, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
-import { checkArguments, flat, isEmpty, isNil, omit, } from "../utils/type-utils.js";
+import { checkArguments, flat, isEmpty, isNil, omit, pick, } from "../utils/type-utils.js";
 import { MessageQueue, toMessagePayload, } from "./message-queue.js";
 import { newEmptyContextUsage } from "./usage.js";
 /**
@@ -340,11 +340,9 @@ class AIGNEContextShared {
                     }
                 }
                 const stream = await activeAgent.invoke(input, {
-                    hooks: options.hooks,
+                    ...pick(options, "hooks", "model", "imageModel", "caller"),
                     context,
                     streaming: true,
-                    model: options.model,
-                    imageModel: options.imageModel,
                 });
                 for await (const value of stream) {
                     if (isAgentResponseDelta(value)) {

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

@@ -8,6 +8,10 @@ export interface ContextUsage {
     creditPrefix?: "$" | "€" | "¥";
     agentCalls: number;
     duration: number;
+    /** Number of tokens written to cache (first time caching) */
+    cacheCreationInputTokens: number;
+    /** Number of tokens read from cache (cache hit) */
+    cacheReadInputTokens: number;
 }
 /**
  * @hidden

package/lib/esm/aigne/usage.js

@@ -8,6 +8,8 @@ export function newEmptyContextUsage() {
         aigneHubCredits: 0,
         agentCalls: 0,
         duration: 0,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 0,
     };
 }
 export function mergeContextUsage(usage, additional) {
@@ -21,4 +23,8 @@ export function mergeContextUsage(usage, additional) {
         usage.agentCalls += additional.agentCalls;
     if (additional.duration)
         usage.duration += additional.duration;
+    if (additional.cacheCreationInputTokens)
+        usage.cacheCreationInputTokens += additional.cacheCreationInputTokens;
+    if (additional.cacheReadInputTokens)
+        usage.cacheReadInputTokens += additional.cacheReadInputTokens;
 }

package/lib/esm/index.d.ts

@@ -13,6 +13,7 @@ export * from "./agents/user-agent.js";
 export * from "./agents/video-model.js";
 export * from "./aigne/index.js";
 export * from "./memory/index.js";
+export * from "./prompt/agent-session.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";
 export * from "./utils/json-utils.js";

package/lib/esm/index.js

@@ -13,6 +13,7 @@ export * from "./agents/user-agent.js";
 export * from "./agents/video-model.js";
 export * from "./aigne/index.js";
 export * from "./memory/index.js";
+export * from "./prompt/agent-session.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";
 export * from "./utils/json-utils.js";

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

@@ -1,9 +1,6 @@
 import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentClass, AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
-import { AIAgentToolChoice } from "../agents/ai-agent.js";
-import { type Role } from "../agents/chat-model.js";
-import { ProcessMode, type ReflectionMode } from "../agents/team-agent.js";
+import type { AgentHooks, TaskRenderMode } from "../agents/agent.js";
 import type { LoadOptions } from "./index.js";
 import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
@@ -45,7 +42,8 @@ export interface AFSContextSchema {
         presets?: Record<string, AFSContextPresetSchema>;
     };
 }
-export interface BaseAgentSchema {
+export interface AgentSchema {
+    type: string;
     name?: string;
     description?: string;
     model?: z.infer<typeof chatModelSchema>;
@@ -67,67 +65,11 @@ export interface BaseAgentSchema {
         context?: AFSContextSchema;
     });
     shareAFS?: boolean;
+    [key: string]: unknown;
 }
-export type Instructions = {
-    role: Exclude<Role, "tool">;
-    content: string;
-    path: string;
-}[];
-export interface AIAgentSchema extends BaseAgentSchema {
-    type: "ai";
-    instructions?: Instructions;
-    autoReorderSystemMessages?: boolean;
-    autoMergeSystemMessages?: boolean;
-    inputKey?: string;
-    inputFileKey?: string;
-    outputKey?: string;
-    outputFileKey?: string;
-    toolChoice?: AIAgentToolChoice;
-    toolCallsConcurrency?: number;
-    keepTextInToolUses?: boolean;
-}
-export interface ImageAgentSchema extends BaseAgentSchema {
-    type: "image";
-    instructions: Instructions;
-    inputFileKey?: string;
-}
-export interface MCPAgentSchema extends BaseAgentSchema {
-    type: "mcp";
-    url?: string;
-    command?: string;
-    args?: string[];
-}
-export interface TeamAgentSchema extends BaseAgentSchema {
-    type: "team";
-    mode?: ProcessMode;
-    iterateOn?: string;
-    concurrency?: number;
-    iterateWithPreviousOutput?: boolean;
-    includeAllStepsOutput?: boolean;
-    reflection?: Omit<ReflectionMode, "reviewer"> & {
-        reviewer: NestAgentSchema;
-    };
-}
-export interface TransformAgentSchema extends BaseAgentSchema {
-    type: "transform";
-    jsonata: string;
-}
-export interface FunctionAgentSchema extends BaseAgentSchema {
-    type: "function";
-    process: FunctionAgentFn;
-}
-export interface ThirdAgentSchema extends BaseAgentSchema {
-    agentClass?: AgentClass;
-    type: "";
-    [key: string]: any;
-}
-export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema | ThirdAgentSchema;
 export declare function parseAgentFile(path: string, data: any, options: LoadOptions): Promise<AgentSchema>;
 export declare function loadAgentFromYamlFile(path: string, options: LoadOptions): Promise<AgentSchema>;
-export declare const getInstructionsSchema: ({ filepath }: {
-    filepath: string;
-}) => ZodType<Instructions>;
-export declare const getAgentSchema: ({ filepath, options, }: {
+export declare const getAgentSchema: ({ filepath }: {
     filepath: string;
     options?: LoadOptions;
 }) => ZodType<AgentSchema, z.ZodTypeDef, AgentSchema>;