@aigne/core 1.72.0-beta.5 → 1.72.0-beta.7

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

@@ -9,7 +9,7 @@ import type { Memory, MemoryAgent } from "../memory/memory.js";
 import type { MemoryRecorderInput } from "../memory/recorder.js";
 import type { MemoryRetrieverInput } from "../memory/retriever.js";
 import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
-import type { ChatModel } from "./chat-model.js";
+import type { ChatModel, ChatModelInputMessage } from "./chat-model.js";
 import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import type { ImageModel } from "./image-model.js";
 import { type GetterSchema, type TransferAgentOutput } from "./types.js";
@@ -350,7 +350,20 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      */
     private disableEvents?;
     historyConfig?: {
-        disabled?: boolean;
+        /**
+         * Whether to enable history recording and injection
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Whether to record history entries, default to enabled when history is enabled
+         */
+        record?: boolean;
+        /**
+         * Whether to inject history entries into the context, default to enabled when history is enabled
+         */
+        inject?: boolean;
+        useOldMemory?: boolean;
         maxTokens?: number;
         maxItems?: number;
     };
@@ -455,7 +468,9 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @param options Invocation options
      * @returns Final processed output
      */
-    protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, options: AgentInvokeOptions): Promise<O>;
+    protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, { messages, ...options }: AgentInvokeOptions & {
+        messages?: ChatModelInputMessage[];
+    }): Promise<O>;
     /**
      * Process errors that occur during agent execution
      *
@@ -785,29 +800,29 @@ export interface AgentResponseProgress {
         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;
-        })[];
+        message: ChatModelInputMessage;
     }) & Omit<AgentEvent, "agent"> & {
         agent: {
             name: string;
         };
     };
 }
+export type AgentResponseProgressMessageItem = {
+    type: "text";
+    content: string;
+} | {
+    type: "thinking";
+    thoughts: string;
+} | {
+    type: "tool_use";
+    toolUseId: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+    content: unknown;
+};
 export declare function isAgentResponseProgress<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseProgress;
 /**
  * Creates a text delta for streaming responses

package/lib/dts/agents/chat-model.d.ts

@@ -225,6 +225,7 @@ export type ChatModelInputMessageContent = string | UnionContent[];
 export type TextContent = {
     type: "text";
     text: string;
+    isThinking?: boolean;
     /**
      * Cache control marker (only supported by Claude)
      *

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

@@ -1,6 +1,6 @@
 import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentHooks, TaskRenderMode } from "../agents/agent.js";
+import type { Agent, AgentHooks, TaskRenderMode } from "../agents/agent.js";
 import type { LoadOptions } from "./index.js";
 import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
@@ -65,6 +65,7 @@ export interface AgentSchema {
         context?: AFSContextSchema;
     });
     shareAFS?: boolean;
+    historyConfig?: Agent["historyConfig"];
     [key: string]: unknown;
 }
 export declare function parseAgentFile(path: string, data: any, options: LoadOptions): Promise<AgentSchema>;

package/lib/dts/prompt/context/afs/history.d.ts

@@ -1,5 +1,9 @@
+import type { AFSListOptions } from "@aigne/afs";
 import type { Agent } from "../../../agents/agent.js";
-export declare function getHistories(agent: Agent): Promise<{
+export declare function getHistories({ filter, agent, }: {
+    filter: AFSListOptions["filter"];
+    agent: Agent;
+}): Promise<{
     role: "user" | "agent";
     content: unknown;
 }[]>;

package/lib/dts/prompt/prompt-builder.d.ts

@@ -1,14 +1,16 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js";
+import { Agent, type Message } from "../agents/agent.js";
 import { type AIAgent } from "../agents/ai-agent.js";
-import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
+import { type ChatModel, type ChatModelInput, type ChatModelInputMessage } from "../agents/chat-model.js";
 import { type FileUnionContent } from "../agents/model.js";
+import type { Context } from "../aigne/context.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
     workingDir?: string;
 }
-export interface PromptBuildOptions extends Partial<Pick<AgentInvokeOptions, "context">> {
+export interface PromptBuildOptions {
+    context?: Context;
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
@@ -37,10 +39,12 @@ export declare class PromptBuilder {
     }>;
     private getTemplateVariables;
     private buildMessages;
-    getHistories(options: PromptBuildOptions): Promise<{
-        role: "user" | "agent";
-        content: unknown;
-    }[]>;
+    protected deprecatedMemories(message: string | undefined, options: PromptBuildOptions): Promise<ChatModelInputMessage[]>;
+    getHistories({ agentId, userId, sessionId, ...options }: PromptBuildOptions & {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    }): Promise<ChatModelInputMessage[]>;
     private refineMessages;
     private convertMemoriesToMessages;
     private buildResponseFormat;

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

@@ -9,7 +9,7 @@ import type { Memory, MemoryAgent } from "../memory/memory.js";
 import type { MemoryRecorderInput } from "../memory/recorder.js";
 import type { MemoryRetrieverInput } from "../memory/retriever.js";
 import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
-import type { ChatModel } from "./chat-model.js";
+import type { ChatModel, ChatModelInputMessage } from "./chat-model.js";
 import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import type { ImageModel } from "./image-model.js";
 import { type GetterSchema, type TransferAgentOutput } from "./types.js";
@@ -350,7 +350,20 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      */
     private disableEvents?;
     historyConfig?: {
-        disabled?: boolean;
+        /**
+         * Whether to enable history recording and injection
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Whether to record history entries, default to enabled when history is enabled
+         */
+        record?: boolean;
+        /**
+         * Whether to inject history entries into the context, default to enabled when history is enabled
+         */
+        inject?: boolean;
+        useOldMemory?: boolean;
         maxTokens?: number;
         maxItems?: number;
     };
@@ -455,7 +468,9 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @param options Invocation options
      * @returns Final processed output
      */
-    protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, options: AgentInvokeOptions): Promise<O>;
+    protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, { messages, ...options }: AgentInvokeOptions & {
+        messages?: ChatModelInputMessage[];
+    }): Promise<O>;
     /**
      * Process errors that occur during agent execution
      *
@@ -785,29 +800,29 @@ export interface AgentResponseProgress {
         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;
-        })[];
+        message: ChatModelInputMessage;
     }) & Omit<AgentEvent, "agent"> & {
         agent: {
             name: string;
         };
     };
 }
+export type AgentResponseProgressMessageItem = {
+    type: "text";
+    content: string;
+} | {
+    type: "thinking";
+    thoughts: string;
+} | {
+    type: "tool_use";
+    toolUseId: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+    content: unknown;
+};
 export declare function isAgentResponseProgress<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseProgress;
 /**
  * Creates a text delta for streaming responses

package/lib/esm/agents/agent.js

@@ -415,11 +415,15 @@ export class Agent {
                     : isAsyncGenerator(response)
                         ? asyncGeneratorToReadableStream(response)
                         : objectToAgentResponseStream(response);
+                const messages = [];
                 for await (const chunk of stream) {
                     mergeAgentResponseChunk(output, chunk);
                     yield chunk;
+                    if (isAgentResponseProgress(chunk) && chunk.progress.event === "message") {
+                        messages.push(chunk.progress.message);
+                    }
                 }
-                let result = await this.processAgentOutput(input, output, options);
+                let result = await this.processAgentOutput(input, output, { ...options, messages });
                 if (attempt > 0) {
                     result = { ...result, $meta: { ...result.$meta, retries: attempt } };
                 }
@@ -516,7 +520,7 @@ export class Agent {
      * @param options Invocation options
      * @returns Final processed output
      */
-    async processAgentOutput(input, output, options) {
+    async processAgentOutput(input, output, { messages, ...options }) {
         const { context } = options;
         if (!isRecord(output)) {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
@@ -528,8 +532,17 @@ export class Agent {
         const o = await this.callHooks(["onSuccess", "onEnd"], { input, output: finalOutput }, options);
         if (o?.output)
             finalOutput = o.output;
-        if (this.historyConfig?.disabled !== true)
-            this.afs?.emit("agentSucceed", { input, output: finalOutput });
+        if (this.historyConfig?.record === true ||
+            (this.historyConfig?.record !== false && this.historyConfig?.enabled)) {
+            this.afs?.emit("agentSucceed", {
+                agentId: this.name,
+                userId: context.userContext.userId,
+                sessionId: context.userContext.sessionId,
+                input,
+                output: finalOutput,
+                messages,
+            });
+        }
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
         return finalOutput;

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

@@ -313,8 +313,10 @@ export class AIAgent extends Agent {
             yield {
                 progress: {
                     event: "message",
-                    role: "user",
-                    message: [{ type: "text", content: inputMessage }],
+                    message: {
+                        role: "user",
+                        content: [{ type: "text", text: inputMessage }],
+                    },
                 },
             };
         }
@@ -343,15 +345,22 @@ export class AIAgent extends Agent {
                 }
             }
             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 (text || thoughts) {
+                const content = [];
+                if (thoughts) {
+                    content.push({ type: "text", text: thoughts, isThinking: true });
+                }
+                if (text) {
+                    content.push({ type: "text", text });
+                }
+                if (content.length) {
+                    yield {
+                        progress: {
+                            event: "message",
+                            message: { role: "agent", content },
+                        },
+                    };
+                }
             }
             if (toolCalls?.length) {
                 if (this.keepTextInToolUses !== true) {
@@ -383,25 +392,14 @@ export class AIAgent extends Agent {
                         queue.killAndDrain();
                     }
                 }, this.toolCallsConcurrency || 1);
+                yield {
+                    progress: { event: "message", message: { role: "agent", toolCalls } },
+                };
                 // Execute tools
                 for (const call of toolCalls) {
                     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();
@@ -413,14 +411,11 @@ export class AIAgent extends Agent {
                         yield {
                             progress: {
                                 event: "message",
-                                role: "agent",
-                                message: [
-                                    {
-                                        type: "tool_result",
-                                        toolUseId: call.id,
-                                        content: output,
-                                    },
-                                ],
+                                message: {
+                                    role: "tool",
+                                    toolCallId: call.id,
+                                    content: JSON.stringify(output),
+                                },
                             },
                         };
                     }
@@ -444,11 +439,6 @@ 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;
         }
     }

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

@@ -225,6 +225,7 @@ export type ChatModelInputMessageContent = string | UnionContent[];
 export type TextContent = {
     type: "text";
     text: string;
+    isThinking?: boolean;
     /**
      * Cache control marker (only supported by Claude)
      *

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

@@ -340,15 +340,29 @@ const modelOptionsSchemaProperties = {
         z.literal("medium"),
         z.literal("high"),
     ]),
+    cacheConfig: z.object({
+        enabled: optionalize(z.boolean().default(true)),
+        ttl: optionalize(z.union([z.literal("5m"), z.literal("1h"), z.number()]).default("5m")),
+        strategy: optionalize(z.union([z.literal("auto"), z.literal("manual")]).default("auto")),
+        autoBreakpoints: optionalize(z.object({
+            tools: optionalize(z.boolean().default(true)),
+            system: optionalize(z.boolean().default(true)),
+            lastMessage: optionalize(z.boolean().default(false)),
+        })),
+    }),
 };
-const modelOptionsSchema = z.object(Object.fromEntries(Object.entries(modelOptionsSchemaProperties).map(([key, schema]) => [
+const modelOptionsSchema = z
+    .object(Object.fromEntries(Object.entries(modelOptionsSchemaProperties).map(([key, schema]) => [
     key,
     optionalize(schema),
-])));
-const modelOptionsWithGetterSchema = z.object(Object.fromEntries(Object.entries(modelOptionsSchemaProperties).map(([key, schema]) => [
+])))
+    .passthrough();
+const modelOptionsWithGetterSchema = z
+    .object(Object.fromEntries(Object.entries(modelOptionsSchemaProperties).map(([key, schema]) => [
     key,
     optionalize(getterSchema(schema)),
-])));
+])))
+    .passthrough();
 const chatModelOptionsSchema = agentOptionsSchema.extend({
     model: optionalize(z.string()),
     modelOptions: optionalize(modelOptionsWithGetterSchema),

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

@@ -1,6 +1,6 @@
 import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentHooks, TaskRenderMode } from "../agents/agent.js";
+import type { Agent, AgentHooks, TaskRenderMode } from "../agents/agent.js";
 import type { LoadOptions } from "./index.js";
 import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
@@ -65,6 +65,7 @@ export interface AgentSchema {
         context?: AFSContextSchema;
     });
     shareAFS?: boolean;
+    historyConfig?: Agent["historyConfig"];
     [key: string]: unknown;
 }
 export declare function parseAgentFile(path: string, data: any, options: LoadOptions): Promise<AgentSchema>;

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

@@ -95,6 +95,14 @@ export const getAgentSchema = ({ filepath }) => {
                 })),
             ])),
             shareAFS: optionalize(z.boolean()),
+            historyConfig: camelizeSchema(optionalize(z.object({
+                enabled: optionalize(z.boolean()),
+                record: optionalize(z.boolean()),
+                inject: optionalize(z.boolean()),
+                use_old_memory: optionalize(z.boolean()),
+                maxTokens: optionalize(z.number().int().positive()),
+                maxItems: optionalize(z.number().int().positive()),
+            }))),
         });
         return camelizeSchema(baseAgentSchema.passthrough());
     });

package/lib/esm/prompt/context/afs/history.d.ts

@@ -1,5 +1,9 @@
+import type { AFSListOptions } from "@aigne/afs";
 import type { Agent } from "../../../agents/agent.js";
-export declare function getHistories(agent: Agent): Promise<{
+export declare function getHistories({ filter, agent, }: {
+    filter: AFSListOptions["filter"];
+    agent: Agent;
+}): Promise<{
     role: "user" | "agent";
     content: unknown;
 }[]>;

package/lib/esm/prompt/context/afs/history.js

@@ -1,6 +1,6 @@
 import { AFSHistory } from "@aigne/afs-history";
 import { isNonNullable } from "../../../utils/type-utils.js";
-export async function getHistories(agent) {
+export async function getHistories({ filter, agent, }) {
     const afs = agent?.afs;
     if (!afs)
         return [];
@@ -8,6 +8,7 @@ export async function getHistories(agent) {
     if (!historyModule)
         return [];
     const history = (await afs.list(historyModule.path, {
+        filter,
         limit: agent.historyConfig?.maxItems || 10,
         orderBy: [["createdAt", "desc"]],
     })).data;

package/lib/esm/prompt/context/afs/index.js

@@ -17,7 +17,14 @@ export function createAFSContext(agent, context) {
         get histories() {
             if (!agent)
                 return Promise.resolve([]);
-            return getHistories(agent);
+            return getHistories({
+                agent,
+                filter: {
+                    agentId: agent.name,
+                    userId: context?.userContext.userId,
+                    sessionId: context?.userContext.sessionId,
+                },
+            });
         },
         get skills() {
             const afs = agent?.afs;

package/lib/esm/prompt/prompt-builder.d.ts

@@ -1,14 +1,16 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js";
+import { Agent, type Message } from "../agents/agent.js";
 import { type AIAgent } from "../agents/ai-agent.js";
-import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
+import { type ChatModel, type ChatModelInput, type ChatModelInputMessage } from "../agents/chat-model.js";
 import { type FileUnionContent } from "../agents/model.js";
+import type { Context } from "../aigne/context.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
     workingDir?: string;
 }
-export interface PromptBuildOptions extends Partial<Pick<AgentInvokeOptions, "context">> {
+export interface PromptBuildOptions {
+    context?: Context;
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
@@ -37,10 +39,12 @@ export declare class PromptBuilder {
     }>;
     private getTemplateVariables;
     private buildMessages;
-    getHistories(options: PromptBuildOptions): Promise<{
-        role: "user" | "agent";
-        content: unknown;
-    }[]>;
+    protected deprecatedMemories(message: string | undefined, options: PromptBuildOptions): Promise<ChatModelInputMessage[]>;
+    getHistories({ agentId, userId, sessionId, ...options }: PromptBuildOptions & {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    }): Promise<ChatModelInputMessage[]>;
     private refineMessages;
     private convertMemoriesToMessages;
     private buildResponseFormat;