@aigne/core 1.16.0 → 1.17.0

package/lib/cjs/memory/default-memory/default-memory-storage/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMemoryStorage = void 0;
+exports.initSequelize = initSequelize;
+require("sqlite3");
+const sequelize_1 = require("sequelize");
+const logger_js_1 = require("../../../utils/logger.js");
+const storage_js_1 = require("../storage.js");
+const migrate_js_1 = require("./migrate.js");
+const memory_js_1 = require("./models/memory.js");
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+class DefaultMemoryStorage extends storage_js_1.MemoryStorage {
+    options;
+    memories = {};
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _models;
+    get models() {
+        this._models ??= (async () => {
+            const sequelize = initSequelize(this.options?.path);
+            await (0, migrate_js_1.migrate)(sequelize);
+            return {
+                Memory: (0, memory_js_1.initMemoryModel)(sequelize),
+            };
+        })();
+        return this._models;
+    }
+    convertMemory(m) {
+        return {
+            id: m.id,
+            sessionId: m.sessionId,
+            content: m.content,
+            createdAt: m.createdAt.toISOString(),
+        };
+    }
+    async search(query, { context }) {
+        const { limit = DEFAULT_MAX_MEMORY_COUNT } = query;
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const { Memory } = await this.models;
+        const memories = await Memory.findAll({
+            where: { sessionId },
+            order: [["id", "DESC"]],
+            limit,
+        });
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const { Memory } = await this.models;
+        const m = await Memory.create({
+            ...memory,
+            sessionId,
+        });
+        return { result: this.convertMemory(m) };
+    }
+}
+exports.DefaultMemoryStorage = DefaultMemoryStorage;
+function initSequelize(path) {
+    const sequelize = new sequelize_1.Sequelize({
+        logging: (sql) => logger_js_1.logger.debug(sql),
+        storage: path,
+        dialect: "sqlite",
+    });
+    return sequelize;
+}

package/lib/cjs/memory/default-memory/default-memory-storage/migrate.d.ts

@@ -0,0 +1,7 @@
+import type { Sequelize } from "sequelize";
+import { type MigrateDownOptions, type MigrateUpOptions } from "umzug";
+export declare const migrate: (sequelize: Sequelize, { type, upOptions, downOptions, }?: {
+    type?: "up" | "down";
+    upOptions?: MigrateUpOptions;
+    downOptions?: MigrateDownOptions;
+}) => Promise<void>;

package/lib/cjs/memory/default-memory/default-memory-storage/migrate.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const umzug_1 = require("umzug");
+const init = __importStar(require("./migrations/20250523165801-init.js"));
+const migrate = async (sequelize, { type = "up", upOptions, downOptions, } = {}) => {
+    const umzug = new umzug_1.Umzug({
+        migrations: [{ ...init, name: "20241224202701-init" }],
+        context: sequelize.getQueryInterface(),
+        storage: new umzug_1.SequelizeStorage({ sequelize }),
+        logger: console,
+    });
+    if (type === "down") {
+        await umzug.down(downOptions);
+    }
+    else {
+        await umzug.up(upOptions);
+    }
+};
+exports.migrate = migrate;

package/lib/cjs/memory/default-memory/default-memory-storage/migrations/20250523165801-init.d.ts

@@ -0,0 +1,7 @@
+import { type QueryInterface } from "sequelize";
+export declare const up: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;
+export declare const down: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;

package/lib/cjs/memory/default-memory/default-memory-storage/migrations/20250523165801-init.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+const sequelize_1 = require("sequelize");
+const up = async ({ context: queryInterface }) => {
+    await queryInterface.createTable("Memories", {
+        id: {
+            type: sequelize_1.DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+        },
+        createdAt: {
+            type: sequelize_1.DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: sequelize_1.DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: sequelize_1.DataTypes.STRING,
+        },
+        content: {
+            type: sequelize_1.DataTypes.JSON,
+            allowNull: false,
+        },
+    });
+};
+exports.up = up;
+const down = async ({ context: queryInterface }) => {
+    await queryInterface.dropTable("Memories");
+};
+exports.down = down;

package/lib/cjs/memory/default-memory/default-memory-storage/models/memory.d.ts

@@ -0,0 +1,10 @@
+import { type CreationOptional, type InferAttributes, type InferCreationAttributes, Model } from "sequelize";
+import type { ModelStatic, Sequelize } from "sequelize";
+export interface Memory extends Model<InferAttributes<Memory>, InferCreationAttributes<Memory>> {
+    id: CreationOptional<string>;
+    createdAt: CreationOptional<Date>;
+    updatedAt: CreationOptional<Date>;
+    sessionId?: string | null;
+    content: unknown;
+}
+export declare function initMemoryModel(sequelize: Sequelize): ModelStatic<Memory>;

package/lib/cjs/memory/default-memory/default-memory-storage/models/memory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMemoryModel = initMemoryModel;
+const sequelize_1 = require("sequelize");
+const uuid_1 = require("uuid");
+const nextId = () => (0, uuid_1.v7)();
+function initMemoryModel(sequelize) {
+    return class Memory extends sequelize_1.Model {
+    }.init({
+        id: {
+            type: sequelize_1.DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+            defaultValue: nextId,
+        },
+        createdAt: {
+            type: sequelize_1.DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: sequelize_1.DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: sequelize_1.DataTypes.STRING,
+        },
+        content: {
+            type: sequelize_1.DataTypes.JSON,
+            allowNull: false,
+        },
+    }, { sequelize });
+}

package/lib/cjs/memory/default-memory/index.d.ts

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "../memory.js";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}

package/lib/cjs/memory/{default-memory.js → default-memory/index.js}

@@ -3,38 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultMemory = exports.DEFAULT_MAX_MEMORY_COUNT = void 0;
+exports.DefaultMemory = void 0;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const memory_js_1 = require("./memory.js");
-const recorder_js_1 = require("./recorder.js");
-const retriever_js_1 = require("./retriever.js");
-exports.DEFAULT_MAX_MEMORY_COUNT = 10;
+const memory_js_1 = require("../memory.js");
+const recorder_js_1 = require("../recorder.js");
+const retriever_js_1 = require("../retriever.js");
+const index_js_1 = require("./default-memory-storage/index.js");
+const storage_js_1 = require("./storage.js");
 class DefaultMemory extends memory_js_1.MemoryAgent {
     constructor(options = {}) {
         super({
             ...options,
             autoUpdate: options.autoUpdate ?? true,
         });
+        this.storage =
+            options.storage instanceof storage_js_1.MemoryStorage
+                ? options.storage
+                : new index_js_1.DefaultMemoryStorage(options.storage);
         if (!this.recorder)
             this.recorder = new DefaultMemoryRecorder(this);
         if (!this.retriever)
             this.retriever = new DefaultMemoryRetriever(this);
     }
-    storage = [];
-    async search(options = {}) {
-        const { limit = exports.DEFAULT_MAX_MEMORY_COUNT } = options;
-        const result = limit < 0 ? this.storage.slice(limit) : this.storage.slice(0, limit);
-        return { result };
-    }
-    async create(memory) {
-        const m = {
-            ...memory,
-            id: (0, memory_js_1.newMemoryId)(),
-            createdAt: new Date().toISOString(),
-        };
-        this.storage.push(m);
-        return { result: m };
-    }
+    storage;
 }
 exports.DefaultMemory = DefaultMemory;
 class DefaultMemoryRetriever extends retriever_js_1.MemoryRetriever {
@@ -43,8 +34,8 @@ class DefaultMemoryRetriever extends retriever_js_1.MemoryRetriever {
         super({});
         this.memory = memory;
     }
-    async process(input) {
-        const { result } = await this.memory.search(input);
+    async process(input, options) {
+        const { result } = await this.memory.storage.search(input, options);
         return { memories: result };
     }
 }
@@ -54,12 +45,12 @@ class DefaultMemoryRecorder extends recorder_js_1.MemoryRecorder {
         super({});
         this.memory = memory;
     }
-    async process(input) {
+    async process(input, options) {
         const newMemories = [];
         for (const content of input.content) {
-            const { result: [last], } = await this.memory.search({ limit: -1 });
+            const { result: [last], } = await this.memory.storage.search({ limit: 1 }, options);
             if (!(0, fast_deep_equal_1.default)(last?.content, content)) {
-                const { result } = await this.memory.create({ content });
+                const { result } = await this.memory.storage.create({ content }, options);
                 newMemories.push(result);
             }
         }

package/lib/cjs/memory/default-memory/storage.d.ts

@@ -0,0 +1,13 @@
+import type { AgentInvokeOptions } from "../../agents/agent.js";
+import type { Memory } from "../memory.js";
+export declare abstract class MemoryStorage {
+    abstract create(memory: Pick<Memory, "content">, options: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    abstract search(query: {
+        search?: string;
+        limit?: number;
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

package/lib/cjs/memory/default-memory/storage.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+class MemoryStorage {
+}
+exports.MemoryStorage = MemoryStorage;

package/lib/cjs/memory/memory.d.ts

@@ -1,10 +1,11 @@
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../agents/agent.js";
 import type { Context } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryRecorder, MemoryRecorderInput, MemoryRecorderOutput } from "./recorder.js";
 import type { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOutput } from "./retriever.js";
 export interface Memory {
     id: string;
+    sessionId?: string | null;
     content: unknown;
     createdAt: string;
 }
@@ -62,7 +63,7 @@ export declare class MemoryAgent extends Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    process(_input: Message, _context: Context): Promise<Message>;
+    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
     /**
      * Retrieves memories based on the provided input criteria.
      *

package/lib/cjs/memory/memory.js

@@ -85,7 +85,7 @@ class MemoryAgent extends agent_js_1.Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    async process(_input, _context) {
+    async process(_input, _options) {
         throw new Error("Method not implemented.");
     }
     /**

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

@@ -6,7 +6,13 @@ import type { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<I extends Message>(message: string | I): I;
+export declare function createMessage<V extends Message>(message: string, variables?: V): {
+    [MESSAGE_KEY]: string;
+} & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
+    [MESSAGE_KEY]: string;
+} | I) & typeof variables;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;

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

@@ -12,10 +12,10 @@ const type_utils_js_1 = require("../utils/type-utils.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
-function createMessage(message) {
-    return typeof message === "string"
-        ? { [exports.MESSAGE_KEY]: message }
-        : { ...message };
+function createMessage(message, variables) {
+    return (typeof message === "string"
+        ? { [exports.MESSAGE_KEY]: message, ...variables }
+        : { ...message, ...variables });
 }
 function getMessage(input) {
     const userInputMessage = input[exports.MESSAGE_KEY];

package/lib/cjs/utils/type-utils.d.ts

@@ -1,4 +1,4 @@
-import { type ZodType } from "zod";
+import { type ZodType, z } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
@@ -20,6 +20,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
+export declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<T>;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;

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

@@ -1,6 +1,6 @@
 import { inspect } from "node:util";
 import { ZodObject, type ZodType } from "zod";
-import type { Context } from "../aigne/context.js";
+import type { Context, UserContext } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryAgent } from "../memory/memory.js";
 import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
@@ -99,7 +99,21 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
 export declare const agentOptionsSchema: ZodObject<{
     [key in keyof AgentOptions]: ZodType<AgentOptions[key]>;
 }>;
-export interface AgentInvokeOptions {
+export interface AgentInvokeOptions<U extends UserContext = UserContext> {
+    /**
+     * The execution context for the agent
+     *
+     * The context provides the runtime environment for agent execution, including:
+     * - Event emission and subscription management
+     * - Inter-agent communication and message passing
+     * - Resource usage tracking and limits enforcement
+     * - Timeout and status management
+     * - Memory and state management across agent invocations
+     *
+     * Each agent invocation requires a context to coordinate with the broader
+     * agent system and maintain proper isolation and resource control.
+     */
+    context: Context<U>;
     /**
      * Whether to enable streaming response
      *
@@ -278,7 +292,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     /**
      * Check context status to ensure it hasn't timed out
      *
-     * @param context The context to check
+     * @param options Invocation options containing context
      * @throws Error if the context has timed out
      */
     private checkContextStatus;
@@ -290,7 +304,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * suitable for scenarios where a complete result is needed at once.
      *
      * @param input Input message to the agent, can be a string or structured object
-     * @param context Execution context, providing environment and resource access
      * @param options Invocation options, must set streaming to false or leave unset
      * @returns Final JSON response
      *
@@ -298,7 +311,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with regular mode:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke}
      */
-    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions & {
+    invoke(input: I | string, options?: Partial<AgentInvokeOptions> & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -309,7 +322,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * chat bot typing effects.
      *
      * @param input Input message to the agent, can be a string or structured object
-     * @param context Execution context, providing environment and resource access
      * @param options Invocation options, must set streaming to true for this overload
      * @returns Streaming response object
      *
@@ -317,7 +329,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with streaming response:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke-streaming}
      */
-    invoke(input: I | string, context: Context | undefined, options: {
+    invoke(input: I | string, options: Partial<AgentInvokeOptions> & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -326,12 +338,11 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Returns either streaming or regular response based on the streaming parameter in options
      *
      * @param input Input message to the agent
-     * @param context Execution context
      * @param options Invocation options
      * @returns Agent response (streaming or regular)
      */
-    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions): Promise<AgentResponse<O>>;
-    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, context: Context): Promise<O>;
+    invoke(input: I | string, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, options: AgentInvokeOptions): Promise<O>;
     /**
      * Process agent output
      *
@@ -339,7 +350,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      *
      * @param input Original input message
      * @param output Raw output produced by the agent
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Final processed output
      */
     private processAgentOutput;
@@ -349,7 +360,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Logs error information, triggers failure events, and re-throws the error
      *
      * @param error Caught error
-     * @param context Execution context
+     * @param options Invocation options
      */
     private processAgentError;
     /**
@@ -358,10 +369,10 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * If the context has a maximum invocation limit set, checks if the limit
      * has been exceeded and increments the invocation counter
      *
-     * @param context Execution context
+     * @param options Invocation options containing context and limits
      * @throws Error if maximum invocation limit is exceeded
      */
-    protected checkAgentInvokesUsage(context: Context): void;
+    protected checkAgentInvokesUsage(options: AgentInvokeOptions): void;
     /**
      * Pre-processing operations before handling input
      *
@@ -370,9 +381,9 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - Verifying invocation limits
      *
      * @param _ Input message (unused)
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    protected preprocess(_: I, context: Context): PromiseOrValue<void>;
+    protected preprocess(_: I, options: AgentInvokeOptions): Promise<void>;
     private checkResponseByGuideRails;
     private runGuideRails;
     /**
@@ -400,10 +411,10 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      *
      * @param input Input message
      * @param output Output message
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    protected postprocess(input: I, output: O, context: Context): PromiseOrValue<void>;
-    protected publishToTopics(output: Message, context: Context): Promise<void>;
+    protected postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+    protected publishToTopics(output: Message, options: AgentInvokeOptions): Promise<void>;
     /**
      * Core processing method of the agent, must be implemented in subclasses
      *
@@ -415,7 +426,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - Another agent instance (transfer agent)
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Options for agent invocation
      * @returns Processing result
      *
      * @example
@@ -434,7 +445,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Example of transfer to another agent:
      * {@includeCode ../../test/agents/agent.test.ts#example-process-transfer}
      */
-    abstract process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    abstract process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
     /**
      * Shut down the agent and clean up resources
      *
@@ -484,6 +495,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the input message
      */
     onStart?: (event: {
+        context: Context;
         input: I;
     }) => PromiseOrValue<void>;
     /**
@@ -496,6 +508,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the input message and either output or error
      */
     onEnd?: (event: XOr<{
+        context: Context;
         input: I;
         output: O;
         error: Error;
@@ -509,6 +522,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the skill being used and input message
      */
     onSkillStart?: (event: {
+        context: Context;
         skill: Agent;
         input: I;
     }) => PromiseOrValue<void>;
@@ -522,6 +536,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the skill used, input message, and either output or error
      */
     onSkillEnd?: (event: XOr<{
+        context: Context;
         skill: Agent;
         input: I;
         output: O;
@@ -537,6 +552,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the source agent, target agent, and input message
      */
     onHandoff?: (event: {
+        context: Context;
         source: Agent;
         target: Agent;
         input: I;
@@ -587,7 +603,7 @@ export interface AgentResponseDelta<T> {
         }> | Partial<{
             [key: string]: string;
         }>;
-        json?: Partial<T | TransferAgentOutput>;
+        json?: Partial<T> | TransferAgentOutput;
     };
 }
 /**
@@ -619,7 +635,7 @@ export declare function jsonDelta<T extends Message>(jsonDelta: NonNullable<Agen
  *
  * @template O Agent output message type
  */
-export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O | TransferAgentOutput> | undefined | void>;
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | TransferAgentOutput | undefined | void>;
 /**
  * Result type for agent processing method, can be:
  * - Direct or streaming response
@@ -709,10 +725,10 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
      * Process input implementation, calls the configured processing function
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Processing result
      */
-    process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
 }
 /**
  * Function type for function agents
@@ -725,4 +741,4 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
  * @param context Execution context
  * @returns Processing result, can be synchronous or asynchronous
  */
-export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, context: Context) => PromiseOrValue<AgentProcessResult<O>>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;