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

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

@@ -5,9 +5,8 @@ import type { ChatModel } from "../agents/chat-model.js";
 import type { ImageModel } from "../agents/image-model.js";
 import type { AIGNEOptions } from "../aigne/aigne.js";
 import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
-import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
-import { type Instructions, loadAgentFromYamlFile, type NestAgentSchema } from "./agent-yaml.js";
+import { loadAgentFromYamlFile, type NestAgentSchema } from "./agent-yaml.js";
 export interface LoadOptions {
     memories?: {
         new (parameters?: MemoryAgentOptions): MemoryAgent;
@@ -19,7 +18,10 @@ export interface LoadOptions {
         availableModules?: {
             module: string;
             alias?: string[];
-            create: (options?: Record<string, any>) => PromiseOrValue<AFSModule>;
+            load: (options: {
+                filepath: string;
+                parsed?: object;
+            }) => PromiseOrValue<AFSModule>;
         }[];
     };
     aigne?: z.infer<typeof aigneFileSchema>;
@@ -27,6 +29,9 @@ export interface LoadOptions {
         parent?: string;
     }) => Promise<any>;
 }
+export interface AgentLoadOptions extends LoadOptions {
+    loadNestAgent: (path: string, agent: NestAgentSchema, options: LoadOptions, agentOptions?: AgentOptions<any, any> & Record<string, unknown>) => Promise<Agent>;
+}
 export declare function load(path: string, options?: LoadOptions): Promise<AIGNEOptions>;
 export declare function loadAgent(path: string, options: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;
 export declare function loadNestAgent(path: string, agent: NestAgentSchema, options: LoadOptions, agentOptions?: AgentOptions<any, any> & Record<string, unknown>): Promise<Agent>;
@@ -67,9 +72,9 @@ declare const aigneFileSchema: z.ZodObject<{
         } | undefined, z.ZodTypeDef, number | {
             $get: string;
         } | undefined>;
-        thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+        thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
-        } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+        } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined, z.ZodTypeDef, z.objectInputType<{
@@ -98,9 +103,9 @@ declare const aigneFileSchema: z.ZodObject<{
         } | undefined, z.ZodTypeDef, number | {
             $get: string;
         } | undefined>;
-        thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+        thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
-        } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+        } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined>;
@@ -132,6 +137,7 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined>;
 }, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
     model?: z.objectInputType<{
         model: ZodType<string | {
             $get: string;
@@ -158,13 +164,12 @@ declare const aigneFileSchema: z.ZodObject<{
         } | undefined, z.ZodTypeDef, number | {
             $get: string;
         } | undefined>;
-        thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+        thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
-        } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+        } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    name?: string | undefined;
     description?: string | undefined;
     imageModel?: z.objectInputType<{
         model: ZodType<string | {
@@ -183,6 +188,7 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined;
 }, {
+    name?: string | undefined;
     model?: z.objectInputType<{
         model: ZodType<string | {
             $get: string;
@@ -209,13 +215,12 @@ declare const aigneFileSchema: z.ZodObject<{
         } | undefined, z.ZodTypeDef, number | {
             $get: string;
         } | undefined>;
-        thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+        thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
-        } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+        } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    name?: string | undefined;
     description?: string | undefined;
     imageModel?: z.objectInputType<{
         model: ZodType<string | {
@@ -239,5 +244,4 @@ export declare function loadAIGNEFile(path: string): Promise<{
     rootDir: string;
 }>;
 export declare function findAIGNEFile(path: string): Promise<string>;
-export declare function instructionsToPromptBuilder(instructions: Instructions): PromptBuilder;
 export {};

package/lib/dts/loader/schema.d.ts

@@ -1,4 +1,6 @@
 import { type ZodType, z } from "zod";
+import { type Role } from "../agents/chat-model.js";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
 export declare const inputOutputSchema: ({ path }: {
     path: string;
 }) => z.ZodUnion<[ZodType<any, z.ZodTypeDef, any>, z.ZodEffects<z.ZodObject<{
@@ -55,9 +57,9 @@ declare const chatModelObjectSchema: z.ZodObject<{
     } | undefined, z.ZodTypeDef, number | {
         $get: string;
     } | undefined>;
-    thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+    thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
-    } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+    } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
     } | undefined>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
@@ -86,9 +88,9 @@ declare const chatModelObjectSchema: z.ZodObject<{
     } | undefined, z.ZodTypeDef, number | {
         $get: string;
     } | undefined>;
-    thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+    thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
-    } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+    } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
     } | undefined>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
@@ -117,9 +119,9 @@ declare const chatModelObjectSchema: z.ZodObject<{
     } | undefined, z.ZodTypeDef, number | {
         $get: string;
     } | undefined>;
-    thinkingEffort: ZodType<number | "high" | "medium" | "low" | "minimal" | {
+    thinkingEffort: ZodType<number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
-    } | undefined, z.ZodTypeDef, number | "high" | "medium" | "low" | "minimal" | {
+    } | undefined, z.ZodTypeDef, number | "high" | "low" | "medium" | "minimal" | {
         $get: string;
     } | undefined>;
 }, z.ZodTypeAny, "passthrough">>;
@@ -149,4 +151,17 @@ export declare function camelizeSchema<T extends ZodType>(schema: T, { shallow }
     shallow?: boolean;
 }): T;
 export declare function preprocessSchema<T extends ZodType>(fn: (data: unknown) => unknown, schema: T): T;
+export type Instructions = {
+    role: Exclude<Role, "tool">;
+    content: string;
+    path: string;
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h";
+    };
+}[];
+export declare const getInstructionsSchema: ({ filepath }: {
+    filepath: string;
+}) => ZodType<Instructions>;
+export declare function instructionsToPromptBuilder(instructions: Instructions | string): PromptBuilder;
 export {};

package/lib/dts/prompt/skills/afs/agent-skill/agent-skill.d.ts

@@ -0,0 +1,17 @@
+import { Agent, type AgentOptions, type Message } from "../../../../agents/agent.js";
+import type { Skill } from "./skill-loader.js";
+export interface SkillToolInput extends Message {
+    skill: string;
+    args?: string;
+}
+export interface SkillToolOutput extends Message {
+    result: string;
+}
+export interface SkillToolOptions extends AgentOptions<SkillToolInput, SkillToolOutput> {
+    agentSkills: Skill[];
+}
+export declare class AgentSkill extends Agent<SkillToolInput, SkillToolOutput> {
+    constructor(options: SkillToolOptions);
+    private agentSkills;
+    process(input: SkillToolInput): Promise<SkillToolOutput>;
+}

package/lib/dts/prompt/skills/afs/agent-skill/skill-loader.d.ts

@@ -0,0 +1,13 @@
+import type { AFS } from "@aigne/afs";
+import { AgentSkill } from "./agent-skill.js";
+export interface Skill {
+    path: string;
+    name: string;
+    description: string;
+    content: string;
+}
+export declare function loadSkill(path: string): Promise<Skill>;
+export declare function loadSkills(paths: string[]): Promise<Skill[]>;
+export declare function loadAgentSkillFromAFS({ afs, }: {
+    afs: AFS;
+}): Promise<AgentSkill | undefined>;

package/lib/dts/prompt/template.d.ts

@@ -27,35 +27,38 @@ export declare class ChatMessageTemplate {
     content?: ChatModelInputMessage["content"];
     name?: string | undefined;
     options?: FormatOptions | undefined;
-    constructor(role: "system" | "user" | "agent" | "tool", content?: ChatModelInputMessage["content"], name?: string | undefined, options?: FormatOptions | undefined);
+    cacheControl?: ChatModelInputMessage["cacheControl"];
+    constructor(role: "system" | "user" | "agent" | "tool", content?: ChatModelInputMessage["content"], name?: string | undefined, options?: FormatOptions | undefined, cacheControl?: ChatModelInputMessage["cacheControl"]);
     format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<ChatModelInputMessage>;
 }
 export declare class SystemMessageTemplate extends ChatMessageTemplate {
-    static from(content: string, name?: string, options?: FormatOptions): SystemMessageTemplate;
+    static from(content: string, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): SystemMessageTemplate;
 }
 export declare class UserMessageTemplate extends ChatMessageTemplate {
-    static from(template: ChatModelInputMessageContent, name?: string, options?: FormatOptions): UserMessageTemplate;
+    static from(template: ChatModelInputMessageContent, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): UserMessageTemplate;
 }
 export declare class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls?: ChatModelOutputToolCall[] | undefined;
-    static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string, options?: FormatOptions): AgentMessageTemplate;
-    constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string, options?: FormatOptions);
+    static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): AgentMessageTemplate;
+    constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]);
     format(_variables?: Record<string, unknown>, _options?: FormatOptions): Promise<{
-        role: "agent" | "system" | "user" | "tool";
+        role: "system" | "user" | "agent" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCalls: ChatModelOutputToolCall[] | undefined;
+        cacheControl: import("../index.js").CacheControl | undefined;
     }>;
 }
 export declare class ToolMessageTemplate extends ChatMessageTemplate {
     toolCallId: string;
-    static from(content: object | string, toolCallId: string, name?: string, options?: FormatOptions): ToolMessageTemplate;
-    constructor(content: object | string, toolCallId: string, name?: string, options?: FormatOptions);
+    static from(content: object | string, toolCallId: string, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): ToolMessageTemplate;
+    constructor(content: object | string, toolCallId: string, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]);
     format(_variables?: Record<string, unknown>, _options?: FormatOptions): Promise<{
-        role: "agent" | "system" | "user" | "tool";
+        role: "system" | "user" | "agent" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCallId: string;
+        cacheControl: import("../index.js").CacheControl | undefined;
     }>;
 }
 export declare class ChatMessagesTemplate {
@@ -69,25 +72,61 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
     role: z.ZodLiteral<"system">;
     content: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"5m">, z.ZodLiteral<"1h">]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
-    role: "system";
     content: string;
+    role: "system";
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }, {
-    role: "system";
     content: string;
+    role: "system";
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"user">;
     content: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"5m">, z.ZodLiteral<"1h">]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
-    role: "user";
     content: string;
+    role: "user";
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }, {
-    role: "user";
     content: string;
+    role: "user";
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"agent">;
@@ -121,10 +160,23 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         id: string;
     }>, "many">>;
     name: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"5m">, z.ZodLiteral<"1h">]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     role: "agent";
-    name?: string | undefined;
     content?: string | undefined;
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     toolCalls?: {
         function: {
             name: string;
@@ -133,10 +185,14 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         type: "function";
         id: string;
     }[] | undefined;
+    name?: string | undefined;
 }, {
     role: "agent";
-    name?: string | undefined;
     content?: string | undefined;
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     toolCalls?: {
         function: {
             name: string;
@@ -145,20 +201,39 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         type: "function";
         id: string;
     }[] | undefined;
+    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"tool">;
     content: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, string, string | Record<string, unknown>>;
     toolCallId: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"5m">, z.ZodLiteral<"1h">]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }, {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
-    role: "tool";
     content: string;
+    role: "tool";
     toolCallId: string;
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }, {
-    role: "tool";
     content: string | Record<string, unknown>;
+    role: "tool";
     toolCallId: string;
+    cacheControl?: {
+        type: "ephemeral";
+        ttl?: "5m" | "1h" | undefined;
+    } | undefined;
     name?: string | undefined;
 }>]>;
 export declare function safeParseChatMessages(messages: unknown): ChatMessageTemplate[] | undefined;

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

@@ -1,7 +1,7 @@
 import { AFS, type AFSExecOptions, type AFSExecResult, type AFSListOptions, type AFSListResult, type AFSModule, type AFSOptions, type AFSReadResult, type AFSSearchOptions } from "@aigne/afs";
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import type * as prompts from "@inquirer/prompts";
-import { type ZodObject, type ZodType } from "zod";
+import { type ZodObject, type ZodType, z } from "zod";
 import type { AgentEvent, Context, UserContext } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { ContextUsage } from "../aigne/usage.js";
@@ -783,6 +783,25 @@ export interface AgentResponseProgress {
     } | {
         event: "agentFailed";
         error: Error;
+    } | {
+        event: "message";
+        role: "user" | "agent";
+        message: ({
+            type: "text";
+            content: string;
+        } | {
+            type: "thinking";
+            thoughts: string;
+        } | {
+            type: "tool_use";
+            toolUseId: string;
+            name: string;
+            input: unknown;
+        } | {
+            type: "tool_result";
+            toolUseId: string;
+            content: unknown;
+        })[];
     }) & Omit<AgentEvent, "agent"> & {
         agent: {
             name: string;
@@ -870,6 +889,17 @@ export interface FunctionAgentOptions<I extends Message = Message, O extends Mes
  */
 export declare class FunctionAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     tag: string;
+    static schema(): ZodObject<{
+        process: ZodType<FunctionAgentFn>;
+    }, "strip", z.ZodTypeAny, {
+        process: FunctionAgentFn<any, any, FunctionAgent<any, any>>;
+    }, {
+        process: FunctionAgentFn<any, any, FunctionAgent<any, any>>;
+    }>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     /**
      * Create a function agent from a function or options
      *

package/lib/esm/agents/agent.js

@@ -5,6 +5,7 @@ import nunjucks from "nunjucks";
 import { joinURL } from "ufo";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { codeToFunctionAgentFn } from "../loader/function-agent.js";
 import { sortHooks } from "../utils/agent-utils.js";
 import { getZodObjectKeys, isZodSchema } from "../utils/json-schema.js";
 import { logger } from "../utils/logger.js";
@@ -824,6 +825,18 @@ function checkAgentInputOutputSchema(schema) {
  */
 export class FunctionAgent extends Agent {
     tag = "FunctionAgent";
+    static schema() {
+        return z.object({
+            process: z.preprocess((v) => (typeof v === "string" ? codeToFunctionAgentFn(v) : v), z.custom()),
+        });
+    }
+    static async load(options) {
+        const valid = await FunctionAgent.schema().parseAsync(options.parsed);
+        return new FunctionAgent({
+            ...options.parsed,
+            process: valid.process,
+        });
+    }
     /**
      * Create a function agent from a function or options
      *

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

@@ -188,6 +188,13 @@ export declare const aiAgentOptionsSchema: ZodObject<{
  */
 export declare class AIAgent<I extends Message = any, O extends Message = any> extends Agent<I, O> {
     tag: string;
+    static schema<T>({ filepath }: {
+        filepath: string;
+    }): ZodType<T>;
+    static load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     /**
      * Create an AIAgent with the specified options
      *

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

@@ -1,8 +1,10 @@
 import { z } from "zod";
+import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize, } from "../loader/schema.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
 import * as fastq from "../utils/queue.js";
+import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, isAgentResponseDelta, } from "./agent.js";
@@ -84,6 +86,32 @@ export const aiAgentOptionsSchema = agentOptionsSchema.extend({
  */
 export class AIAgent extends Agent {
     tag = "AIAgent";
+    static schema({ filepath }) {
+        const instructionsSchema = getInstructionsSchema({ filepath });
+        return camelizeSchema(z.object({
+            instructions: optionalize(instructionsSchema),
+            autoReorderSystemMessages: optionalize(z.boolean()),
+            autoMergeSystemMessages: optionalize(z.boolean()),
+            inputKey: optionalize(z.string()),
+            outputKey: optionalize(z.string()),
+            inputFileKey: optionalize(z.string()),
+            outputFileKey: optionalize(z.string()),
+            toolChoice: optionalize(z.nativeEnum(AIAgentToolChoice)),
+            toolCallsConcurrency: optionalize(z.number().int().min(0)),
+            keepTextInToolUses: optionalize(z.boolean()),
+            catchToolsError: optionalize(z.boolean()),
+            structuredStreamMode: optionalize(z.boolean()),
+        }));
+    }
+    static async load(options) {
+        const schema = AIAgent.schema(options);
+        const valid = await schema.parseAsync(options.parsed);
+        return new AIAgent({
+            ...options.parsed,
+            ...valid,
+            instructions: valid.instructions && instructionsToPromptBuilder(valid.instructions),
+        });
+    }
     /**
      * Create an AIAgent with the specified options
      *
@@ -280,6 +308,16 @@ export class AIAgent extends Agent {
         }
         const toolCallMessages = [];
         const outputKey = this.outputKey;
+        const inputMessage = this.inputKey ? input[this.inputKey] : undefined;
+        if (inputMessage) {
+            yield {
+                progress: {
+                    event: "message",
+                    role: "user",
+                    message: [{ type: "text", content: inputMessage }],
+                },
+            };
+        }
         for (;;) {
             const modelOutput = {};
             let stream = await this.invokeChildAgent(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { ...options, streaming: true });
@@ -289,12 +327,12 @@ export class AIAgent extends Agent {
             }
             let isTextIgnored = false;
             for await (const value of stream) {
+                mergeAgentResponseChunk(modelOutput, value);
                 if (isAgentResponseDelta(value)) {
                     if (!isTextIgnored && value.delta.text?.text) {
                         yield { delta: { text: { [outputKey]: value.delta.text.text } } };
                     }
                     if (value.delta.json) {
-                        Object.assign(modelOutput, value.delta.json);
                         if (this.structuredStreamMode) {
                             yield { delta: { json: value.delta.json.json } };
                             if (!isTextIgnored && modelOutput.json && this.ignoreTextOfStructuredStreamMode) {
@@ -304,13 +342,23 @@ export class AIAgent extends Agent {
                     }
                 }
             }
-            const { toolCalls, json, text, files } = modelOutput;
+            const { toolCalls, json, text, thoughts, files } = modelOutput;
+            if (text) {
+                yield {
+                    progress: { event: "message", role: "agent", message: [{ type: "text", content: text }] },
+                };
+            }
+            if (thoughts) {
+                yield {
+                    progress: { event: "message", role: "agent", message: [{ type: "thinking", thoughts }] },
+                };
+            }
             if (toolCalls?.length) {
                 if (this.keepTextInToolUses !== true) {
                     yield { delta: { json: { [outputKey]: "" } } };
                 }
                 else {
-                    yield { delta: { text: { [outputKey]: "\n" } } };
+                    yield { delta: { text: { [outputKey]: "\n\n" } } };
                 }
                 const executedToolCalls = [];
                 let error;
@@ -340,6 +388,20 @@ export class AIAgent extends Agent {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
+                    yield {
+                        progress: {
+                            event: "message",
+                            role: "agent",
+                            message: [
+                                {
+                                    type: "tool_use",
+                                    name: call.function.name,
+                                    input: call.function.arguments,
+                                    toolUseId: call.id,
+                                },
+                            ],
+                        },
+                    };
                     queue.push({ tool, call });
                 }
                 await queue.drained();
@@ -347,6 +409,21 @@ export class AIAgent extends Agent {
                     throw error;
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
+                    for (const { call, output } of executedToolCalls) {
+                        yield {
+                            progress: {
+                                event: "message",
+                                role: "agent",
+                                message: [
+                                    {
+                                        type: "tool_result",
+                                        toolUseId: call.id,
+                                        content: output,
+                                    },
+                                ],
+                            },
+                        };
+                    }
                     const transferOutput = executedToolCalls.find((i) => isTransferAgentOutput(i.output))?.output;
                     if (transferOutput)
                         return transferOutput;
@@ -367,6 +444,11 @@ export class AIAgent extends Agent {
             if (!isEmpty(result)) {
                 yield { delta: { json: result } };
             }
+            if (text) {
+                yield {
+                    progress: { event: "message", role: "agent", message: [{ type: "text", content: text }] },
+                };
+            }
             return;
         }
     }