langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

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

@@ -0,0 +1,208 @@
+import { JumpToTarget } from "../constants.js";
+import { ClientTool, ServerTool } from "../tools.js";
+import { AgentBuiltInState, Runtime } from "../runtime.js";
+import { ModelRequest } from "../nodes/types.js";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { AnnotationRoot, Command } from "@langchain/langgraph";
+import { InteropZodToStateDefinition } from "@langchain/langgraph/zod";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodDefault, InteropZodObject, InteropZodOptional } from "@langchain/core/utils/types";
+import { ToolCall as ToolCall$1 } from "@langchain/core/messages/tool";
+
+//#region src/agents/middleware/types.d.ts
+type AnyAnnotationRoot = AnnotationRoot<any>;
+/**
+ * Result type for middleware functions.
+ */
+type MiddlewareResult<TState> = TState | void;
+/**
+ * Represents a tool call request for the wrapToolCall hook.
+ * Contains the tool call information along with the agent's current state and runtime.
+ */
+interface ToolCallRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {
+  /**
+   * The tool call to be executed
+   */
+  toolCall: ToolCall$1;
+  /**
+   * The BaseTool instance being invoked.
+   * Provides access to tool metadata like name, description, schema, etc.
+   */
+  tool: ClientTool | ServerTool;
+  /**
+   * The current agent state (includes both middleware state and built-in state).
+   */
+  state: TState & AgentBuiltInState;
+  /**
+   * The runtime context containing metadata, signal, writer, interrupt, etc.
+   */
+  runtime: Runtime<TContext>;
+}
+/**
+ * Handler function type for wrapping tool calls.
+ * Takes a tool call and returns the tool result or a command.
+ */
+type ToolCallHandler = (toolCall: ToolCall$1) => Promise<ToolMessage | Command> | ToolMessage | Command;
+/**
+ * Wrapper function type for the wrapToolCall hook.
+ * Allows middleware to intercept and modify tool execution.
+ */
+type ToolCallWrapper<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> = (request: ToolCallRequest<TState, TContext>, handler: ToolCallHandler) => Promise<ToolMessage | Command> | ToolMessage | Command;
+/**
+ * Base middleware interface.
+ */
+interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {
+  stateSchema?: TSchema;
+  contextSchema?: TContextSchema;
+  name: string;
+  beforeAgentJumpTo?: JumpToTarget[];
+  beforeModelJumpTo?: JumpToTarget[];
+  afterModelJumpTo?: JumpToTarget[];
+  afterAgentJumpTo?: JumpToTarget[];
+  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 ToolCall 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.toolCall);
+   *     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.toolCall);
+   * }
+   * ```
+   *
+   * @example Caching
+   * ```ts
+   * const cache = new Map();
+   * wrapToolCall: async (request, handler) => {
+   *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;
+   *   if (cache.has(cacheKey)) {
+   *     return cache.get(cacheKey);
+   *   }
+   *   const result = await handler(request.toolCall);
+   *   cache.set(cacheKey, result);
+   *   return result;
+   * }
+   * ```
+   */
+  wrapToolCall?: ToolCallWrapper<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>;
+  /**
+   * 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
+   *
+   * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.
+   * @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?(request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>, handler: (request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>) => Promise<AIMessage> | AIMessage): Promise<AIMessage> | AIMessage;
+  beforeAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
+  beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
+  afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
+  afterAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
+}
+/**
+ * Helper type to filter out properties that start with underscore (private properties)
+ */
+type FilterPrivateProps<T> = { [K in keyof T as K extends `_${string}` ? never : K]: T[K] };
+/**
+ * Helper type to infer the state schema type from a middleware
+ * This filters out private properties (those starting with underscore)
+ */
+type InferMiddlewareState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};
+/**
+ * Helper type to infer the input state schema type from a middleware (all properties optional)
+ * This filters out private properties (those starting with underscore)
+ */
+type InferMiddlewareInputState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};
+/**
+ * Helper type to infer merged state from an array of middleware (just the middleware states)
+ */
+type InferMiddlewareStates<T = AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};
+/**
+ * Helper type to infer merged input state from an array of middleware (with optional defaults)
+ */
+type InferMiddlewareInputStates<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};
+/**
+ * Helper type to infer merged state from an array of middleware (includes built-in state)
+ */
+
+/**
+ * Helper type to infer the input context schema type from a middleware (with optional defaults)
+ */
+type InferMiddlewareContextInput<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};
+/**
+ * Helper type to infer merged context from an array of middleware
+ */
+
+/**
+ * Helper to merge two context types, preserving undefined unions
+ */
+type MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;
+/**
+ * Helper type to infer merged input context from an array of middleware (with optional defaults)
+ */
+type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};
+/**
+ * Helper type to extract input type from context schema (with optional defaults)
+ */
+type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>["State"] : {};
+type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;
+//#endregion
+export { AgentMiddleware, AnyAnnotationRoot, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, MiddlewareResult, ToAnnotationRoot, ToolCallHandler, ToolCallRequest, ToolCallWrapper };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodInput","InferInteropZodOutput","AnnotationRoot","InteropZodToStateDefinition","AIMessage","ToolMessage","ToolCall","Command","JumpToTarget","ClientTool","ServerTool","Runtime","AgentBuiltInState","ModelRequest","AnyAnnotationRoot","MiddlewareResult","TState","ToolCallRequest","Record","TContext","ToolCallHandler","Promise","ToolCallWrapper","AgentMiddleware","TSchema","TContextSchema","TFullContext","Partial","FilterPrivateProps","T","K","InferMiddlewareState","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","InferContextInput","ContextSchema","ToAnnotationRoot"],"sources":["../../../src/agents/middleware/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { AnnotationRoot } from \"@langchain/langgraph\";\nimport type { InteropZodToStateDefinition } from \"@langchain/langgraph/zod\";\nimport type { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { Command } from \"@langchain/langgraph\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { ClientTool, ServerTool } from \"../tools.js\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\nimport type { ModelRequest } from \"../nodes/types.js\";\nexport type AnyAnnotationRoot = AnnotationRoot<any>;\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Represents a tool call request for the wrapToolCall hook.\n * Contains the tool call information along with the agent's current state and runtime.\n */\nexport interface ToolCallRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The tool call to be executed\n     */\n    toolCall: ToolCall;\n    /**\n     * The BaseTool instance being invoked.\n     * Provides access to tool metadata like name, description, schema, etc.\n     */\n    tool: ClientTool | ServerTool;\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n}\n/**\n * Handler function type for wrapping tool calls.\n * Takes a tool call and returns the tool result or a command.\n */\nexport type ToolCallHandler = (toolCall: ToolCall) => Promise<ToolMessage | Command> | ToolMessage | Command;\n/**\n * Wrapper function type for the wrapToolCall hook.\n * Allows middleware to intercept and modify tool execution.\n */\nexport type ToolCallWrapper<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> = (request: ToolCallRequest<TState, TContext>, handler: ToolCallHandler) => Promise<ToolMessage | Command> | ToolMessage | Command;\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {\n    stateSchema?: TSchema;\n    contextSchema?: TContextSchema;\n    name: string;\n    beforeAgentJumpTo?: JumpToTarget[];\n    beforeModelJumpTo?: JumpToTarget[];\n    afterModelJumpTo?: JumpToTarget[];\n    afterAgentJumpTo?: JumpToTarget[];\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 ToolCall 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.toolCall);\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.toolCall);\n     * }\n     * ```\n     *\n     * @example Caching\n     * ```ts\n     * const cache = new Map();\n     * wrapToolCall: async (request, handler) => {\n     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;\n     *   if (cache.has(cacheKey)) {\n     *     return cache.get(cacheKey);\n     *   }\n     *   const result = await handler(request.toolCall);\n     *   cache.set(cacheKey, result);\n     *   return result;\n     * }\n     * ```\n     */\n    wrapToolCall?: ToolCallWrapper<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>;\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     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.\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?(request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>, handler: (request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>) => Promise<AIMessage> | AIMessage): Promise<AIMessage> | AIMessage;\n    beforeAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n}\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T = AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\nexport type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\nexport {};\n"],"mappings":"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"}

package/dist/agents/middleware/utils.cjs

@@ -0,0 +1,26 @@
+
+//#region src/agents/middleware/utils.ts
+/**
+* Default token counter that approximates based on character count
+* @param messages Messages to count tokens for
+* @returns Approximate token count
+*/
+function countTokensApproximately(messages) {
+	let totalChars = 0;
+	for (const msg of messages) {
+		let textContent;
+		if (typeof msg.content === "string") textContent = msg.content;
+		else if (Array.isArray(msg.content)) textContent = msg.content.map((item) => {
+			if (typeof item === "string") return item;
+			if (item.type === "text" && "text" in item) return item.text;
+			return "";
+		}).join("");
+		else textContent = "";
+		totalChars += textContent.length;
+	}
+	return Math.ceil(totalChars / 4);
+}
+
+//#endregion
+exports.countTokensApproximately = countTokensApproximately;
+//# sourceMappingURL=utils.cjs.map

package/dist/agents/middleware/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["messages: BaseMessage[]","textContent: string"],"sources":["../../../src/agents/middleware/utils.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\n\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport function countTokensApproximately(messages: BaseMessage[]): number {\n  let totalChars = 0;\n  for (const msg of messages) {\n    let textContent: string;\n    if (typeof msg.content === \"string\") {\n      textContent = msg.content;\n    } else if (Array.isArray(msg.content)) {\n      textContent = msg.content\n        .map((item) => {\n          if (typeof item === \"string\") return item;\n          if (item.type === \"text\" && \"text\" in item) return item.text;\n          return \"\";\n        })\n        .join(\"\");\n    } else {\n      textContent = \"\";\n    }\n    totalChars += textContent.length;\n  }\n  // Approximate 1 token = 4 characters\n  return Math.ceil(totalChars / 4);\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,yBAAyBA,UAAiC;CACxE,IAAI,aAAa;AACjB,MAAK,MAAM,OAAO,UAAU;EAC1B,IAAIC;AACJ,MAAI,OAAO,IAAI,YAAY,UACzB,cAAc,IAAI;WACT,MAAM,QAAQ,IAAI,QAAQ,EACnC,cAAc,IAAI,QACf,IAAI,CAAC,SAAS;AACb,OAAI,OAAO,SAAS,SAAU,QAAO;AACrC,OAAI,KAAK,SAAS,UAAU,UAAU,KAAM,QAAO,KAAK;AACxD,UAAO;EACR,EAAC,CACD,KAAK,GAAG;OAEX,cAAc;EAEhB,cAAc,YAAY;CAC3B;AAED,QAAO,KAAK,KAAK,aAAa,EAAE;AACjC"}

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

@@ -0,0 +1,13 @@
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/agents/middleware/utils.d.ts
+
+/**
+ * Default token counter that approximates based on character count
+ * @param messages Messages to count tokens for
+ * @returns Approximate token count
+ */
+declare function countTokensApproximately(messages: BaseMessage[]): number;
+//#endregion
+export { countTokensApproximately };
+//# sourceMappingURL=utils.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["BaseMessage","countTokensApproximately"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\n"],"mappings":";;;;;;AAMA;;;iBAAwBC,wBAAAA,WAAmCD"}

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

@@ -0,0 +1,13 @@
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/agents/middleware/utils.d.ts
+
+/**
+ * Default token counter that approximates based on character count
+ * @param messages Messages to count tokens for
+ * @returns Approximate token count
+ */
+declare function countTokensApproximately(messages: BaseMessage[]): number;
+//#endregion
+export { countTokensApproximately };
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["BaseMessage","countTokensApproximately"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\n"],"mappings":";;;;;;AAMA;;;iBAAwBC,wBAAAA,WAAmCD"}

package/dist/agents/middleware/utils.js

@@ -0,0 +1,25 @@
+//#region src/agents/middleware/utils.ts
+/**
+* Default token counter that approximates based on character count
+* @param messages Messages to count tokens for
+* @returns Approximate token count
+*/
+function countTokensApproximately(messages) {
+	let totalChars = 0;
+	for (const msg of messages) {
+		let textContent;
+		if (typeof msg.content === "string") textContent = msg.content;
+		else if (Array.isArray(msg.content)) textContent = msg.content.map((item) => {
+			if (typeof item === "string") return item;
+			if (item.type === "text" && "text" in item) return item.text;
+			return "";
+		}).join("");
+		else textContent = "";
+		totalChars += textContent.length;
+	}
+	return Math.ceil(totalChars / 4);
+}
+
+//#endregion
+export { countTokensApproximately };
+//# sourceMappingURL=utils.js.map

package/dist/agents/middleware/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["messages: BaseMessage[]","textContent: string"],"sources":["../../../src/agents/middleware/utils.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\n\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport function countTokensApproximately(messages: BaseMessage[]): number {\n  let totalChars = 0;\n  for (const msg of messages) {\n    let textContent: string;\n    if (typeof msg.content === \"string\") {\n      textContent = msg.content;\n    } else if (Array.isArray(msg.content)) {\n      textContent = msg.content\n        .map((item) => {\n          if (typeof item === \"string\") return item;\n          if (item.type === \"text\" && \"text\" in item) return item.text;\n          return \"\";\n        })\n        .join(\"\");\n    } else {\n      textContent = \"\";\n    }\n    totalChars += textContent.length;\n  }\n  // Approximate 1 token = 4 characters\n  return Math.ceil(totalChars / 4);\n}\n"],"mappings":";;;;;;AAOA,SAAgB,yBAAyBA,UAAiC;CACxE,IAAI,aAAa;AACjB,MAAK,MAAM,OAAO,UAAU;EAC1B,IAAIC;AACJ,MAAI,OAAO,IAAI,YAAY,UACzB,cAAc,IAAI;WACT,MAAM,QAAQ,IAAI,QAAQ,EACnC,cAAc,IAAI,QACf,IAAI,CAAC,SAAS;AACb,OAAI,OAAO,SAAS,SAAU,QAAO;AACrC,OAAI,KAAK,SAAS,UAAU,UAAU,KAAM,QAAO,KAAK;AACxD,UAAO;EACR,EAAC,CACD,KAAK,GAAG;OAEX,cAAc;EAEhB,cAAc,YAAY;CAC3B;AAED,QAAO,KAAK,KAAK,aAAa,EAAE;AACjC"}

package/dist/agents/middleware.cjs

@@ -0,0 +1,58 @@
+
+//#region src/agents/middleware.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"));
+*     }
+*   },
+* });
+* ```
+*/
+function createMiddleware(config) {
+	const middleware = {
+		name: config.name,
+		stateSchema: config.stateSchema,
+		contextSchema: config.contextSchema,
+		beforeAgentJumpTo: config.beforeAgentJumpTo,
+		beforeModelJumpTo: config.beforeModelJumpTo,
+		afterModelJumpTo: config.afterModelJumpTo,
+		afterAgentJumpTo: config.afterAgentJumpTo,
+		tools: config.tools ?? []
+	};
+	if (config.wrapToolCall) middleware.wrapToolCall = async (request, handler) => Promise.resolve(config.wrapToolCall(request, handler));
+	if (config.wrapModelCall) middleware.wrapModelCall = async (request, handler) => Promise.resolve(config.wrapModelCall(request, handler));
+	if (config.beforeAgent) middleware.beforeAgent = async (state, runtime) => Promise.resolve(config.beforeAgent(state, runtime));
+	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));
+	if (config.afterAgent) middleware.afterAgent = async (state, runtime) => Promise.resolve(config.afterAgent(state, runtime));
+	return middleware;
+}
+
+//#endregion
+exports.createMiddleware = createMiddleware;
+//# sourceMappingURL=middleware.cjs.map

package/dist/agents/middleware.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.cjs","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   * Explitictly defines which targets are allowed to be jumped to from the `beforeAgent` hook.\n   */\n  beforeAgentJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `beforeModel` hook.\n   */\n  beforeModelJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `afterModel` hook.\n   */\n  afterModelJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `afterAgent` hook.\n   */\n  afterAgentJumpTo?: JumpToTarget[];\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 ToolCall 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.toolCall);\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.toolCall);\n   * }\n   * ```\n   */\n  wrapToolCall?: (\n    request: ToolCallRequest<\n      (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) &\n        AgentBuiltInState,\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    >,\n    handler: ToolCallHandler\n  ) => Promise<ToolMessage | Command> | ToolMessage | Command;\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?: (\n    request: ModelRequest<\n      (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) &\n        AgentBuiltInState,\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    >,\n    handler: (\n      request: ModelRequest<\n        (TSchema extends InteropZodObject\n          ? InferInteropZodInput<TSchema>\n          : {}) &\n          AgentBuiltInState,\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      >\n    ) => Promise<AIMessage> | AIMessage\n  ) => Promise<AIMessage> | AIMessage;\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\n        >\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\n        >\n      >;\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  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\nimport type { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport type { Command } from \"@langchain/langgraph\";\n\nimport type { JumpToTarget } from \"./constants.js\";\nimport type { ClientTool, ServerTool } from \"./tools.js\";\nimport type { Runtime, AgentBuiltInState } from \"./runtime.js\";\nimport type {\n  AgentMiddleware,\n  MiddlewareResult,\n  ToolCallRequest,\n  ToolCallHandler,\n} from \"./middleware/types.js\";\nimport type { ModelRequest } from \"./nodes/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 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   * Explitictly defines which targets are allowed to be jumped to from the `beforeAgent` hook.\n   */\n  beforeAgentJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `beforeModel` hook.\n   */\n  beforeModelJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `afterModel` hook.\n   */\n  afterModelJumpTo?: JumpToTarget[];\n  /**\n   * Explitictly defines which targets are allowed to be jumped to from the `afterAgent` hook.\n   */\n  afterAgentJumpTo?: JumpToTarget[];\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 ToolCall 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.toolCall);\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.toolCall);\n   * }\n   * ```\n   */\n  wrapToolCall?: (\n    request: ToolCallRequest<\n      (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) &\n        AgentBuiltInState,\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    >,\n    handler: ToolCallHandler\n  ) => Promise<ToolMessage | Command> | ToolMessage | Command;\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?: (\n    request: ModelRequest<\n      (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) &\n        AgentBuiltInState,\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    >,\n    handler: (\n      request: ModelRequest<\n        (TSchema extends InteropZodObject\n          ? InferInteropZodInput<TSchema>\n          : {}) &\n          AgentBuiltInState,\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      >\n    ) => Promise<AIMessage> | AIMessage\n  ) => Promise<AIMessage> | AIMessage;\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\n        >\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?: (\n    state: (TSchema extends InteropZodObject\n      ? InferInteropZodInput<TSchema>\n      : {}) &\n      AgentBuiltInState,\n    runtime: Runtime<\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    >\n  ) =>\n    | Promise<\n        MiddlewareResult<\n          Partial<\n            TSchema extends InteropZodObject\n              ? InferInteropZodInput<TSchema>\n              : {}\n          >\n        >\n      >\n    | MiddlewareResult<\n        Partial<\n          TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}\n        >\n      >;\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    beforeAgentJumpTo: config.beforeAgentJumpTo,\n    beforeModelJumpTo: config.beforeModelJumpTo,\n    afterModelJumpTo: config.afterModelJumpTo,\n    afterAgentJumpTo: config.afterAgentJumpTo,\n    tools: config.tools ?? [],\n  };\n\n  if (config.wrapToolCall) {\n    middleware.wrapToolCall = async (request, handler) =>\n      Promise.resolve(config.wrapToolCall!(request, handler));\n  }\n\n  if (config.wrapModelCall) {\n    middleware.wrapModelCall = async (request, handler) =>\n      Promise.resolve(config.wrapModelCall!(request, handler));\n  }\n\n  if (config.beforeAgent) {\n    middleware.beforeAgent = async (state, runtime) =>\n      Promise.resolve(\n        config.beforeAgent!(\n          state,\n          runtime as Runtime<\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          >\n        )\n      );\n  }\n\n  if (config.beforeModel) {\n    middleware.beforeModel = async (state, runtime) =>\n      Promise.resolve(\n        config.beforeModel!(\n          state,\n          runtime as Runtime<\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          >\n        )\n      );\n  }\n\n  if (config.afterModel) {\n    middleware.afterModel = async (state, runtime) =>\n      Promise.resolve(\n        config.afterModel!(\n          state,\n          runtime as Runtime<\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          >\n        )\n      );\n  }\n\n  if (config.afterAgent) {\n    middleware.afterAgent = async (state, runtime) =>\n      Promise.resolve(\n        config.afterAgent!(\n          state,\n          runtime as Runtime<\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          >\n        )\n      );\n  }\n\n  return middleware;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,iBAOdA,QAqTgD;CAChD,MAAMC,aAA4D;EAChE,MAAM,OAAO;EACb,aAAa,OAAO;EACpB,eAAe,OAAO;EACtB,mBAAmB,OAAO;EAC1B,mBAAmB,OAAO;EAC1B,kBAAkB,OAAO;EACzB,kBAAkB,OAAO;EACzB,OAAO,OAAO,SAAS,CAAE;CAC1B;AAED,KAAI,OAAO,cACT,WAAW,eAAe,OAAO,SAAS,YACxC,QAAQ,QAAQ,OAAO,aAAc,SAAS,QAAQ,CAAC;AAG3D,KAAI,OAAO,eACT,WAAW,gBAAgB,OAAO,SAAS,YACzC,QAAQ,QAAQ,OAAO,cAAe,SAAS,QAAQ,CAAC;AAG5D,KAAI,OAAO,aACT,WAAW,cAAc,OAAO,OAAO,YACrC,QAAQ,QACN,OAAO,YACL,OACA,QASD,CACF;AAGL,KAAI,OAAO,aACT,WAAW,cAAc,OAAO,OAAO,YACrC,QAAQ,QACN,OAAO,YACL,OACA,QASD,CACF;AAGL,KAAI,OAAO,YACT,WAAW,aAAa,OAAO,OAAO,YACpC,QAAQ,QACN,OAAO,WACL,OACA,QASD,CACF;AAGL,KAAI,OAAO,YACT,WAAW,aAAa,OAAO,OAAO,YACpC,QAAQ,QACN,OAAO,WACL,OACA,QASD,CACF;AAGL,QAAO;AACR"}