@aigne/core 1.5.0 → 1.5.1-1

package/lib/cjs/execution-engine/execution-engine.js

@@ -5,14 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionEngine = void 0;
 const node_events_1 = __importDefault(require("node:events"));
-const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
-const types_js_1 = require("../agents/types.js");
-const user_agent_js_1 = require("../agents/user-agent.js");
 const chat_model_js_1 = require("../models/chat-model.js");
-const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
+const context_js_1 = require("./context.js");
 const message_queue_js_1 = require("./message-queue.js");
 class ExecutionEngine extends node_events_1.default {
     constructor(options) {
@@ -21,6 +18,7 @@ class ExecutionEngine extends node_events_1.default {
         super();
         this.model = options?.model;
         this.tools = options?.tools ?? [];
+        this.limits = options?.limits;
         if (options?.agents?.length)
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
@@ -29,6 +27,7 @@ class ExecutionEngine extends node_events_1.default {
     model;
     tools;
     agents = [];
+    limits;
     addAgent(...agents) {
         (0, type_utils_js_1.checkArguments)("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);
         for (const agent of agents) {
@@ -36,8 +35,8 @@ class ExecutionEngine extends node_events_1.default {
             agent.attach(this);
         }
     }
-    createMessageFromInput(message) {
-        return typeof message === "string" ? (0, prompt_builder_js_1.createMessage)(message) : message;
+    newContext() {
+        return new context_js_1.ExecutionContext(this);
     }
     /**
      * Publish a message to a topic, the engine will call the listeners of the topic
@@ -46,56 +45,10 @@ class ExecutionEngine extends node_events_1.default {
      * @param from the agent who publish the message, if not provided, it will be treated as a user message
      */
     publish(topic, message, from) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine.publish", executionEnginePublishArgsSchema, {
-            topic,
-            message,
-            from,
-        });
-        const request = {
-            role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
-            source: from?.name,
-            message: this.createMessageFromInput(message),
-        };
-        this.messageQueue.publish(topic, request);
+        return new context_js_1.ExecutionContext(this).publish(topic, message, from);
     }
     call(agent, message, options) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine.call", executionEngineCallArgsSchema, {
-            agent,
-            message,
-            options,
-        });
-        if ((0, lodash_es_1.isNil)(message)) {
-            let activeAgent = agent;
-            return user_agent_js_1.UserAgent.from({
-                context: this,
-                process: async (input, context) => {
-                    const [output, agent] = await context.call(activeAgent, input, {
-                        returnActiveAgent: true,
-                    });
-                    activeAgent = agent;
-                    return output;
-                },
-            });
-        }
-        return this._call(agent, this.createMessageFromInput(message)).then((result) => options?.returnActiveAgent ? [result.output, result.agent] : result.output);
-    }
-    /**
-     * Call an agent with a message and return the output and the active agent
-     * @param agent Agent to call
-     * @param message Message to pass to the agent
-     * @returns the output of the agent and the final active agent
-     */
-    async _call(agent, message) {
-        const { output, agent: activeAgent } = await this.callAgent(agent, message);
-        if (activeAgent instanceof agent_js_1.Agent) {
-            const publishTopics = typeof activeAgent.publishTopic === "function"
-                ? await activeAgent.publishTopic(output)
-                : activeAgent.publishTopic;
-            if (publishTopics?.length) {
-                this.publish(publishTopics, output, activeAgent);
-            }
-        }
-        return { output, agent: activeAgent };
+        return new context_js_1.ExecutionContext(this).call(agent, message, options);
     }
     subscribe(topic, listener) {
         (0, type_utils_js_1.checkArguments)("ExecutionEngine.subscribe", executionEngineSubscribeArgsSchema, {
@@ -111,38 +64,6 @@ class ExecutionEngine extends node_events_1.default {
         });
         this.messageQueue.unsubscribe(topic, listener);
     }
-    async callAgent(agent, input) {
-        let activeAgent = agent;
-        let output;
-        for (;;) {
-            let result;
-            if (typeof activeAgent === "function") {
-                result = await activeAgent(input, this);
-            }
-            else {
-                result = await activeAgent.call(input, this);
-            }
-            if (!(result instanceof agent_js_1.Agent))
-                output = result;
-            const transferToAgent = result instanceof agent_js_1.Agent
-                ? result
-                : (0, types_js_1.isTransferAgentOutput)(result)
-                    ? result[types_js_1.transferAgentOutputKey].agent
-                    : undefined;
-            if (transferToAgent) {
-                activeAgent = transferToAgent;
-            }
-            else {
-                break;
-            }
-        }
-        if (!output)
-            throw new Error("Unexpected empty output");
-        return {
-            agent: activeAgent,
-            output,
-        };
-    }
     async shutdown() {
         for (const tool of this.tools) {
             await tool.shutdown();
@@ -164,16 +85,6 @@ const executionEngineOptionsSchema = zod_1.z.object({
     agents: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
 });
 const executionEngineAddAgentArgsSchema = zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent));
-const executionEnginePublishArgsSchema = zod_1.z.object({
-    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
-    message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
-    from: zod_1.z.instanceof(agent_js_1.Agent).optional(),
-});
-const executionEngineCallArgsSchema = zod_1.z.object({
-    agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),
-    message: zod_1.z.union([zod_1.z.record(zod_1.z.unknown()), zod_1.z.string()]).optional(),
-    options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),
-});
 const executionEngineSubscribeArgsSchema = zod_1.z.object({
     topic: zod_1.z.string(),
     listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()).optional(),

package/lib/cjs/execution-engine/message-queue.d.ts

@@ -1,10 +1,12 @@
 import type { Message } from "../agents/agent.js";
+import type { Context } from "./context.js";
 export declare const UserInputTopic = "UserInputTopic";
 export declare const UserOutputTopic = "UserOutputTopic";
 export interface MessagePayload {
     role: "user" | "agent";
     source?: string;
     message: Message;
+    context: Context;
 }
 export type MessageQueueListener = (message: MessagePayload) => void;
 export type MessageRequest = MessagePayload;

package/lib/cjs/execution-engine/utils.d.ts

@@ -1,4 +1,4 @@
 import { type FunctionAgentFn } from "../agents/agent.js";
 import type { Runnable } from "./context.js";
-export declare function sequential(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
-export declare function parallel(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
+export declare function sequential(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
+export declare function parallel(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;

package/lib/cjs/execution-engine/utils.js

@@ -5,32 +5,28 @@ exports.parallel = parallel;
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
-function sequential(..._agents) {
-    (0, type_utils_js_1.checkArguments)("sequential", agentArraySchema, _agents);
-    let agents = [..._agents];
+function sequential(...agents) {
+    (0, type_utils_js_1.checkArguments)("sequential", agentArraySchema, agents);
+    let _agents = [...agents];
     return async (input, context) => {
-        if (!context)
-            throw new Error("Context is required for executing sequential agents. Please provide a valid context.");
         const output = {};
         // Clone the agents to run, so that we can update the agents list during the loop
-        const agentsToRun = [...agents];
-        agents = [];
+        const agentsToRun = [..._agents];
+        _agents = [];
         for (const agent of agentsToRun) {
             const [o, transferToAgent] = await context.call(agent, { ...input, ...output }, { returnActiveAgent: true });
             Object.assign(output, o);
-            agents.push(transferToAgent);
+            _agents.push(transferToAgent);
         }
         return output;
     };
 }
-function parallel(..._agents) {
-    (0, type_utils_js_1.checkArguments)("parallel", agentArraySchema, _agents);
-    let agents = [..._agents];
+function parallel(...agents) {
+    (0, type_utils_js_1.checkArguments)("parallel", agentArraySchema, agents);
+    let _agents = [...agents];
     return async (input, context) => {
-        if (!context)
-            throw new Error("Context is required for executing parallel agents. Please provide a valid context.");
-        const result = await Promise.all(agents.map((agent) => context.call(agent, input, { returnActiveAgent: true })));
-        agents = result.map((i) => i[1]);
+        const result = await Promise.all(_agents.map((agent) => context.call(agent, input, { returnActiveAgent: true })));
+        _agents = result.map((i) => i[1]);
         const outputs = result.map((i) => i[0]);
         return Object.assign({}, ...outputs);
     };

package/lib/cjs/models/chat-model.d.ts

@@ -1,6 +1,9 @@
 import { Agent, type Message } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
+    protected preprocess(input: ChatModelInput, context: Context): void;
+    protected postprocess(input: ChatModelInput, output: ChatModelOutput, context: Context): void;
 }
 export interface ChatModelInput extends Message {
     messages: ChatModelInputMessage[];
@@ -71,6 +74,7 @@ export interface ChatModelOutput extends Message {
     text?: string;
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
+    usage?: ChatModelOutputUsage;
 }
 export interface ChatModelOutputToolCall {
     id: string;
@@ -80,3 +84,7 @@ export interface ChatModelOutputToolCall {
         arguments: Message;
     };
 }
+export interface ChatModelOutputUsage {
+    promptTokens: number;
+    completionTokens: number;
+}

package/lib/cjs/models/chat-model.js

@@ -10,6 +10,22 @@ class ChatModel extends agent_js_1.Agent {
             outputSchema: chatModelOutputSchema,
         });
     }
+    preprocess(input, context) {
+        super.preprocess(input, context);
+        const { limits, usage } = context;
+        const usedTokens = usage.completionTokens + usage.promptTokens;
+        if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
+            throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
+        }
+    }
+    postprocess(input, output, context) {
+        super.postprocess(input, output, context);
+        const { usage } = output;
+        if (usage) {
+            context.usage.completionTokens += usage.completionTokens;
+            context.usage.promptTokens += usage.promptTokens;
+        }
+    }
 }
 exports.ChatModel = ChatModel;
 const chatModelInputMessageSchema = zod_1.z.object({
@@ -85,8 +101,13 @@ const chatModelOutputToolCallSchema = zod_1.z.object({
         arguments: zod_1.z.record(zod_1.z.unknown()),
     }),
 });
+const chatModelOutputUsageSchema = zod_1.z.object({
+    promptTokens: zod_1.z.number(),
+    completionTokens: zod_1.z.number(),
+});
 const chatModelOutputSchema = zod_1.z.object({
     text: zod_1.z.string().optional(),
     json: zod_1.z.record(zod_1.z.unknown()).optional(),
     toolCalls: zod_1.z.array(chatModelOutputToolCallSchema).optional(),
+    usage: chatModelOutputUsageSchema.optional(),
 });

package/lib/cjs/models/claude-chat-model.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeChatModel = exports.claudeChatModelOptionsSchema = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const logger_js_1 = require("../utils/logger.js");
+const model_utils_js_1 = require("../utils/model-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
@@ -65,7 +65,12 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
         // Claude doesn't support json_schema response and tool calls in the same request,
         // so we need to make a separate request for json_schema response when the tool calls is empty
         if (!result.toolCalls?.length && input.responseFormat?.type === "json_schema") {
-            return this.requestStructuredOutput(body, input.responseFormat);
+            const output = await this.requestStructuredOutput(body, input.responseFormat);
+            return {
+                ...output,
+                // merge usage from both requests
+                usage: (0, model_utils_js_1.mergeUsage)(result.usage, output.usage),
+            };
         }
         return result;
     }
@@ -74,7 +79,18 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
         try {
             let text = "";
             const toolCalls = [];
+            let usage;
             for await (const chunk of stream) {
+                if (chunk.type === "message_start") {
+                    const { input_tokens, output_tokens } = chunk.message.usage;
+                    usage = {
+                        promptTokens: input_tokens,
+                        completionTokens: output_tokens,
+                    };
+                }
+                if (chunk.type === "message_delta" && usage) {
+                    usage.completionTokens = chunk.usage.output_tokens;
+                }
                 logs.push(JSON.stringify(chunk));
                 // handle streaming text
                 if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
@@ -98,7 +114,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
                     call.args += chunk.delta.partial_json;
                 }
             }
-            const result = { text };
+            const result = { usage, text };
             if (toolCalls.length) {
                 result.toolCalls = toolCalls
                     .map(({ args, ...c }) => ({
@@ -143,6 +159,10 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             throw new Error("Json tool not found");
         return {
             json: jsonTool.input,
+            usage: {
+                promptTokens: result.usage.input_tokens,
+                completionTokens: result.usage.output_tokens,
+            },
         };
     }
 }
@@ -236,7 +256,7 @@ function convertTools({ tools, toolChoice, disableParallelToolUse, }) {
             ? tools.map((i) => ({
                 name: i.function.name,
                 description: i.function.description,
-                input_schema: (0, lodash_es_1.isEmpty)(i.function.parameters)
+                input_schema: (0, type_utils_js_1.isEmpty)(i.function.parameters)
                     ? { type: "object" }
                     : i.function.parameters,
             }))

package/lib/cjs/models/openai-chat-model.d.ts

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import { z } from "zod";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
@@ -61,7 +62,7 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     private _client?;
-    private get client();
+    get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
 }

package/lib/cjs/models/openai-chat-model.js

@@ -69,10 +69,14 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
                     },
                 }
                 : undefined,
+            stream_options: {
+                include_usage: true,
+            },
             stream: true,
         });
         let text = "";
         const toolCalls = [];
+        let usage;
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
             if (choice?.delta.tool_calls?.length) {
@@ -94,8 +98,16 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
             }
             if (choice?.delta.content)
                 text += choice.delta.content;
+            if (chunk.usage) {
+                usage = {
+                    promptTokens: chunk.usage.prompt_tokens,
+                    completionTokens: chunk.usage.completion_tokens,
+                };
+            }
         }
-        const result = {};
+        const result = {
+            usage,
+        };
         if (input.responseFormat?.type === "json_schema" && text) {
             result.json = (0, json_schema_js_1.parseJSON)(text);
         }

package/lib/cjs/models/xai-chat-model.d.ts

@@ -7,6 +7,5 @@ export interface XAIChatModelOptions {
     baseURL?: string;
 }
 export declare class XAIChatModel extends OpenAIChatModel {
-    options?: XAIChatModelOptions | undefined;
-    constructor(options?: XAIChatModelOptions | undefined);
+    constructor(options?: XAIChatModelOptions);
 }

package/lib/cjs/models/xai-chat-model.js

@@ -5,14 +5,12 @@ const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
 class XAIChatModel extends openai_chat_model_js_1.OpenAIChatModel {
-    options;
     constructor(options) {
         super({
             ...options,
             model: options?.model || XAI_DEFAULT_CHAT_MODEL,
             baseURL: options?.baseURL || XAI_BASE_URL,
         });
-        this.options = options;
     }
 }
 exports.XAIChatModel = XAIChatModel;

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

@@ -4,10 +4,10 @@ exports.PromptBuilder = exports.DEFAULT_MAX_HISTORY_MESSAGES = exports.MESSAGE_K
 exports.createMessage = createMessage;
 exports.getMessage = getMessage;
 const promises_1 = require("node:fs/promises");
-const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
 const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
 exports.DEFAULT_MAX_HISTORY_MESSAGES = 10;
@@ -18,7 +18,7 @@ function getMessage(input) {
     const userInputMessage = input[exports.MESSAGE_KEY];
     if (typeof userInputMessage === "string")
         return userInputMessage;
-    if (!(0, lodash_es_1.isNil)(userInputMessage))
+    if (!(0, type_utils_js_1.isNil)(userInputMessage))
         return JSON.stringify(userInputMessage);
     return undefined;
 }
@@ -172,5 +172,5 @@ function isEmptyObjectType(schema) {
 }
 function convertMessageToContent(i) {
     const str = i[exports.MESSAGE_KEY];
-    return !(0, lodash_es_1.isNil)(str) ? (typeof str === "string" ? str : JSON.stringify(str)) : JSON.stringify(i);
+    return !(0, type_utils_js_1.isNil)(str) ? (typeof str === "string" ? str : JSON.stringify(str)) : JSON.stringify(i);
 }

package/lib/cjs/utils/json-schema.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.outputSchemaToResponseFormatSchema = outputSchemaToResponseFormatSchema;
 exports.parseJSON = parseJSON;
 exports.ensureZodUnionArray = ensureZodUnionArray;
-const lodash_es_1 = require("lodash-es");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const logger_js_1 = require("./logger.js");
 function outputSchemaToResponseFormatSchema(agentOutput) {
@@ -13,7 +12,7 @@ function setAdditionPropertiesDeep(schema, additionalProperties) {
     if (Array.isArray(schema)) {
         return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
     }
-    if ((0, lodash_es_1.isObject)(schema)) {
+    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
         return Object.entries(schema).reduce((acc, [key, value]) => {
             acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
             if (acc.type === "object") {

package/lib/cjs/utils/logger.d.ts

@@ -10,7 +10,7 @@ export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: import("ora").Ora;
+    globalSpinner: import("@aigne/ora").Ora;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;

package/lib/cjs/utils/logger.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
+const ora_1 = __importDefault(require("@aigne/ora"));
 const debug_1 = __importDefault(require("debug"));
-const ora_1 = __importDefault(require("ora"));
 debug_1.default.log = (...args) => {
     const { isSpinning } = globalSpinner;
     if (isSpinning)

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

@@ -0,0 +1,3 @@
+import type { ChatModelOutputUsage } from "../models/chat-model.js";
+import type { Nullish } from "./type-utils.js";
+export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

package/lib/cjs/utils/model-utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeUsage = mergeUsage;
+function mergeUsage(...usages) {
+    return {
+        promptTokens: usages.reduce((acc, usage) => (usage ? acc + usage.promptTokens : acc), 0),
+        completionTokens: usages.reduce((acc, usage) => (usage ? acc + usage.completionTokens : acc), 0),
+    };
+}

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

@@ -1,12 +1,11 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined;
+export declare function isNil(value: unknown): value is null | undefined;
+export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
-export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
-export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;
-export declare function get(obj: unknown, path: string | string[], type: "number"): number | undefined;
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };

package/lib/cjs/utils/type-utils.js

@@ -1,31 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNil = isNil;
+exports.isEmpty = isEmpty;
 exports.isNonNullable = isNonNullable;
 exports.isNotEmpty = isNotEmpty;
 exports.orArrayToArray = orArrayToArray;
-exports.get = get;
 exports.createAccessorArray = createAccessorArray;
 exports.checkArguments = checkArguments;
-const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
+function isNil(value) {
+    return value === null || value === undefined;
+}
+function isEmpty(obj) {
+    if (isNil(obj))
+        return true;
+    if (typeof obj === "string" || Array.isArray(obj))
+        return obj.length === 0;
+    if (typeof obj === "object")
+        Object.keys(obj).length === 0;
+    return false;
+}
 function isNonNullable(value) {
-    return !(0, lodash_es_1.isNil)(value);
+    return !isNil(value);
 }
 function isNotEmpty(arr) {
     return arr.length > 0;
 }
 function orArrayToArray(value) {
-    if ((0, lodash_es_1.isNil)(value))
+    if (isNil(value))
         return [];
     return Array.isArray(value) ? value : [value];
 }
-function get(obj, path, type) {
-    const v = (0, lodash_es_1.get)(obj, path);
-    if (type === "string" && typeof v === "string")
-        return v;
-    if (type === "number" && typeof v === "number")
-        return v;
-}
 function createAccessorArray(array, accessor) {
     return new Proxy(array, {
         get: (t, p, r) => Reflect.get(t, p, r) ?? accessor(array, p),

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

@@ -44,11 +44,15 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - subscribe to memory topic if memory is enabled
      * @param context Context to attach
      */
-    attach(context: Context): void;
+    attach(context: Pick<Context, "subscribe">): void;
     addTool<I extends Message, O extends Message>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
+    private checkContextStatus;
+    private newDefaultContext;
     call(input: I | string, context?: Context): Promise<O>;
-    abstract process(input: I, context?: Context): Promise<O | TransferAgentOutput>;
+    protected preprocess(_: I, context: Context): void;
+    protected postprocess(input: I, output: O, context: Context): void;
+    abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
 }
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
@@ -59,6 +63,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context?: Context): Promise<TransferAgentOutput | O>;
+    process(input: I, context: Context): Promise<TransferAgentOutput | O>;
 }
-export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;
+export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;

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

@@ -27,10 +27,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     disableLogging: z.ZodOptional<z.ZodBoolean>;
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
-    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | undefined;
+    toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
-    description?: string | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
@@ -42,10 +42,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     disableLogging?: boolean | undefined;
     memory?: any;
 }, {
+    description?: string | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
-    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | undefined;
+    toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
-    description?: string | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
@@ -64,5 +64,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    process(input: I, context?: Context): Promise<import("./types.js").TransferAgentOutput | O>;
+    process(input: I, context: Context): Promise<import("./types.js").TransferAgentOutput | O>;
 }

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

@@ -21,6 +21,6 @@ export declare class AgentMemory {
     memories: Memory[];
     private subscriptions;
     addMemory(memory: Memory): void;
-    attach(context: Context): void;
+    attach(context: Pick<Context, "subscribe">): void;
     detach(): void;
 }