@aigne/transport 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.3.1](https://github.com/AIGNE-io/aigne-framework/compare/transport-v0.3.0...transport-v0.3.1) (2025-05-30)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/openai bumped to 0.2.2
+  * devDependencies
+    * @aigne/core bumped to 1.18.1
+    * @aigne/test-utils bumped to 0.3.3
+
+## [0.3.0](https://github.com/AIGNE-io/aigne-framework/compare/transport-v0.2.0...transport-v0.3.0) (2025-05-29)
+
+
+### Features
+
+* add memory agents support for client agent ([#139](https://github.com/AIGNE-io/aigne-framework/issues/139)) ([57044fa](https://github.com/AIGNE-io/aigne-framework/commit/57044fa87b8abcba395cd05f941d6d312ab65764))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/openai bumped to 0.2.1
+  * devDependencies
+    * @aigne/core bumped to 1.18.0
+    * @aigne/test-utils bumped to 0.3.2
+
 ## [0.2.0](https://github.com/AIGNE-io/aigne-framework/compare/transport-v0.1.0...transport-v0.2.0) (2025-05-25)
 
 

package/lib/cjs/http-client/client-agent.d.ts

@@ -0,0 +1,20 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type AgentResponse, type AgentResponseStream, type Message } from "@aigne/core";
+import type { MemoryAgent } from "@aigne/core/memory/memory.js";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { AIGNEHTTPClient } from "./client.js";
+export interface ClientAgentOptions<I extends Message = Message, O extends Message = Message> extends Required<Pick<AgentOptions<I, O>, "name">> {
+    memory?: MemoryAgent | MemoryAgent[];
+}
+export declare class ClientAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    client: AIGNEHTTPClient;
+    constructor(client: AIGNEHTTPClient, options: ClientAgentOptions<I, O>);
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions> & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke(input: string | I, options: Partial<AgentInvokeOptions> & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    process(_input: I, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+}

package/lib/cjs/http-client/client-agent.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAgent = void 0;
+const core_1 = require("@aigne/core");
+const stream_utils_js_1 = require("@aigne/core/utils/stream-utils.js");
+class ClientAgent extends core_1.Agent {
+    client;
+    constructor(client, options) {
+        super(options);
+        this.client = client;
+    }
+    async invoke(input, options) {
+        const memories = await this.retrieveMemories({ search: input }, { ...options, context: this.client });
+        const result = await this.client._invoke(this.name, input, {
+            ...options,
+            returnActiveAgent: false,
+            memories,
+        });
+        if (!(result instanceof ReadableStream)) {
+            await this.postprocess((0, core_1.createMessage)(input), result, {
+                ...options,
+                context: this.client,
+            });
+            return result;
+        }
+        return (0, stream_utils_js_1.onAgentResponseStreamEnd)(result, async (result) => {
+            await this.postprocess((0, core_1.createMessage)(input), result, {
+                ...options,
+                context: this.client,
+            });
+        });
+    }
+    process(_input, _options) {
+        throw new Error("Method not implemented.");
+    }
+    async postprocess(input, output, options) {
+        await this.recordMemories({
+            content: [
+                { role: "user", content: input },
+                { role: "agent", content: (0, core_1.replaceTransferAgentToName)(output), source: this.name },
+            ],
+        }, options);
+    }
+}
+exports.ClientAgent = ClientAgent;

package/lib/cjs/http-client/client.d.ts

@@ -1,7 +1,6 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "@aigne/core";
+import { type Agent, type AgentResponse, type AgentResponseStream, type Context, type ContextEmitEventMap, type ContextEventMap, type ContextUsage, type InvokeOptions, type Message, type MessagePayload, type MessageQueueListener, type Unsubscribe, type UserAgent, type UserContext } from "@aigne/core";
+import type { Args, Listener } from "@aigne/core/utils/typed-event-emtter.js";
+import { ClientAgent, type ClientAgentOptions } from "./client-agent.js";
 /**
  * Configuration options for the AIGNEHTTPClient.
  */
@@ -16,7 +15,7 @@ export interface AIGNEHTTPClientOptions {
  * Options for invoking an agent through the AIGNEHTTPClient.
  * Extends the standard AgentInvokeOptions with client-specific options.
  */
-export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "context"> {
+export interface AIGNEHTTPClientInvokeOptions extends InvokeOptions {
     /**
      * Additional fetch API options to customize the HTTP request.
      * These options will be merged with the default options used by the client.
@@ -36,7 +35,7 @@ export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "
  * Here's an example of how to use AIGNEClient with streaming response:
  * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
  */
-export declare class AIGNEHTTPClient {
+export declare class AIGNEHTTPClient<U extends UserContext = UserContext> implements Context<U> {
     options: AIGNEHTTPClientOptions;
     /**
      * Creates a new AIGNEClient instance.
@@ -44,6 +43,42 @@ export declare class AIGNEHTTPClient {
      * @param options - Configuration options for connecting to the AIGNE server
      */
     constructor(options: AIGNEHTTPClientOptions);
+    usage: ContextUsage;
+    userContext: U;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming?: false;
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options?: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+    }): Promise<O | AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message?: I | string, options?: AIGNEHTTPClientInvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
+    publish(_topic: string | string[], _payload: Omit<MessagePayload, "context"> | Message | string, _options?: InvokeOptions): void;
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    unsubscribe(_topic: string | string[], _listener: MessageQueueListener): void;
+    newContext(_options?: {
+        reset?: boolean;
+    }): Context;
+    emit<K extends keyof ContextEventMap>(_eventName: K, ..._args: Args<K, ContextEmitEventMap>): boolean;
+    on<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    once<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    off<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
     /**
      * Invokes an agent in non-streaming mode and returns the complete response.
      *
@@ -56,7 +91,7 @@ export declare class AIGNEHTTPClient {
      * Here's a simple example of how to use AIGNEClient:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-simple}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -71,7 +106,7 @@ export declare class AIGNEHTTPClient {
      * Here's an example of how to use AIGNEClient with streaming response:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -82,7 +117,7 @@ export declare class AIGNEHTTPClient {
      * @param options - Options for the invocation
      * @returns Either a complete response or a response stream depending on the streaming option
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
     /**
      * Enhanced fetch method that handles error responses from the AIGNE server.
      * This method wraps the standard fetch API to provide better error handling and reporting.
@@ -94,4 +129,5 @@ export declare class AIGNEHTTPClient {
      * @private
      */
     fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+    getAgent<I extends Message = Message, O extends Message = Message>(options: ClientAgentOptions<I, O>): Promise<ClientAgent<I, O>>;
 }

package/lib/cjs/http-client/client.js

@@ -1,11 +1,10 @@
 "use strict";
-/**
- * Client module used to interact with the AIGNE framework.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIGNEHTTPClient = void 0;
+const core_1 = require("@aigne/core");
 const event_stream_js_1 = require("@aigne/core/utils/event-stream.js");
 const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
+const client_agent_js_1 = require("./client-agent.js");
 /**
  * Http client for interacting with a remote AIGNE server.
  * AIGNEHTTPClient provides a client-side interface that matches the AIGNE API,
@@ -29,7 +28,41 @@ class AIGNEHTTPClient {
     constructor(options) {
         this.options = options;
     }
-    async invoke(agent, input, options) {
+    usage = (0, core_1.newEmptyContextUsage)();
+    userContext = {};
+    invoke(agent, message, options) {
+        if (options?.returnActiveAgent)
+            throw new Error("Method not implemented.");
+        if (!message)
+            throw new Error("Message is required for invoking an agent");
+        const a = typeof agent === "string" ? this.getAgent({ name: agent }) : Promise.resolve(agent);
+        return a.then((agent) => agent.invoke(message, options));
+    }
+    publish(_topic, _payload, _options) {
+        throw new Error("Method not implemented.");
+    }
+    subscribe(_topic, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    unsubscribe(_topic, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    newContext(_options) {
+        throw new Error("Method not implemented.");
+    }
+    emit(_eventName, ..._args) {
+        throw new Error("Method not implemented.");
+    }
+    on(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    once(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    off(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    async _invoke(agent, input, options) {
         // Send the agent invocation request to the AIGNE server
         const response = await this.fetch(this.options.url, {
             ...options?.fetchOptions,
@@ -83,5 +116,8 @@ class AIGNEHTTPClient {
         }
         return result;
     }
+    async getAgent(options) {
+        return new client_agent_js_1.ClientAgent(this, options);
+    }
 }
 exports.AIGNEHTTPClient = AIGNEHTTPClient;

package/lib/cjs/http-server/server.d.ts

@@ -1,5 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import type { AIGNE, UserContext } from "@aigne/core";
+import type { AIGNE, AgentInvokeOptions, UserContext } from "@aigne/core";
 import { z } from "zod";
 /**
  * Schema for validating agent invocation payloads.
@@ -11,27 +11,63 @@ export declare const invokePayloadSchema: z.ZodObject<{
     agent: z.ZodString;
     input: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
     options: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        streaming: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, boolean | undefined, boolean | null | undefined>;
+        userContext: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, Record<string, unknown> | undefined, Record<string, unknown> | null | undefined>;
+        memories: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            content: z.ZodType<object, z.ZodTypeDef, object>;
+        }, "strip", z.ZodTypeAny, {
+            content: object;
+        }, {
+            content: object;
+        }>, "many">>>, {
+            content: object;
+        }[] | undefined, {
+            content: object;
+        }[] | null | undefined>;
     }, "strip", z.ZodTypeAny, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     }, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     }>>>, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined>;
 }, "strip", z.ZodTypeAny, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined;
 }, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined;
 }>;
 /**
@@ -50,8 +86,7 @@ export interface AIGNEHTTPServerOptions {
      */
     maximumBodySize?: string;
 }
-export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> {
-    userContext?: U;
+export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> extends Pick<AgentInvokeOptions<U>, "userContext" | "memories"> {
 }
 /**
  * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
@@ -116,10 +151,11 @@ export declare class AIGNEHTTPServer {
      * with either streaming or non-streaming response handling.
      *
      * @param request - The parsed or raw request to process
+     * @param options - Additional options for the invocation, such as user context and memories
      * @returns A standard Response object with the invocation result
      * @private
      */
-    _invoke(request: Record<string, unknown> | Request | IncomingMessage, { userContext }?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage, options?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
     /**
      * Prepares and normalizes the input from various request types.
      * Handles different request formats (Node.js IncomingMessage, Fetch API Request,

package/lib/cjs/http-server/server.js

@@ -28,7 +28,20 @@ exports.invokePayloadSchema = zod_1.z.object({
     agent: zod_1.z.string(),
     input: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())]),
     options: zod_1.z
-        .object({ streaming: zod_1.z.boolean().nullish() })
+        .object({
+        streaming: zod_1.z
+            .boolean()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        userContext: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.unknown())
+            .nullish()
+            .transform((v) => v ?? undefined),
+        memories: zod_1.z
+            .array(zod_1.z.object({ content: zod_1.z.custom() }))
+            .nullish()
+            .transform((v) => v ?? undefined),
+    })
         .nullish()
         .transform((v) => v ?? undefined),
 });
@@ -61,7 +74,10 @@ class AIGNEHTTPServer {
     }
     async invoke(request, response, options) {
         const opts = !(response instanceof node_http_1.ServerResponse) ? options || response : options;
-        const result = await this._invoke(request, { userContext: opts?.userContext });
+        const result = await this._invoke(request, {
+            userContext: opts?.userContext,
+            memories: opts?.memories,
+        });
         if (response instanceof node_http_1.ServerResponse) {
             await this._writeResponse(result, response);
             return;
@@ -74,24 +90,33 @@ class AIGNEHTTPServer {
      * with either streaming or non-streaming response handling.
      *
      * @param request - The parsed or raw request to process
+     * @param options - Additional options for the invocation, such as user context and memories
      * @returns A standard Response object with the invocation result
      * @private
      */
-    async _invoke(request, { userContext } = {}) {
+    async _invoke(request, options = {}) {
         const { engine } = this;
         try {
             const payload = await this._prepareInput(request);
-            const { agent: agentName, input, options: { streaming } = {}, } = (0, type_utils_js_1.tryOrThrow)(() => (0, type_utils_js_1.checkArguments)(`Invoke agent ${payload.agent}`, exports.invokePayloadSchema, payload), (error) => new error_js_1.ServerError(400, error.message));
+            const { agent: agentName, input, options: { streaming, ...opts } = {}, } = (0, type_utils_js_1.tryOrThrow)(() => (0, type_utils_js_1.checkArguments)(`Invoke agent ${payload.agent}`, exports.invokePayloadSchema, payload), (error) => new error_js_1.ServerError(400, error.message));
             const agent = engine.agents[agentName];
             if (!agent)
                 throw new error_js_1.ServerError(404, `Agent ${agentName} not found`);
+            const mergedOptions = {
+                userContext: { ...opts.userContext, ...options.userContext },
+                memories: [...(opts.memories ?? []), ...(options.memories ?? [])],
+            };
             if (!streaming) {
-                const result = await engine.invoke(agent, input, { userContext });
+                const result = await engine.invoke(agent, input, mergedOptions);
                 return new Response(JSON.stringify(result), {
                     headers: { "Content-Type": "application/json" },
                 });
             }
-            const stream = await engine.invoke(agent, input, { userContext, streaming: true });
+            const stream = await engine.invoke(agent, input, {
+                ...mergedOptions,
+                returnActiveAgent: false,
+                streaming: true,
+            });
             return new Response(new event_stream_js_1.AgentResponseStreamSSE(stream), {
                 headers: {
                     "Content-Type": "text/event-stream",

package/lib/dts/http-client/client-agent.d.ts

@@ -0,0 +1,20 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type AgentResponse, type AgentResponseStream, type Message } from "@aigne/core";
+import type { MemoryAgent } from "@aigne/core/memory/memory.js";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { AIGNEHTTPClient } from "./client.js";
+export interface ClientAgentOptions<I extends Message = Message, O extends Message = Message> extends Required<Pick<AgentOptions<I, O>, "name">> {
+    memory?: MemoryAgent | MemoryAgent[];
+}
+export declare class ClientAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    client: AIGNEHTTPClient;
+    constructor(client: AIGNEHTTPClient, options: ClientAgentOptions<I, O>);
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions> & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke(input: string | I, options: Partial<AgentInvokeOptions> & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    process(_input: I, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+}

package/lib/dts/http-client/client.d.ts

@@ -1,7 +1,6 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "@aigne/core";
+import { type Agent, type AgentResponse, type AgentResponseStream, type Context, type ContextEmitEventMap, type ContextEventMap, type ContextUsage, type InvokeOptions, type Message, type MessagePayload, type MessageQueueListener, type Unsubscribe, type UserAgent, type UserContext } from "@aigne/core";
+import type { Args, Listener } from "@aigne/core/utils/typed-event-emtter.js";
+import { ClientAgent, type ClientAgentOptions } from "./client-agent.js";
 /**
  * Configuration options for the AIGNEHTTPClient.
  */
@@ -16,7 +15,7 @@ export interface AIGNEHTTPClientOptions {
  * Options for invoking an agent through the AIGNEHTTPClient.
  * Extends the standard AgentInvokeOptions with client-specific options.
  */
-export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "context"> {
+export interface AIGNEHTTPClientInvokeOptions extends InvokeOptions {
     /**
      * Additional fetch API options to customize the HTTP request.
      * These options will be merged with the default options used by the client.
@@ -36,7 +35,7 @@ export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "
  * Here's an example of how to use AIGNEClient with streaming response:
  * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
  */
-export declare class AIGNEHTTPClient {
+export declare class AIGNEHTTPClient<U extends UserContext = UserContext> implements Context<U> {
     options: AIGNEHTTPClientOptions;
     /**
      * Creates a new AIGNEClient instance.
@@ -44,6 +43,42 @@ export declare class AIGNEHTTPClient {
      * @param options - Configuration options for connecting to the AIGNE server
      */
     constructor(options: AIGNEHTTPClientOptions);
+    usage: ContextUsage;
+    userContext: U;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming?: false;
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options?: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+    }): Promise<O | AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message?: I | string, options?: AIGNEHTTPClientInvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
+    publish(_topic: string | string[], _payload: Omit<MessagePayload, "context"> | Message | string, _options?: InvokeOptions): void;
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    unsubscribe(_topic: string | string[], _listener: MessageQueueListener): void;
+    newContext(_options?: {
+        reset?: boolean;
+    }): Context;
+    emit<K extends keyof ContextEventMap>(_eventName: K, ..._args: Args<K, ContextEmitEventMap>): boolean;
+    on<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    once<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    off<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
     /**
      * Invokes an agent in non-streaming mode and returns the complete response.
      *
@@ -56,7 +91,7 @@ export declare class AIGNEHTTPClient {
      * Here's a simple example of how to use AIGNEClient:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-simple}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -71,7 +106,7 @@ export declare class AIGNEHTTPClient {
      * Here's an example of how to use AIGNEClient with streaming response:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -82,7 +117,7 @@ export declare class AIGNEHTTPClient {
      * @param options - Options for the invocation
      * @returns Either a complete response or a response stream depending on the streaming option
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
     /**
      * Enhanced fetch method that handles error responses from the AIGNE server.
      * This method wraps the standard fetch API to provide better error handling and reporting.
@@ -94,4 +129,5 @@ export declare class AIGNEHTTPClient {
      * @private
      */
     fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+    getAgent<I extends Message = Message, O extends Message = Message>(options: ClientAgentOptions<I, O>): Promise<ClientAgent<I, O>>;
 }

package/lib/dts/http-server/server.d.ts

@@ -1,5 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import type { AIGNE, UserContext } from "@aigne/core";
+import type { AIGNE, AgentInvokeOptions, UserContext } from "@aigne/core";
 import { z } from "zod";
 /**
  * Schema for validating agent invocation payloads.
@@ -11,27 +11,63 @@ export declare const invokePayloadSchema: z.ZodObject<{
     agent: z.ZodString;
     input: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
     options: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        streaming: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, boolean | undefined, boolean | null | undefined>;
+        userContext: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, Record<string, unknown> | undefined, Record<string, unknown> | null | undefined>;
+        memories: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            content: z.ZodType<object, z.ZodTypeDef, object>;
+        }, "strip", z.ZodTypeAny, {
+            content: object;
+        }, {
+            content: object;
+        }>, "many">>>, {
+            content: object;
+        }[] | undefined, {
+            content: object;
+        }[] | null | undefined>;
     }, "strip", z.ZodTypeAny, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     }, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     }>>>, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined>;
 }, "strip", z.ZodTypeAny, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined;
 }, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined;
 }>;
 /**
@@ -50,8 +86,7 @@ export interface AIGNEHTTPServerOptions {
      */
     maximumBodySize?: string;
 }
-export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> {
-    userContext?: U;
+export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> extends Pick<AgentInvokeOptions<U>, "userContext" | "memories"> {
 }
 /**
  * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
@@ -116,10 +151,11 @@ export declare class AIGNEHTTPServer {
      * with either streaming or non-streaming response handling.
      *
      * @param request - The parsed or raw request to process
+     * @param options - Additional options for the invocation, such as user context and memories
      * @returns A standard Response object with the invocation result
      * @private
      */
-    _invoke(request: Record<string, unknown> | Request | IncomingMessage, { userContext }?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage, options?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
     /**
      * Prepares and normalizes the input from various request types.
      * Handles different request formats (Node.js IncomingMessage, Fetch API Request,

package/lib/esm/http-client/client-agent.d.ts

@@ -0,0 +1,20 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type AgentResponse, type AgentResponseStream, type Message } from "@aigne/core";
+import type { MemoryAgent } from "@aigne/core/memory/memory.js";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { AIGNEHTTPClient } from "./client.js";
+export interface ClientAgentOptions<I extends Message = Message, O extends Message = Message> extends Required<Pick<AgentOptions<I, O>, "name">> {
+    memory?: MemoryAgent | MemoryAgent[];
+}
+export declare class ClientAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    client: AIGNEHTTPClient;
+    constructor(client: AIGNEHTTPClient, options: ClientAgentOptions<I, O>);
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions> & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke(input: string | I, options: Partial<AgentInvokeOptions> & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke(input: string | I, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    process(_input: I, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+}

package/lib/esm/http-client/client-agent.js

@@ -0,0 +1,41 @@
+import { Agent, createMessage, replaceTransferAgentToName, } from "@aigne/core";
+import { onAgentResponseStreamEnd } from "@aigne/core/utils/stream-utils.js";
+export class ClientAgent extends Agent {
+    client;
+    constructor(client, options) {
+        super(options);
+        this.client = client;
+    }
+    async invoke(input, options) {
+        const memories = await this.retrieveMemories({ search: input }, { ...options, context: this.client });
+        const result = await this.client._invoke(this.name, input, {
+            ...options,
+            returnActiveAgent: false,
+            memories,
+        });
+        if (!(result instanceof ReadableStream)) {
+            await this.postprocess(createMessage(input), result, {
+                ...options,
+                context: this.client,
+            });
+            return result;
+        }
+        return onAgentResponseStreamEnd(result, async (result) => {
+            await this.postprocess(createMessage(input), result, {
+                ...options,
+                context: this.client,
+            });
+        });
+    }
+    process(_input, _options) {
+        throw new Error("Method not implemented.");
+    }
+    async postprocess(input, output, options) {
+        await this.recordMemories({
+            content: [
+                { role: "user", content: input },
+                { role: "agent", content: replaceTransferAgentToName(output), source: this.name },
+            ],
+        }, options);
+    }
+}

package/lib/esm/http-client/client.d.ts

@@ -1,7 +1,6 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "@aigne/core";
+import { type Agent, type AgentResponse, type AgentResponseStream, type Context, type ContextEmitEventMap, type ContextEventMap, type ContextUsage, type InvokeOptions, type Message, type MessagePayload, type MessageQueueListener, type Unsubscribe, type UserAgent, type UserContext } from "@aigne/core";
+import type { Args, Listener } from "@aigne/core/utils/typed-event-emtter.js";
+import { ClientAgent, type ClientAgentOptions } from "./client-agent.js";
 /**
  * Configuration options for the AIGNEHTTPClient.
  */
@@ -16,7 +15,7 @@ export interface AIGNEHTTPClientOptions {
  * Options for invoking an agent through the AIGNEHTTPClient.
  * Extends the standard AgentInvokeOptions with client-specific options.
  */
-export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "context"> {
+export interface AIGNEHTTPClientInvokeOptions extends InvokeOptions {
     /**
      * Additional fetch API options to customize the HTTP request.
      * These options will be merged with the default options used by the client.
@@ -36,7 +35,7 @@ export interface AIGNEHTTPClientInvokeOptions extends Omit<AgentInvokeOptions, "
  * Here's an example of how to use AIGNEClient with streaming response:
  * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
  */
-export declare class AIGNEHTTPClient {
+export declare class AIGNEHTTPClient<U extends UserContext = UserContext> implements Context<U> {
     options: AIGNEHTTPClientOptions;
     /**
      * Creates a new AIGNEClient instance.
@@ -44,6 +43,42 @@ export declare class AIGNEHTTPClient {
      * @param options - Configuration options for connecting to the AIGNE server
      */
     constructor(options: AIGNEHTTPClientOptions);
+    usage: ContextUsage;
+    userContext: U;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming?: false;
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options?: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message: I | string, options: AIGNEHTTPClientInvokeOptions & {
+        returnActiveAgent?: false;
+    }): Promise<O | AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O> | string, message?: I | string, options?: AIGNEHTTPClientInvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
+    publish(_topic: string | string[], _payload: Omit<MessagePayload, "context"> | Message | string, _options?: InvokeOptions): void;
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    unsubscribe(_topic: string | string[], _listener: MessageQueueListener): void;
+    newContext(_options?: {
+        reset?: boolean;
+    }): Context;
+    emit<K extends keyof ContextEventMap>(_eventName: K, ..._args: Args<K, ContextEmitEventMap>): boolean;
+    on<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    once<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
+    off<K extends keyof ContextEventMap>(_eventName: K, _listener: Listener<K, ContextEventMap>): this;
     /**
      * Invokes an agent in non-streaming mode and returns the complete response.
      *
@@ -56,7 +91,7 @@ export declare class AIGNEHTTPClient {
      * Here's a simple example of how to use AIGNEClient:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-simple}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -71,7 +106,7 @@ export declare class AIGNEHTTPClient {
      * Here's an example of how to use AIGNEClient with streaming response:
      * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -82,7 +117,7 @@ export declare class AIGNEHTTPClient {
      * @param options - Options for the invocation
      * @returns Either a complete response or a response stream depending on the streaming option
      */
-    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
+    _invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
     /**
      * Enhanced fetch method that handles error responses from the AIGNE server.
      * This method wraps the standard fetch API to provide better error handling and reporting.
@@ -94,4 +129,5 @@ export declare class AIGNEHTTPClient {
      * @private
      */
     fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+    getAgent<I extends Message = Message, O extends Message = Message>(options: ClientAgentOptions<I, O>): Promise<ClientAgent<I, O>>;
 }

package/lib/esm/http-client/client.js

@@ -1,8 +1,7 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
+import { newEmptyContextUsage, } from "@aigne/core";
 import { AgentResponseStreamParser, EventStreamParser } from "@aigne/core/utils/event-stream.js";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { ClientAgent } from "./client-agent.js";
 /**
  * Http client for interacting with a remote AIGNE server.
  * AIGNEHTTPClient provides a client-side interface that matches the AIGNE API,
@@ -26,7 +25,41 @@ export class AIGNEHTTPClient {
     constructor(options) {
         this.options = options;
     }
-    async invoke(agent, input, options) {
+    usage = newEmptyContextUsage();
+    userContext = {};
+    invoke(agent, message, options) {
+        if (options?.returnActiveAgent)
+            throw new Error("Method not implemented.");
+        if (!message)
+            throw new Error("Message is required for invoking an agent");
+        const a = typeof agent === "string" ? this.getAgent({ name: agent }) : Promise.resolve(agent);
+        return a.then((agent) => agent.invoke(message, options));
+    }
+    publish(_topic, _payload, _options) {
+        throw new Error("Method not implemented.");
+    }
+    subscribe(_topic, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    unsubscribe(_topic, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    newContext(_options) {
+        throw new Error("Method not implemented.");
+    }
+    emit(_eventName, ..._args) {
+        throw new Error("Method not implemented.");
+    }
+    on(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    once(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    off(_eventName, _listener) {
+        throw new Error("Method not implemented.");
+    }
+    async _invoke(agent, input, options) {
         // Send the agent invocation request to the AIGNE server
         const response = await this.fetch(this.options.url, {
             ...options?.fetchOptions,
@@ -80,4 +113,7 @@ export class AIGNEHTTPClient {
         }
         return result;
     }
+    async getAgent(options) {
+        return new ClientAgent(this, options);
+    }
 }

package/lib/esm/http-server/server.d.ts

@@ -1,5 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import type { AIGNE, UserContext } from "@aigne/core";
+import type { AIGNE, AgentInvokeOptions, UserContext } from "@aigne/core";
 import { z } from "zod";
 /**
  * Schema for validating agent invocation payloads.
@@ -11,27 +11,63 @@ export declare const invokePayloadSchema: z.ZodObject<{
     agent: z.ZodString;
     input: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
     options: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        streaming: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>, boolean | undefined, boolean | null | undefined>;
+        userContext: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, Record<string, unknown> | undefined, Record<string, unknown> | null | undefined>;
+        memories: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            content: z.ZodType<object, z.ZodTypeDef, object>;
+        }, "strip", z.ZodTypeAny, {
+            content: object;
+        }, {
+            content: object;
+        }>, "many">>>, {
+            content: object;
+        }[] | undefined, {
+            content: object;
+        }[] | null | undefined>;
     }, "strip", z.ZodTypeAny, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     }, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     }>>>, {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined, {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined>;
 }, "strip", z.ZodTypeAny, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
-        streaming?: boolean | null | undefined;
+        streaming?: boolean | undefined;
+        userContext?: Record<string, unknown> | undefined;
+        memories?: {
+            content: object;
+        }[] | undefined;
     } | undefined;
 }, {
     agent: string;
     input: string | Record<string, unknown>;
     options?: {
         streaming?: boolean | null | undefined;
+        userContext?: Record<string, unknown> | null | undefined;
+        memories?: {
+            content: object;
+        }[] | null | undefined;
     } | null | undefined;
 }>;
 /**
@@ -50,8 +86,7 @@ export interface AIGNEHTTPServerOptions {
      */
     maximumBodySize?: string;
 }
-export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> {
-    userContext?: U;
+export interface AIGNEHTTPServerInvokeOptions<U extends UserContext = UserContext> extends Pick<AgentInvokeOptions<U>, "userContext" | "memories"> {
 }
 /**
  * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
@@ -116,10 +151,11 @@ export declare class AIGNEHTTPServer {
      * with either streaming or non-streaming response handling.
      *
      * @param request - The parsed or raw request to process
+     * @param options - Additional options for the invocation, such as user context and memories
      * @returns A standard Response object with the invocation result
      * @private
      */
-    _invoke(request: Record<string, unknown> | Request | IncomingMessage, { userContext }?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage, options?: AIGNEHTTPServerInvokeOptions): Promise<Response>;
     /**
      * Prepares and normalizes the input from various request types.
      * Handles different request formats (Node.js IncomingMessage, Fetch API Request,

package/lib/esm/http-server/server.js

@@ -22,7 +22,20 @@ export const invokePayloadSchema = z.object({
     agent: z.string(),
     input: z.union([z.string(), z.record(z.string(), z.unknown())]),
     options: z
-        .object({ streaming: z.boolean().nullish() })
+        .object({
+        streaming: z
+            .boolean()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        userContext: z
+            .record(z.string(), z.unknown())
+            .nullish()
+            .transform((v) => v ?? undefined),
+        memories: z
+            .array(z.object({ content: z.custom() }))
+            .nullish()
+            .transform((v) => v ?? undefined),
+    })
         .nullish()
         .transform((v) => v ?? undefined),
 });
@@ -55,7 +68,10 @@ export class AIGNEHTTPServer {
     }
     async invoke(request, response, options) {
         const opts = !(response instanceof ServerResponse) ? options || response : options;
-        const result = await this._invoke(request, { userContext: opts?.userContext });
+        const result = await this._invoke(request, {
+            userContext: opts?.userContext,
+            memories: opts?.memories,
+        });
         if (response instanceof ServerResponse) {
             await this._writeResponse(result, response);
             return;
@@ -68,24 +84,33 @@ export class AIGNEHTTPServer {
      * with either streaming or non-streaming response handling.
      *
      * @param request - The parsed or raw request to process
+     * @param options - Additional options for the invocation, such as user context and memories
      * @returns A standard Response object with the invocation result
      * @private
      */
-    async _invoke(request, { userContext } = {}) {
+    async _invoke(request, options = {}) {
         const { engine } = this;
         try {
             const payload = await this._prepareInput(request);
-            const { agent: agentName, input, options: { streaming } = {}, } = tryOrThrow(() => checkArguments(`Invoke agent ${payload.agent}`, invokePayloadSchema, payload), (error) => new ServerError(400, error.message));
+            const { agent: agentName, input, options: { streaming, ...opts } = {}, } = tryOrThrow(() => checkArguments(`Invoke agent ${payload.agent}`, invokePayloadSchema, payload), (error) => new ServerError(400, error.message));
             const agent = engine.agents[agentName];
             if (!agent)
                 throw new ServerError(404, `Agent ${agentName} not found`);
+            const mergedOptions = {
+                userContext: { ...opts.userContext, ...options.userContext },
+                memories: [...(opts.memories ?? []), ...(options.memories ?? [])],
+            };
             if (!streaming) {
-                const result = await engine.invoke(agent, input, { userContext });
+                const result = await engine.invoke(agent, input, mergedOptions);
                 return new Response(JSON.stringify(result), {
                     headers: { "Content-Type": "application/json" },
                 });
             }
-            const stream = await engine.invoke(agent, input, { userContext, streaming: true });
+            const stream = await engine.invoke(agent, input, {
+                ...mergedOptions,
+                returnActiveAgent: false,
+                streaming: true,
+            });
             return new Response(new AgentResponseStreamSSE(stream), {
                 headers: {
                     "Content-Type": "text/event-stream",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/transport",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "AIGNE Transport SDK providing HTTP client and server implementations for communication between AIGNE components",
   "publishConfig": {
     "access": "public"
@@ -39,7 +39,7 @@
     }
   },
   "dependencies": {
-    "@aigne/openai": "^0.2.0"
+    "@aigne/openai": "^0.2.2"
   },
   "devDependencies": {
     "@types/bun": "^1.2.12",
@@ -48,12 +48,14 @@
     "compression": "^1.8.0",
     "detect-port": "^2.1.0",
     "express": "^5.1.0",
+    "fast-deep-equal": "^3.1.3",
     "hono": "^4.7.10",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "@aigne/core": "^1.17.0",
-    "@aigne/test-utils": "^0.3.1"
+    "uuid": "^11.1.0",
+    "@aigne/test-utils": "^0.3.3",
+    "@aigne/core": "^1.18.1"
   },
   "scripts": {
     "lint": "tsc --noEmit",