@aigne/core 1.72.0-beta.6 → 1.72.0-beta.8

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

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

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

@@ -1,14 +1,17 @@
 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, ChatModelInput, ChatModelInputMessage } from "../agents/chat-model.js";
 import { type FileUnionContent } from "../agents/model.js";
+import type { Context } from "../aigne/context.js";
+import { AgentSession } from "./agent-session.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;
@@ -26,7 +29,9 @@ export declare class PromptBuilder {
     instructions?: string | ChatMessagesTemplate;
     workingDir?: string;
     copy(): PromptBuilder;
-    build(options: PromptBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<Omit<ChatModelInput, "messages"> & {
+        session: AgentSession;
+        userMessage: ChatModelInputMessage;
         toolAgents?: Agent[];
     }>;
     buildPrompt(options: Pick<PromptBuildOptions, "input" | "context"> & {
@@ -37,11 +42,8 @@ export declare class PromptBuilder {
     }>;
     private getTemplateVariables;
     private buildMessages;
-    getHistories(options: PromptBuildOptions): Promise<{
-        role: "user" | "agent";
-        content: unknown;
-    }[]>;
-    private refineMessages;
+    private mergeMessages;
+    protected deprecatedMemories(message: string | undefined, options: PromptBuildOptions): Promise<ChatModelInputMessage[]>;
     private convertMemoriesToMessages;
     private buildResponseFormat;
     private buildTools;

package/lib/cjs/prompt/prompt-builder.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptBuilder = void 0;
-const afs_history_1 = require("@aigne/afs-history");
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
+const uuid_1 = require("@aigne/uuid");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
@@ -12,8 +12,8 @@ const model_js_1 = require("../agents/model.js");
 const schema_js_1 = require("../loader/schema.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
+const agent_session_js_1 = require("./agent-session.js");
 const index_js_2 = require("./context/index.js");
-const afs_builtin_prompt_js_1 = require("./prompts/afs-builtin-prompt.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const structured_stream_instructions_js_1 = require("./prompts/structured-stream-instructions.js");
 const index_js_3 = require("./skills/afs/index.js");
@@ -73,13 +73,28 @@ class PromptBuilder {
         });
     }
     async build(options) {
+        let { userId, sessionId } = options.context?.userContext || {};
+        const agentId = options.agent?.name;
+        const afs = options.agent?.afs;
+        sessionId ||= (0, uuid_1.v7)();
+        const session = new agent_session_js_1.AgentSession({
+            agentId,
+            userId,
+            sessionId,
+            afs,
+            compact: options.agent?.compact,
+        });
+        const { systemMessage, userMessage } = await this.buildMessages(options);
+        if (systemMessage)
+            await session.setSystemMessages(systemMessage);
         return {
-            messages: await this.buildMessages(options),
+            userMessage,
             responseFormat: options.agent?.structuredStreamMode
                 ? undefined
                 : this.buildResponseFormat(options),
             outputFileType: options.agent?.outputFileType,
             ...(await this.buildTools(options)),
+            session,
         };
     }
     async buildPrompt(options) {
@@ -102,84 +117,41 @@ class PromptBuilder {
         const { input } = options;
         const inputKey = options.agent?.inputKey;
         const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
-        const [messages, otherCustomMessages] = (0, type_utils_js_1.partition)((await (typeof this.instructions === "string"
+        const template = typeof this.instructions === "string"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
-            : this.instructions)?.format(this.getTemplateVariables(options), { workingDir: this.workingDir })) ?? [], (i) => i.role === "system");
+            : this.instructions;
+        const [systemMessages, userMessages] = (0, type_utils_js_1.partition)((await template?.format(this.getTemplateVariables(options), {
+            workingDir: this.workingDir,
+        })) ?? [], (i) => i.role === "system");
         const inputFileKey = options.agent?.inputFileKey;
         const files = (0, type_utils_js_1.flat)(inputFileKey
             ? (0, type_utils_js_1.checkArguments)("Check input files", (0, schema_js_1.optionalize)(model_js_1.fileUnionContentsSchema), input?.[inputFileKey])
             : null);
-        const memories = [];
-        if (options.agent && options.context) {
-            memories.push(...(await options.agent.retrieveMemories({ search: message }, { context: options.context })));
-        }
-        if (options.agent?.useMemoriesFromContext && options.context?.memories?.length) {
-            memories.push(...options.context.memories);
-        }
-        const afs = options.agent?.afs;
-        if (afs && options.agent?.historyConfig?.disabled !== true) {
-            const historyModule = (await afs.listModules()).find((m) => m.module instanceof afs_history_1.AFSHistory);
-            if (historyModule) {
-                const history = await afs.list(historyModule.path, {
-                    limit: options.agent?.maxRetrieveMemoryCount || 10,
-                    orderBy: [["createdAt", "desc"]],
-                });
-                memories.push(...history.data
-                    .reverse()
-                    .filter((i) => (0, type_utils_js_1.isNonNullable)(i.content)));
-                if (message) {
-                    const result = (await afs.search("/", message)).data;
-                    const ms = result
-                        .map((entry) => {
-                        if (entry.metadata?.execute)
-                            return null;
-                        const content = entry.content || entry.summary;
-                        if (!content)
-                            return null;
-                        return {
-                            content,
-                            description: entry.description,
-                        };
-                    })
-                        .filter(type_utils_js_1.isNonNullable);
-                    memories.push(...ms);
-                    const executable = result.filter((i) => !!i.metadata?.execute);
-                    if (executable.length) {
-                        messages.push({
-                            role: "system",
-                            content: await template_js_1.PromptTemplate.from(afs_builtin_prompt_js_1.AFS_EXECUTABLE_TOOLS_PROMPT_TEMPLATE).format({
-                                tools: executable.map((entry) => ({
-                                    path: entry.path,
-                                    name: entry.metadata.execute.name,
-                                    description: entry.metadata.execute.description,
-                                    inputSchema: entry.metadata.execute.inputSchema,
-                                    outputSchema: entry.metadata.execute.outputSchema,
-                                })),
-                            }),
-                        });
-                    }
-                }
-            }
+        if (options.agent?.memories.length || options.context?.memories.length) {
+            const deprecatedMemories = await this.deprecatedMemories(message, options);
+            if (deprecatedMemories.length)
+                systemMessages.push(...deprecatedMemories);
         }
-        if (memories.length)
-            messages.push(...(await this.convertMemoriesToMessages(memories, options)));
         // if the agent is using structured stream mode, add the instructions
         const { structuredStreamMode, outputSchema } = options.agent || {};
         if (structuredStreamMode && outputSchema) {
             const instructions = options.agent?.customStructuredStreamInstructions?.instructions ||
                 PromptBuilder.from(structured_stream_instructions_js_1.STRUCTURED_STREAM_INSTRUCTIONS.instructions);
-            messages.push(...(await instructions.buildMessages({
-                input: {
-                    ...input,
-                    outputJsonSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(outputSchema),
-                },
-            })));
+            systemMessages.push({
+                role: "system",
+                content: (await instructions.buildPrompt({
+                    input: {
+                        ...input,
+                        outputJsonSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(outputSchema),
+                    },
+                })).prompt,
+            });
         }
         if (message || files.length) {
             const content = [];
             if (message &&
-                // avoid duplicate user messages: developer may have already included the message in the custom user messages
-                !otherCustomMessages.some((i) => i.role === "user" &&
+                // avoid duplicate user messages: developer may have already included the message in the messages
+                !userMessages.some((i) => i.role === "user" &&
                     (typeof i.content === "string"
                         ? i.content.includes(message)
                         : i.content?.some((c) => c.type === "text" && c.text.includes(message))))) {
@@ -188,63 +160,51 @@ class PromptBuilder {
             if (files.length)
                 content.push(...files);
             if (content.length) {
-                messages.push({ role: "user", content });
+                userMessages.push({ role: "user", content });
             }
         }
-        messages.push(...otherCustomMessages);
-        return this.refineMessages(options, messages);
+        let systemMessage = this.mergeMessages(systemMessages, "system");
+        if (!systemMessage.content?.length)
+            systemMessage = undefined;
+        let userMessage = this.mergeMessages(userMessages, "user");
+        if (!userMessage.content?.length) {
+            userMessage = { role: "user", content: systemMessage?.content };
+            systemMessage = undefined;
+        }
+        if (!userMessage.content?.length)
+            throw new Error("User message cannot be empty.");
+        return {
+            systemMessage,
+            userMessage,
+        };
     }
-    async getHistories(options) {
-        const { agent } = options;
-        const afs = agent?.afs;
-        if (!afs)
-            return [];
-        const historyModule = (await afs.listModules()).find((m) => m.module instanceof afs_history_1.AFSHistory);
-        if (!historyModule)
-            return [];
-        const history = (await afs.list(historyModule.path, {
-            limit: agent.historyConfig?.maxItems || 10,
-            orderBy: [["createdAt", "desc"]],
-        })).data;
-        return history
-            .reverse()
-            .map((i) => {
-            if (!i.content)
-                return;
-            const { input, output } = i.content;
-            if (!input || !output)
-                return;
-            return [
-                { role: "user", content: input },
-                { role: "agent", content: output },
-            ];
-        })
-            .filter(type_utils_js_1.isNonNullable)
-            .flat();
+    mergeMessages(messages, role) {
+        const content = [];
+        for (const message of messages) {
+            if (typeof message.content === "string") {
+                content.push({ type: "text", text: message.content });
+            }
+            else if (Array.isArray(message.content)) {
+                content.push(...message.content);
+            }
+            else if (message.content) {
+                throw new Error(`Unsupported message content type: ${typeof message.content}`);
+            }
+        }
+        return { role, content };
     }
-    refineMessages(options, messages) {
-        const { autoReorderSystemMessages, autoMergeSystemMessages } = options.agent ?? {};
-        if (!autoReorderSystemMessages && !autoMergeSystemMessages)
-            return messages;
-        const [systemMessages, otherMessages] = (0, type_utils_js_1.partition)(messages, (m) => m.role === "system");
-        if (!autoMergeSystemMessages) {
-            return systemMessages.concat(otherMessages);
+    async deprecatedMemories(message, options) {
+        const messages = [];
+        const memories = [];
+        if (options.agent && options.context) {
+            memories.push(...(await options.agent.retrieveMemories({ search: message }, { context: options.context })));
         }
-        const result = [];
-        if (systemMessages.length) {
-            result.push({
-                role: "system",
-                content: systemMessages
-                    .map((i) => typeof i.content === "string"
-                    ? i.content
-                    : i.content
-                        ?.map((c) => (c.type === "text" ? c.text : null))
-                        .filter(type_utils_js_1.isNonNullable)
-                        .join("\n"))
-                    .join("\n"),
-            });
+        if (options.agent?.useMemoriesFromContext && options.context?.memories?.length) {
+            memories.push(...options.context.memories);
         }
-        return result.concat(otherMessages);
+        if (memories.length)
+            messages.push(...(await this.convertMemoriesToMessages(memories, options)));
+        return messages;
     }
     async convertMemoriesToMessages(memories, options) {
         const messages = [];

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

@@ -42,7 +42,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     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: "system" | "user" | "agent" | "tool";
+        role: "agent" | "user" | "system" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCalls: ChatModelOutputToolCall[] | undefined;
@@ -54,7 +54,7 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     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: "system" | "user" | "agent" | "tool";
+        role: "agent" | "user" | "system" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCallId: string;
@@ -83,21 +83,21 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "system";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string;
     role: "system";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"user">;
     content: z.ZodString;
@@ -113,21 +113,21 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "user";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string;
     role: "user";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"agent">;
     content: z.ZodOptional<z.ZodString>;
@@ -172,6 +172,7 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     role: "agent";
+    name?: string | undefined;
     content?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
@@ -185,9 +186,9 @@ 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";
@@ -201,7 +202,6 @@ 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>>;
@@ -218,23 +218,23 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "tool";
+    content: string;
     toolCallId: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string | Record<string, unknown>;
     role: "tool";
+    content: string | Record<string, unknown>;
     toolCallId: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>]>;
 export declare function safeParseChatMessages(messages: unknown): ChatMessageTemplate[] | undefined;
 export declare function parseChatMessages(messages: (z.infer<typeof chatMessageSchema> & {

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";
@@ -118,7 +118,6 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * agentSucceed, or agentFailed
      */
     disableEvents?: boolean;
-    historyConfig?: Agent["historyConfig"];
     /**
      * One or more memory agents this agent can use
      */
@@ -211,15 +210,15 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
         parsed: object;
     }): Promise<Agent<I, O>>;
     constructor(options?: AgentOptions<I, O>);
+    afs?: AFS;
+    tag?: string;
     /**
      * List of memories this agent can use
      *
      * @deprecated use afs instead
      */
     readonly memories: MemoryAgent[];
-    afs?: AFS;
     asyncMemoryRecord?: boolean;
-    tag?: string;
     /**
      * Maximum number of memory items to retrieve
      */
@@ -349,11 +348,6 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * agentSucceed, or agentFailed
      */
     private disableEvents?;
-    historyConfig?: {
-        disabled?: boolean;
-        maxTokens?: number;
-        maxItems?: number;
-    };
     private subscriptions;
     /**
      * Attach agent to context:
@@ -455,7 +449,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 +781,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/ai-agent.d.ts

@@ -1,4 +1,8 @@
 import { type ZodObject, type ZodType, z } from "zod";
+import { type NestAgentSchema } from "../loader/agent-yaml.js";
+import type { AgentLoadOptions } from "../loader/index.js";
+import { type Instructions } from "../loader/schema.js";
+import type { CompactConfig } from "../prompt/agent-session.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessAsyncGenerator, type AgentProcessResult, type Message } from "./agent.js";
 import type { ChatModel, ChatModelInput } from "./chat-model.js";
@@ -23,8 +27,6 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * more complex prompt templates
      */
     instructions?: string | PromptBuilder;
-    autoReorderSystemMessages?: boolean;
-    autoMergeSystemMessages?: boolean;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -124,6 +126,20 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      */
     memoryPromptTemplate?: string;
     useMemoriesFromContext?: boolean;
+    compact?: CompactConfig;
+}
+export interface AIAgentLoadSchema {
+    instructions?: Instructions;
+    inputKey?: string;
+    inputFileKey?: string;
+    outputKey?: string;
+    outputFileKey?: string;
+    toolChoice?: AIAgentToolChoice;
+    toolCallsConcurrency?: number;
+    keepTextInToolUses?: boolean;
+    compact?: Omit<CompactConfig, "compactor"> & {
+        compactor?: NestAgentSchema;
+    };
 }
 /**
  * Tool choice options for AI agents
@@ -194,6 +210,7 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
     static load<I extends Message = any, O extends Message = any>(options: {
         filepath: string;
         parsed: object;
+        options?: AgentLoadOptions;
     }): Promise<Agent<I, O>>;
     /**
      * Create an AIAgent with the specified options
@@ -225,8 +242,6 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-prompt-builder}
      */
     instructions: PromptBuilder;
-    autoReorderSystemMessages?: boolean;
-    autoMergeSystemMessages?: boolean;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -322,6 +337,7 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
         metadataEnd: string;
         parse: (raw: string) => object;
     };
+    compact?: CompactConfig;
     get inputSchema(): ZodType<I>;
     /**
      * Process an input message and generate a response

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)
      *