langchain 1.0.0-alpha.8 → 1.0.1

package/dist/agents/middleware.d.cts

@@ -0,0 +1,185 @@
+import { ClientTool, ServerTool } from "./tools.cjs";
+import { AfterAgentHook, AfterModelHook, AgentMiddleware, BeforeAgentHook, BeforeModelHook, WrapModelCallHook, WrapToolCallHook } from "./middleware/types.cjs";
+import { InferInteropZodOutput, InteropZodDefault, InteropZodObject, InteropZodOptional } from "@langchain/core/utils/types";
+
+//#region src/agents/middleware.d.ts
+
+/**
+ * Creates a middleware instance with automatic schema inference.
+ *
+ * @param config - Middleware configuration
+ * @param config.name - The name of the middleware
+ * @param config.stateSchema - The schema of the middleware state
+ * @param config.contextSchema - The schema of the middleware context
+ * @param config.wrapModelCall - The function to wrap model invocation
+ * @param config.wrapToolCall - The function to wrap tool invocation
+ * @param config.beforeModel - The function to run before the model call
+ * @param config.afterModel - The function to run after the model call
+ * @param config.beforeAgent - The function to run before the agent execution starts
+ * @param config.afterAgent - The function to run after the agent execution completes
+ * @returns A middleware instance
+ *
+ * @example
+ * ```ts
+ * const authMiddleware = createMiddleware({
+ *   name: "AuthMiddleware",
+ *   stateSchema: z.object({
+ *     isAuthenticated: z.boolean().default(false),
+ *   }),
+ *   contextSchema: z.object({
+ *     userId: z.string(),
+ *   }),
+ *   beforeModel: async (state, runtime, controls) => {
+ *     if (!state.isAuthenticated) {
+ *       return controls.terminate(new Error("Not authenticated"));
+ *     }
+ *   },
+ * });
+ * ```
+ */
+declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined>(config: {
+  /**
+   * The name of the middleware
+   */
+  name: string;
+  /**
+   * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
+  stateSchema?: TSchema;
+  /**
+   * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
+  contextSchema?: TContextSchema;
+  /**
+   * Additional tools registered by the middleware.
+   */
+  tools?: (ClientTool | ServerTool)[];
+  /**
+   * Wraps tool execution with custom logic. This allows you to:
+   * - Modify tool call parameters before execution
+   * - Handle errors and retry with different parameters
+   * - Post-process tool results
+   * - Implement caching, logging, authentication, or other cross-cutting concerns
+   * - Return Command objects for advanced control flow
+   *
+   * The handler receives a ToolCallRequest containing the tool call, state, and runtime,
+   * along with a handler function to execute the actual tool.
+   *
+   * @param request - The tool call request containing toolCall, state, and runtime.
+   * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.
+   * @returns The tool result as a ToolMessage or a Command for advanced control flow.
+   *
+   * @example
+   * ```ts
+   * wrapToolCall: async (request, handler) => {
+   *   console.log(`Calling tool: ${request.tool.name}`);
+   *   console.log(`Tool description: ${request.tool.description}`);
+   *
+   *   try {
+   *     // Execute the tool
+   *     const result = await handler(request);
+   *     console.log(`Tool ${request.tool.name} succeeded`);
+   *     return result;
+   *   } catch (error) {
+   *     console.error(`Tool ${request.tool.name} failed:`, error);
+   *     // Could return a custom error message or retry
+   *     throw error;
+   *   }
+   * }
+   * ```
+   *
+   * @example Authentication
+   * ```ts
+   * wrapToolCall: async (request, handler) => {
+   *   // Check if user is authorized for this tool
+   *   if (!request.runtime.context.isAuthorized(request.tool.name)) {
+   *     return new ToolMessage({
+   *       content: "Unauthorized to call this tool",
+   *       tool_call_id: request.toolCall.id,
+   *     });
+   *   }
+   *   return handler(request);
+   * }
+   * ```
+   */
+  wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * Wraps the model invocation with custom logic. This allows you to:
+   * - Modify the request before calling the model
+   * - Handle errors and retry with different parameters
+   * - Post-process the response
+   * - Implement custom caching, logging, or other cross-cutting concerns
+   *
+   * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.
+   *
+   * @param request - The model request containing all the parameters needed.
+   * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.
+   * @returns The response from the model (or a modified version).
+   *
+   * @example
+   * ```ts
+   * wrapModelCall: async (request, handler) => {
+   *   // Modify request before calling
+   *   const modifiedRequest = { ...request, systemPrompt: "You are helpful" };
+   *
+   *   try {
+   *     // Call the model
+   *     return await handler(modifiedRequest);
+   *   } catch (error) {
+   *     // Handle errors and retry with fallback
+   *     const fallbackRequest = { ...request, model: fallbackModel };
+   *     return await handler(fallbackRequest);
+   *   }
+   * }
+   * ```
+   */
+  wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.
+   * It allows to modify the state of the agent before any model calls or tool executions.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.
+   * It allows to modify the state of the agent.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run after the model call. This function is called after the model is invoked and before any tools are called.
+   * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.
+   * It allows to modify the final state of the agent after all model calls and tool executions are complete.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+}): AgentMiddleware<TSchema, TContextSchema, any>;
+type NormalizeContextSchema<TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodDefault<any> ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodOptional<any> ? Partial<InferInteropZodOutput<TContextSchema>> : never;
+//#endregion
+export { createMiddleware };
+//# sourceMappingURL=middleware.d.cts.map

package/dist/agents/middleware.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.cts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodOutput","ClientTool","ServerTool","AgentMiddleware","WrapToolCallHook","WrapModelCallHook","BeforeAgentHook","BeforeModelHook","AfterModelHook","AfterAgentHook","createMiddleware","TSchema","TContextSchema","NormalizeContextSchema","Partial"],"sources":["../../src/agents/middleware.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"./tools.js\";\nimport type { AgentMiddleware, WrapToolCallHook, WrapModelCallHook, BeforeAgentHook, BeforeModelHook, AfterModelHook, AfterAgentHook } from \"./middleware/types.js\";\n/**\n * Creates a middleware instance with automatic schema inference.\n *\n * @param config - Middleware configuration\n * @param config.name - The name of the middleware\n * @param config.stateSchema - The schema of the middleware state\n * @param config.contextSchema - The schema of the middleware context\n * @param config.wrapModelCall - The function to wrap model invocation\n * @param config.wrapToolCall - The function to wrap tool invocation\n * @param config.beforeModel - The function to run before the model call\n * @param config.afterModel - The function to run after the model call\n * @param config.beforeAgent - The function to run before the agent execution starts\n * @param config.afterAgent - The function to run after the agent execution completes\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * const authMiddleware = createMiddleware({\n *   name: \"AuthMiddleware\",\n *   stateSchema: z.object({\n *     isAuthenticated: z.boolean().default(false),\n *   }),\n *   contextSchema: z.object({\n *     userId: z.string(),\n *   }),\n *   beforeModel: async (state, runtime, controls) => {\n *     if (!state.isAuthenticated) {\n *       return controls.terminate(new Error(\"Not authenticated\"));\n *     }\n *   },\n * });\n * ```\n */\nexport declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined>(config: {\n    /**\n     * The name of the middleware\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n     *\n     * @param request - The model request containing all the parameters needed.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}): AgentMiddleware<TSchema, TContextSchema, any>;\ntype NormalizeContextSchema<TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodDefault<any> ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodOptional<any> ? Partial<InferInteropZodOutput<TContextSchema>> : never;\nexport {};\n"],"mappings":";;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4IgCc,iBA5IRD,gBA4IQC,CAAAA,gBA5IyBd,gBA4IzBc,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,uBA5I0Fd,gBA4I1Fc,GA5I6GZ,kBA4I7GY,CA5IgId,gBA4IhIc,CAAAA,GA5IoJb,iBA4IpJa,CA5IsKd,gBA4ItKc,CAAAA,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,CAAAA,MAAAA,EAAAA;EAAO;;;EAAR,IACXA,EAAAA,MAAAA;EAAO;;AAAR;AAA+B;;;;EACuD,WAAnCZ,CAAAA,EAlIpDY,OAkIoDZ;EAAkB;;;;;;;EAAoL,aAASD,CAAAA,EA1HjQc,cA0HiQd;EAAiB;;;EAA8D,KAASC,CAAAA,EAAAA,CAtHhWE,UAsHgWF,GAtHnVG,UAsHmVH,CAAAA,EAAAA;EAAkB;;;AAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArE3XK,iBAAiBO,SAASE,uBAAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BhDP,kBAAkBM,SAASE,uBAAuBD;;;;;;;;;gBASpDN,gBAAgBK,SAASE,uBAAuBD;;;;;;;;;gBAShDL,gBAAgBI,SAASE,uBAAuBD;;;;;;;;;eASjDJ,eAAeG,SAASE,uBAAuBD;;;;;;;;;eAS/CH,eAAeE,SAASE,uBAAuBD;IAC5DT,gBAAgBQ,SAASC;KACxBC,8CAA8ChB,mBAAmBE,mBAAmBF,oBAAoBC,kBAAkBD,6CAA6Ce,uBAAuBf,mBAAmBG,sBAAsBY,kBAAkBA,uBAAuBd,yBAAyBE,sBAAsBY,kBAAkBA,uBAAuBb,0BAA0Be,QAAQd,sBAAsBY"}

package/dist/agents/middleware.d.ts

@@ -0,0 +1,185 @@
+import { ClientTool, ServerTool } from "./tools.js";
+import { AfterAgentHook, AfterModelHook, AgentMiddleware, BeforeAgentHook, BeforeModelHook, WrapModelCallHook, WrapToolCallHook } from "./middleware/types.js";
+import { InferInteropZodOutput, InteropZodDefault, InteropZodObject, InteropZodOptional } from "@langchain/core/utils/types";
+
+//#region src/agents/middleware.d.ts
+
+/**
+ * Creates a middleware instance with automatic schema inference.
+ *
+ * @param config - Middleware configuration
+ * @param config.name - The name of the middleware
+ * @param config.stateSchema - The schema of the middleware state
+ * @param config.contextSchema - The schema of the middleware context
+ * @param config.wrapModelCall - The function to wrap model invocation
+ * @param config.wrapToolCall - The function to wrap tool invocation
+ * @param config.beforeModel - The function to run before the model call
+ * @param config.afterModel - The function to run after the model call
+ * @param config.beforeAgent - The function to run before the agent execution starts
+ * @param config.afterAgent - The function to run after the agent execution completes
+ * @returns A middleware instance
+ *
+ * @example
+ * ```ts
+ * const authMiddleware = createMiddleware({
+ *   name: "AuthMiddleware",
+ *   stateSchema: z.object({
+ *     isAuthenticated: z.boolean().default(false),
+ *   }),
+ *   contextSchema: z.object({
+ *     userId: z.string(),
+ *   }),
+ *   beforeModel: async (state, runtime, controls) => {
+ *     if (!state.isAuthenticated) {
+ *       return controls.terminate(new Error("Not authenticated"));
+ *     }
+ *   },
+ * });
+ * ```
+ */
+declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined>(config: {
+  /**
+   * The name of the middleware
+   */
+  name: string;
+  /**
+   * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
+  stateSchema?: TSchema;
+  /**
+   * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
+  contextSchema?: TContextSchema;
+  /**
+   * Additional tools registered by the middleware.
+   */
+  tools?: (ClientTool | ServerTool)[];
+  /**
+   * Wraps tool execution with custom logic. This allows you to:
+   * - Modify tool call parameters before execution
+   * - Handle errors and retry with different parameters
+   * - Post-process tool results
+   * - Implement caching, logging, authentication, or other cross-cutting concerns
+   * - Return Command objects for advanced control flow
+   *
+   * The handler receives a ToolCallRequest containing the tool call, state, and runtime,
+   * along with a handler function to execute the actual tool.
+   *
+   * @param request - The tool call request containing toolCall, state, and runtime.
+   * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.
+   * @returns The tool result as a ToolMessage or a Command for advanced control flow.
+   *
+   * @example
+   * ```ts
+   * wrapToolCall: async (request, handler) => {
+   *   console.log(`Calling tool: ${request.tool.name}`);
+   *   console.log(`Tool description: ${request.tool.description}`);
+   *
+   *   try {
+   *     // Execute the tool
+   *     const result = await handler(request);
+   *     console.log(`Tool ${request.tool.name} succeeded`);
+   *     return result;
+   *   } catch (error) {
+   *     console.error(`Tool ${request.tool.name} failed:`, error);
+   *     // Could return a custom error message or retry
+   *     throw error;
+   *   }
+   * }
+   * ```
+   *
+   * @example Authentication
+   * ```ts
+   * wrapToolCall: async (request, handler) => {
+   *   // Check if user is authorized for this tool
+   *   if (!request.runtime.context.isAuthorized(request.tool.name)) {
+   *     return new ToolMessage({
+   *       content: "Unauthorized to call this tool",
+   *       tool_call_id: request.toolCall.id,
+   *     });
+   *   }
+   *   return handler(request);
+   * }
+   * ```
+   */
+  wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * Wraps the model invocation with custom logic. This allows you to:
+   * - Modify the request before calling the model
+   * - Handle errors and retry with different parameters
+   * - Post-process the response
+   * - Implement custom caching, logging, or other cross-cutting concerns
+   *
+   * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.
+   *
+   * @param request - The model request containing all the parameters needed.
+   * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.
+   * @returns The response from the model (or a modified version).
+   *
+   * @example
+   * ```ts
+   * wrapModelCall: async (request, handler) => {
+   *   // Modify request before calling
+   *   const modifiedRequest = { ...request, systemPrompt: "You are helpful" };
+   *
+   *   try {
+   *     // Call the model
+   *     return await handler(modifiedRequest);
+   *   } catch (error) {
+   *     // Handle errors and retry with fallback
+   *     const fallbackRequest = { ...request, model: fallbackModel };
+   *     return await handler(fallbackRequest);
+   *   }
+   * }
+   * ```
+   */
+  wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.
+   * It allows to modify the state of the agent before any model calls or tool executions.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.
+   * It allows to modify the state of the agent.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run after the model call. This function is called after the model is invoked and before any tools are called.
+   * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+  /**
+   * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.
+   * It allows to modify the final state of the agent after all model calls and tool executions are complete.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;
+}): AgentMiddleware<TSchema, TContextSchema, any>;
+type NormalizeContextSchema<TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodDefault<any> ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodOptional<any> ? Partial<InferInteropZodOutput<TContextSchema>> : never;
+//#endregion
+export { createMiddleware };
+//# sourceMappingURL=middleware.d.ts.map

package/dist/agents/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodOutput","ClientTool","ServerTool","AgentMiddleware","WrapToolCallHook","WrapModelCallHook","BeforeAgentHook","BeforeModelHook","AfterModelHook","AfterAgentHook","createMiddleware","TSchema","TContextSchema","NormalizeContextSchema","Partial"],"sources":["../../src/agents/middleware.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"./tools.js\";\nimport type { AgentMiddleware, WrapToolCallHook, WrapModelCallHook, BeforeAgentHook, BeforeModelHook, AfterModelHook, AfterAgentHook } from \"./middleware/types.js\";\n/**\n * Creates a middleware instance with automatic schema inference.\n *\n * @param config - Middleware configuration\n * @param config.name - The name of the middleware\n * @param config.stateSchema - The schema of the middleware state\n * @param config.contextSchema - The schema of the middleware context\n * @param config.wrapModelCall - The function to wrap model invocation\n * @param config.wrapToolCall - The function to wrap tool invocation\n * @param config.beforeModel - The function to run before the model call\n * @param config.afterModel - The function to run after the model call\n * @param config.beforeAgent - The function to run before the agent execution starts\n * @param config.afterAgent - The function to run after the agent execution completes\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * const authMiddleware = createMiddleware({\n *   name: \"AuthMiddleware\",\n *   stateSchema: z.object({\n *     isAuthenticated: z.boolean().default(false),\n *   }),\n *   contextSchema: z.object({\n *     userId: z.string(),\n *   }),\n *   beforeModel: async (state, runtime, controls) => {\n *     if (!state.isAuthenticated) {\n *       return controls.terminate(new Error(\"Not authenticated\"));\n *     }\n *   },\n * });\n * ```\n */\nexport declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined>(config: {\n    /**\n     * The name of the middleware\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n     *\n     * @param request - The model request containing all the parameters needed.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}): AgentMiddleware<TSchema, TContextSchema, any>;\ntype NormalizeContextSchema<TContextSchema extends InteropZodObject | InteropZodOptional<InteropZodObject> | InteropZodDefault<InteropZodObject> | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodDefault<any> ? InferInteropZodOutput<TContextSchema> : TContextSchema extends InteropZodOptional<any> ? Partial<InferInteropZodOutput<TContextSchema>> : never;\nexport {};\n"],"mappings":";;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4IgCc,iBA5IRD,gBA4IQC,CAAAA,gBA5IyBd,gBA4IzBc,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,uBA5I0Fd,gBA4I1Fc,GA5I6GZ,kBA4I7GY,CA5IgId,gBA4IhIc,CAAAA,GA5IoJb,iBA4IpJa,CA5IsKd,gBA4ItKc,CAAAA,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,CAAAA,MAAAA,EAAAA;EAAO;;;EAAR,IACXA,EAAAA,MAAAA;EAAO;;AAAR;AAA+B;;;;EACuD,WAAnCZ,CAAAA,EAlIpDY,OAkIoDZ;EAAkB;;;;;;;EAAoL,aAASD,CAAAA,EA1HjQc,cA0HiQd;EAAiB;;;EAA8D,KAASC,CAAAA,EAAAA,CAtHhWE,UAsHgWF,GAtHnVG,UAsHmVH,CAAAA,EAAAA;EAAkB;;;AAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArE3XK,iBAAiBO,SAASE,uBAAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BhDP,kBAAkBM,SAASE,uBAAuBD;;;;;;;;;gBASpDN,gBAAgBK,SAASE,uBAAuBD;;;;;;;;;gBAShDL,gBAAgBI,SAASE,uBAAuBD;;;;;;;;;eASjDJ,eAAeG,SAASE,uBAAuBD;;;;;;;;;eAS/CH,eAAeE,SAASE,uBAAuBD;IAC5DT,gBAAgBQ,SAASC;KACxBC,8CAA8ChB,mBAAmBE,mBAAmBF,oBAAoBC,kBAAkBD,6CAA6Ce,uBAAuBf,mBAAmBG,sBAAsBY,kBAAkBA,uBAAuBd,yBAAyBE,sBAAsBY,kBAAkBA,uBAAuBb,0BAA0Be,QAAQd,sBAAsBY"}

package/dist/agents/{middlewareAgent/middleware.js → middleware.js}

@@ -1,4 +1,4 @@
-//#region src/agents/middlewareAgent/middleware.ts
+//#region src/agents/middleware.ts
 /**
 * Creates a middleware instance with automatic schema inference.
 *
@@ -6,9 +6,12 @@
 * @param config.name - The name of the middleware
 * @param config.stateSchema - The schema of the middleware state
 * @param config.contextSchema - The schema of the middleware context
-* @param config.modifyModelRequest - The function to prepare the model request
+* @param config.wrapModelCall - The function to wrap model invocation
+* @param config.wrapToolCall - The function to wrap tool invocation
 * @param config.beforeModel - The function to run before the model call
 * @param config.afterModel - The function to run after the model call
+* @param config.beforeAgent - The function to run before the agent execution starts
+* @param config.afterAgent - The function to run after the agent execution completes
 * @returns A middleware instance
 *
 * @example
@@ -34,14 +37,14 @@ function createMiddleware(config) {
 		name: config.name,
 		stateSchema: config.stateSchema,
 		contextSchema: config.contextSchema,
-		beforeModelJumpTo: config.beforeModelJumpTo,
-		afterModelJumpTo: config.afterModelJumpTo,
+		wrapToolCall: config.wrapToolCall,
+		wrapModelCall: config.wrapModelCall,
+		beforeAgent: config.beforeAgent,
+		beforeModel: config.beforeModel,
+		afterModel: config.afterModel,
+		afterAgent: config.afterAgent,
 		tools: config.tools ?? []
 	};
-	if (config.modifyModelRequest) middleware.modifyModelRequest = async (options, state, runtime) => Promise.resolve(config.modifyModelRequest(options, state, runtime));
-	if (config.retryModelRequest) middleware.retryModelRequest = async (error, request, state, runtime, attempt) => Promise.resolve(config.retryModelRequest(error, request, state, runtime, attempt));
-	if (config.beforeModel) middleware.beforeModel = async (state, runtime) => Promise.resolve(config.beforeModel(state, runtime));
-	if (config.afterModel) middleware.afterModel = async (state, runtime) => Promise.resolve(config.afterModel(state, runtime));
 	return middleware;
 }
 

package/dist/agents/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","names":["config: {\n  /**\n   * The name of the middleware\n   */\n  name: string;\n  /**\n   * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n   * - A Zod object\n   * - A Zod optional object\n   * - A Zod default object\n   * - Undefined\n   */\n  stateSchema?: TSchema;\n  /**\n   * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n   * - A Zod object\n   * - A Zod optional object\n   * - A Zod default object\n   * - Undefined\n   */\n  contextSchema?: TContextSchema;\n  /**\n   * Additional tools registered by the middleware.\n   */\n  tools?: (ClientTool | ServerTool)[];\n  /**\n   * Wraps tool execution with custom logic. This allows you to:\n   * - Modify tool call parameters before execution\n   * - Handle errors and retry with different parameters\n   * - Post-process tool results\n   * - Implement caching, logging, authentication, or other cross-cutting concerns\n   * - Return Command objects for advanced control flow\n   *\n   * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n   * along with a handler function to execute the actual tool.\n   *\n   * @param request - The tool call request containing toolCall, state, and runtime.\n   * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n   * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n   *\n   * @example\n   * ```ts\n   * wrapToolCall: async (request, handler) => {\n   *   console.log(`Calling tool: ${request.tool.name}`);\n   *   console.log(`Tool description: ${request.tool.description}`);\n   *\n   *   try {\n   *     // Execute the tool\n   *     const result = await handler(request);\n   *     console.log(`Tool ${request.tool.name} succeeded`);\n   *     return result;\n   *   } catch (error) {\n   *     console.error(`Tool ${request.tool.name} failed:`, error);\n   *     // Could return a custom error message or retry\n   *     throw error;\n   *   }\n   * }\n   * ```\n   *\n   * @example Authentication\n   * ```ts\n   * wrapToolCall: async (request, handler) => {\n   *   // Check if user is authorized for this tool\n   *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n   *     return new ToolMessage({\n   *       content: \"Unauthorized to call this tool\",\n   *       tool_call_id: request.toolCall.id,\n   *     });\n   *   }\n   *   return handler(request);\n   * }\n   * ```\n   */\n  wrapToolCall?: WrapToolCallHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * Wraps the model invocation with custom logic. This allows you to:\n   * - Modify the request before calling the model\n   * - Handle errors and retry with different parameters\n   * - Post-process the response\n   * - Implement custom caching, logging, or other cross-cutting concerns\n   *\n   * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n   *\n   * @param request - The model request containing all the parameters needed.\n   * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n   * @returns The response from the model (or a modified version).\n   *\n   * @example\n   * ```ts\n   * wrapModelCall: async (request, handler) => {\n   *   // Modify request before calling\n   *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n   *\n   *   try {\n   *     // Call the model\n   *     return await handler(modifiedRequest);\n   *   } catch (error) {\n   *     // Handle errors and retry with fallback\n   *     const fallbackRequest = { ...request, model: fallbackModel };\n   *     return await handler(fallbackRequest);\n   *   }\n   * }\n   * ```\n   */\n  wrapModelCall?: WrapModelCallHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n  /**\n   * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n   * It allows to modify the state of the agent before any model calls or tool executions.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  beforeAgent?: BeforeAgentHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n   * It allows to modify the state of the agent.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  beforeModel?: BeforeModelHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n   * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n\n  /**\n   * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n   * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}","middleware: AgentMiddleware<TSchema, TContextSchema, any>"],"sources":["../../src/agents/middleware.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  InteropZodObject,\n  InteropZodDefault,\n  InteropZodOptional,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\nimport type { ClientTool, ServerTool } from \"./tools.js\";\nimport type {\n  AgentMiddleware,\n  WrapToolCallHook,\n  WrapModelCallHook,\n  BeforeAgentHook,\n  BeforeModelHook,\n  AfterModelHook,\n  AfterAgentHook,\n} from \"./middleware/types.js\";\n\n/**\n * Creates a middleware instance with automatic schema inference.\n *\n * @param config - Middleware configuration\n * @param config.name - The name of the middleware\n * @param config.stateSchema - The schema of the middleware state\n * @param config.contextSchema - The schema of the middleware context\n * @param config.wrapModelCall - The function to wrap model invocation\n * @param config.wrapToolCall - The function to wrap tool invocation\n * @param config.beforeModel - The function to run before the model call\n * @param config.afterModel - The function to run after the model call\n * @param config.beforeAgent - The function to run before the agent execution starts\n * @param config.afterAgent - The function to run after the agent execution completes\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * const authMiddleware = createMiddleware({\n *   name: \"AuthMiddleware\",\n *   stateSchema: z.object({\n *     isAuthenticated: z.boolean().default(false),\n *   }),\n *   contextSchema: z.object({\n *     userId: z.string(),\n *   }),\n *   beforeModel: async (state, runtime, controls) => {\n *     if (!state.isAuthenticated) {\n *       return controls.terminate(new Error(\"Not authenticated\"));\n *     }\n *   },\n * });\n * ```\n */\nexport function createMiddleware<\n  TSchema extends InteropZodObject | undefined = undefined,\n  TContextSchema extends\n    | InteropZodObject\n    | InteropZodOptional<InteropZodObject>\n    | InteropZodDefault<InteropZodObject>\n    | undefined = undefined\n>(config: {\n  /**\n   * The name of the middleware\n   */\n  name: string;\n  /**\n   * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n   * - A Zod object\n   * - A Zod optional object\n   * - A Zod default object\n   * - Undefined\n   */\n  stateSchema?: TSchema;\n  /**\n   * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n   * - A Zod object\n   * - A Zod optional object\n   * - A Zod default object\n   * - Undefined\n   */\n  contextSchema?: TContextSchema;\n  /**\n   * Additional tools registered by the middleware.\n   */\n  tools?: (ClientTool | ServerTool)[];\n  /**\n   * Wraps tool execution with custom logic. This allows you to:\n   * - Modify tool call parameters before execution\n   * - Handle errors and retry with different parameters\n   * - Post-process tool results\n   * - Implement caching, logging, authentication, or other cross-cutting concerns\n   * - Return Command objects for advanced control flow\n   *\n   * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n   * along with a handler function to execute the actual tool.\n   *\n   * @param request - The tool call request containing toolCall, state, and runtime.\n   * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n   * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n   *\n   * @example\n   * ```ts\n   * wrapToolCall: async (request, handler) => {\n   *   console.log(`Calling tool: ${request.tool.name}`);\n   *   console.log(`Tool description: ${request.tool.description}`);\n   *\n   *   try {\n   *     // Execute the tool\n   *     const result = await handler(request);\n   *     console.log(`Tool ${request.tool.name} succeeded`);\n   *     return result;\n   *   } catch (error) {\n   *     console.error(`Tool ${request.tool.name} failed:`, error);\n   *     // Could return a custom error message or retry\n   *     throw error;\n   *   }\n   * }\n   * ```\n   *\n   * @example Authentication\n   * ```ts\n   * wrapToolCall: async (request, handler) => {\n   *   // Check if user is authorized for this tool\n   *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n   *     return new ToolMessage({\n   *       content: \"Unauthorized to call this tool\",\n   *       tool_call_id: request.toolCall.id,\n   *     });\n   *   }\n   *   return handler(request);\n   * }\n   * ```\n   */\n  wrapToolCall?: WrapToolCallHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * Wraps the model invocation with custom logic. This allows you to:\n   * - Modify the request before calling the model\n   * - Handle errors and retry with different parameters\n   * - Post-process the response\n   * - Implement custom caching, logging, or other cross-cutting concerns\n   *\n   * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n   *\n   * @param request - The model request containing all the parameters needed.\n   * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n   * @returns The response from the model (or a modified version).\n   *\n   * @example\n   * ```ts\n   * wrapModelCall: async (request, handler) => {\n   *   // Modify request before calling\n   *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n   *\n   *   try {\n   *     // Call the model\n   *     return await handler(modifiedRequest);\n   *   } catch (error) {\n   *     // Handle errors and retry with fallback\n   *     const fallbackRequest = { ...request, model: fallbackModel };\n   *     return await handler(fallbackRequest);\n   *   }\n   * }\n   * ```\n   */\n  wrapModelCall?: WrapModelCallHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n  /**\n   * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n   * It allows to modify the state of the agent before any model calls or tool executions.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  beforeAgent?: BeforeAgentHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n   * It allows to modify the state of the agent.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  beforeModel?: BeforeModelHook<\n    TSchema,\n    NormalizeContextSchema<TContextSchema>\n  >;\n\n  /**\n   * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n   * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n\n  /**\n   * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n   * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n   *\n   * @param state - The middleware state\n   * @param runtime - The middleware runtime\n   * @returns The modified middleware state or undefined to pass through\n   */\n  afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}): AgentMiddleware<TSchema, TContextSchema, any> {\n  const middleware: AgentMiddleware<TSchema, TContextSchema, any> = {\n    name: config.name,\n    stateSchema: config.stateSchema,\n    contextSchema: config.contextSchema,\n    wrapToolCall: config.wrapToolCall,\n    wrapModelCall: config.wrapModelCall,\n    beforeAgent: config.beforeAgent,\n    beforeModel: config.beforeModel,\n    afterModel: config.afterModel,\n    afterAgent: config.afterAgent,\n    tools: config.tools ?? [],\n  };\n\n  return middleware;\n}\n\ntype NormalizeContextSchema<\n  TContextSchema extends\n    | InteropZodObject\n    | InteropZodOptional<InteropZodObject>\n    | InteropZodDefault<InteropZodObject>\n    | undefined = undefined\n> = TContextSchema extends InteropZodObject\n  ? InferInteropZodOutput<TContextSchema>\n  : TContextSchema extends InteropZodDefault<any>\n  ? InferInteropZodOutput<TContextSchema>\n  : TContextSchema extends InteropZodOptional<any>\n  ? Partial<InferInteropZodOutput<TContextSchema>>\n  : never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,iBAOdA,QA6JgD;CAChD,MAAMC,aAA4D;EAChE,MAAM,OAAO;EACb,aAAa,OAAO;EACpB,eAAe,OAAO;EACtB,cAAc,OAAO;EACrB,eAAe,OAAO;EACtB,aAAa,OAAO;EACpB,aAAa,OAAO;EACpB,YAAY,OAAO;EACnB,YAAY,OAAO;EACnB,OAAO,OAAO,SAAS,CAAE;CAC1B;AAED,QAAO;AACR"}

package/dist/agents/nodes/AfterAgentNode.cjs

@@ -0,0 +1,29 @@
+const require_utils = require('../middleware/utils.cjs');
+const require_middleware = require('./middleware.cjs');
+
+//#region src/agents/nodes/AfterAgentNode.ts
+/**
+* Node for executing a single middleware's afterAgent hook.
+*/
+var AfterAgentNode = class extends require_middleware.MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterAgentNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterAgentNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		const fn = require_utils.getHookFunction(this.middleware.afterAgent);
+		return fn(state, runtime);
+	}
+};
+
+//#endregion
+exports.AfterAgentNode = AfterAgentNode;
+//# sourceMappingURL=AfterAgentNode.cjs.map

package/dist/agents/nodes/AfterAgentNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AfterAgentNode.cjs","names":["MiddlewareNode","middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >","options: MiddlewareNodeOptions","state: TStateSchema","config?: RunnableConfig<TContextSchema>","runtime: Runtime<TContextSchema>","getHookFunction"],"sources":["../../../src/agents/nodes/AfterAgentNode.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { MiddlewareNode, MiddlewareNodeOptions } from \"./middleware.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\nimport { getHookFunction } from \"../middleware/utils.js\";\n\n/**\n * Node for executing a single middleware's afterAgent hook.\n */\nexport class AfterAgentNode<\n  TStateSchema extends Record<string, unknown> = Record<string, unknown>,\n  TContextSchema extends Record<string, unknown> = Record<string, unknown>\n> extends MiddlewareNode<TStateSchema, TContextSchema> {\n  lc_namespace = [\"langchain\", \"agents\", \"afterAgentNodes\"];\n\n  constructor(\n    public middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >,\n    options: MiddlewareNodeOptions\n  ) {\n    super(\n      {\n        name: `AfterAgentNode_${middleware.name}`,\n        func: async (\n          state: TStateSchema,\n          config?: RunnableConfig<TContextSchema>\n        ) => this.invokeMiddleware(state, config),\n      },\n      options\n    );\n  }\n\n  runHook(state: TStateSchema, runtime: Runtime<TContextSchema>) {\n    const fn = getHookFunction(this.middleware.afterAgent!);\n    return fn(\n      state as Record<string, unknown> & AgentBuiltInState,\n      runtime as Runtime<unknown>\n    ) as Promise<MiddlewareResult<TStateSchema>>;\n  }\n}\n"],"mappings":";;;;;;;AAUA,IAAa,iBAAb,cAGUA,kCAA6C;CACrD,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,YACSC,YAIPC,SACA;EACA,MACE;GACE,MAAM,CAAC,eAAe,EAAE,WAAW,MAAM;GACzC,MAAM,OACJC,OACAC,WACG,KAAK,iBAAiB,OAAO,OAAO;EAC1C,GACD,QACD;EAfM;CAgBR;CAED,QAAQD,OAAqBE,SAAkC;EAC7D,MAAM,KAAKC,8BAAgB,KAAK,WAAW,WAAY;AACvD,SAAO,GACL,OACA,QACD;CACF;AACF"}

package/dist/agents/nodes/AfterAgentNode.js

@@ -0,0 +1,29 @@
+import { getHookFunction } from "../middleware/utils.js";
+import { MiddlewareNode } from "./middleware.js";
+
+//#region src/agents/nodes/AfterAgentNode.ts
+/**
+* Node for executing a single middleware's afterAgent hook.
+*/
+var AfterAgentNode = class extends MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterAgentNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterAgentNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		const fn = getHookFunction(this.middleware.afterAgent);
+		return fn(state, runtime);
+	}
+};
+
+//#endregion
+export { AfterAgentNode };
+//# sourceMappingURL=AfterAgentNode.js.map

package/dist/agents/nodes/AfterAgentNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AfterAgentNode.js","names":["middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >","options: MiddlewareNodeOptions","state: TStateSchema","config?: RunnableConfig<TContextSchema>","runtime: Runtime<TContextSchema>"],"sources":["../../../src/agents/nodes/AfterAgentNode.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { MiddlewareNode, MiddlewareNodeOptions } from \"./middleware.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\nimport { getHookFunction } from \"../middleware/utils.js\";\n\n/**\n * Node for executing a single middleware's afterAgent hook.\n */\nexport class AfterAgentNode<\n  TStateSchema extends Record<string, unknown> = Record<string, unknown>,\n  TContextSchema extends Record<string, unknown> = Record<string, unknown>\n> extends MiddlewareNode<TStateSchema, TContextSchema> {\n  lc_namespace = [\"langchain\", \"agents\", \"afterAgentNodes\"];\n\n  constructor(\n    public middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >,\n    options: MiddlewareNodeOptions\n  ) {\n    super(\n      {\n        name: `AfterAgentNode_${middleware.name}`,\n        func: async (\n          state: TStateSchema,\n          config?: RunnableConfig<TContextSchema>\n        ) => this.invokeMiddleware(state, config),\n      },\n      options\n    );\n  }\n\n  runHook(state: TStateSchema, runtime: Runtime<TContextSchema>) {\n    const fn = getHookFunction(this.middleware.afterAgent!);\n    return fn(\n      state as Record<string, unknown> & AgentBuiltInState,\n      runtime as Runtime<unknown>\n    ) as Promise<MiddlewareResult<TStateSchema>>;\n  }\n}\n"],"mappings":";;;;;;;AAUA,IAAa,iBAAb,cAGU,eAA6C;CACrD,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,YACSA,YAIPC,SACA;EACA,MACE;GACE,MAAM,CAAC,eAAe,EAAE,WAAW,MAAM;GACzC,MAAM,OACJC,OACAC,WACG,KAAK,iBAAiB,OAAO,OAAO;EAC1C,GACD,QACD;EAfM;CAgBR;CAED,QAAQD,OAAqBE,SAAkC;EAC7D,MAAM,KAAK,gBAAgB,KAAK,WAAW,WAAY;AACvD,SAAO,GACL,OACA,QACD;CACF;AACF"}

package/dist/agents/{middlewareAgent/nodes/AfterModalNode.cjs → nodes/AfterModelNode.cjs}

@@ -1,6 +1,7 @@
+const require_utils = require('../middleware/utils.cjs');
 const require_middleware = require('./middleware.cjs');
 
-//#region src/agents/middlewareAgent/nodes/AfterModalNode.ts
+//#region src/agents/nodes/AfterModelNode.ts
 /**
 * Node for executing a single middleware's afterModel hook.
 */
@@ -8,22 +9,21 @@ var AfterModelNode = class extends require_middleware.MiddlewareNode {
 	lc_namespace = [
 		"langchain",
 		"agents",
-		"afterModalNodes"
+		"afterModelNodes"
 	];
-	name;
 	constructor(middleware, options) {
 		super({
 			name: `AfterModelNode_${middleware.name}`,
 			func: async (state, config) => this.invokeMiddleware(state, config)
 		}, options);
 		this.middleware = middleware;
-		this.name = `AfterModelNode_${middleware.name}`;
 	}
 	runHook(state, runtime) {
-		return this.middleware.afterModel(state, runtime);
+		const fn = require_utils.getHookFunction(this.middleware.afterModel);
+		return fn(state, runtime);
 	}
 };
 
 //#endregion
 exports.AfterModelNode = AfterModelNode;
-//# sourceMappingURL=AfterModalNode.cjs.map
+//# sourceMappingURL=AfterModelNode.cjs.map

package/dist/agents/nodes/AfterModelNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AfterModelNode.cjs","names":["MiddlewareNode","middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >","options: MiddlewareNodeOptions","state: TStateSchema","config?: RunnableConfig<TContextSchema>","runtime: Runtime<TContextSchema>","getHookFunction"],"sources":["../../../src/agents/nodes/AfterModelNode.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { MiddlewareNode, MiddlewareNodeOptions } from \"./middleware.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\nimport { getHookFunction } from \"../middleware/utils.js\";\n\n/**\n * Node for executing a single middleware's afterModel hook.\n */\nexport class AfterModelNode<\n  TStateSchema extends Record<string, unknown> = Record<string, unknown>,\n  TContextSchema extends Record<string, unknown> = Record<string, unknown>\n> extends MiddlewareNode<TStateSchema, TContextSchema> {\n  lc_namespace = [\"langchain\", \"agents\", \"afterModelNodes\"];\n\n  constructor(\n    public middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >,\n    options: MiddlewareNodeOptions\n  ) {\n    super(\n      {\n        name: `AfterModelNode_${middleware.name}`,\n        func: async (\n          state: TStateSchema,\n          config?: RunnableConfig<TContextSchema>\n        ) => this.invokeMiddleware(state, config),\n      },\n      options\n    );\n  }\n\n  runHook(state: TStateSchema, runtime: Runtime<TContextSchema>) {\n    const fn = getHookFunction(this.middleware.afterModel!);\n    return fn(\n      state as Record<string, unknown> & AgentBuiltInState,\n      runtime as Runtime<unknown>\n    ) as Promise<MiddlewareResult<TStateSchema>>;\n  }\n}\n"],"mappings":";;;;;;;AAUA,IAAa,iBAAb,cAGUA,kCAA6C;CACrD,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,YACSC,YAIPC,SACA;EACA,MACE;GACE,MAAM,CAAC,eAAe,EAAE,WAAW,MAAM;GACzC,MAAM,OACJC,OACAC,WACG,KAAK,iBAAiB,OAAO,OAAO;EAC1C,GACD,QACD;EAfM;CAgBR;CAED,QAAQD,OAAqBE,SAAkC;EAC7D,MAAM,KAAKC,8BAAgB,KAAK,WAAW,WAAY;AACvD,SAAO,GACL,OACA,QACD;CACF;AACF"}