langchain 1.5.15 → 1.5.17

package/dist/agents/index.d.cts

@@ -158,83 +158,83 @@ import { SerializableSchema } from "@langchain/core/utils/standard_schema";
  * });
  * ```
  */
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {
   responseFormat: InteropZodType<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {
+export declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {
   responseFormat: StructuredResponseFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {
   responseFormat: JsonSchemaFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema> & {
   responseFormat: SerializableSchema;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema[]> & {
   responseFormat: SerializableSchema[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {
   responseFormat: TypedToolStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {
   responseFormat: ToolStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {
   responseFormat: ProviderStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
   responseFormat?: undefined;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {
   responseFormat: ResponseFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
 //#endregion
-export { type AfterAgentHook, type AfterModelHook, type AgentMiddleware, type AgentRunStream, AgentTypeConfig, type AnyAgentMiddleware, type AnyAnnotationRoot, type BeforeAgentHook, type BeforeModelHook, BuiltInState, CombineStreamTransformers, CombineTools, CreateAgentParams, DefaultAgentTypeConfig, type DefaultMiddlewareTypeConfig, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, InferAgentContext, InferAgentContextSchema, InferAgentMiddleware, InferAgentResponse, InferAgentState, InferAgentStateSchema, InferAgentStreamTransformers, InferAgentTools, InferAgentType, type InferChannelType, type InferContextInput, type InferMergedInputState, type InferMergedState, type InferMiddlewareContext, type InferMiddlewareContextInput, type InferMiddlewareContextInputs, type InferMiddlewareContextSchema, type InferMiddlewareContexts, type InferMiddlewareFullContext, type InferMiddlewareInputState, type InferMiddlewareInputStates, type InferMiddlewareSchema, type InferMiddlewareState, type InferMiddlewareStates, InferMiddlewareStreamTransformers, InferMiddlewareStreamTransformersArray, type InferMiddlewareStreamTransformersFromConfig, InferMiddlewareTools, InferMiddlewareToolsArray, type InferMiddlewareToolsFromConfig, type InferMiddlewareType, type InferSchemaInput, type InferSchemaUpdateType, type InferSchemaValue, type InferSchemaValueType, Interrupt, JumpTo, type JumpToTarget, MIDDLEWARE_BRAND, MiddlewareError, type MiddlewareResult, type MiddlewareTypeConfig, ModelRequest, MultipleStructuredOutputsError, MultipleToolsBoundError, N, type NormalizedSchemaInput, type NormalizedSchemaUpdate, ProviderStrategy, type ReactAgent, ResolveAgentTypeConfig, type ResolveMiddlewareTypeConfig, type ResponseFormat, type ResponseFormatUndefined, type Runtime$1 as Runtime, StructuredOutputParsingError, type SubagentRunStream, type ToAnnotationRoot, ToolCall, type ToolCallHandler, type ToolCallRequest, type ToolCallStreamUnion, ToolInvocationError, ToolResult, ToolStrategy, ToolsToMessageToolSet, type TypedToolStrategy, UserInput, WithStateGraphNodes, type WrapModelCallHandler, type WrapModelCallHook, type WrapToolCallHook, createAgent, createMiddleware, createSubagentTransformer, createToolCallTransformer, providerStrategy, toolStrategy };
+export { type AfterAgentHook, type AfterModelHook, type AgentMiddleware, type AgentRunStream, AgentTypeConfig, type AnyAgentMiddleware, type AnyAnnotationRoot, type BeforeAgentHook, type BeforeModelHook, BuiltInState, CombineStreamTransformers, CombineTools, CreateAgentParams, DefaultAgentTypeConfig, type DefaultMiddlewareTypeConfig, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, InferAgentContext, InferAgentContextSchema, InferAgentMiddleware, InferAgentResponse, InferAgentState, InferAgentStateSchema, InferAgentStreamTransformers, InferAgentTools, InferAgentType, type InferChannelType, type InferContextInput, type InferMergedInputState, type InferMergedState, type InferMiddlewareContext, type InferMiddlewareContextInput, type InferMiddlewareContextInputs, type InferMiddlewareContextSchema, type InferMiddlewareContexts, type InferMiddlewareFullContext, type InferMiddlewareInputState, type InferMiddlewareInputStates, type InferMiddlewareSchema, type InferMiddlewareState, type InferMiddlewareStates, InferMiddlewareStreamTransformers, InferMiddlewareStreamTransformersArray, type InferMiddlewareStreamTransformersFromConfig, InferMiddlewareTools, InferMiddlewareToolsArray, type InferMiddlewareToolsFromConfig, type InferMiddlewareType, type InferSchemaInput, type InferSchemaUpdateType, type InferSchemaValue, type InferSchemaValueType, Interrupt, JumpTo, type JumpToTarget, MIDDLEWARE_BRAND, MiddlewareError, type MiddlewareResult, type MiddlewareTypeConfig, ModelRequest, MultipleStructuredOutputsError, MultipleToolsBoundError, N, type NormalizedSchemaInput, type NormalizedSchemaUpdate, ProviderStrategy, type ReactAgent, ResolveAgentTypeConfig, type ResolveMiddlewareTypeConfig, type ResponseFormat, type ResponseFormatUndefined, type Runtime$1 as Runtime, StructuredOutputParsingError, type SubagentRunStream, type ToAnnotationRoot, ToolCall, type ToolCallHandler, type ToolCallRequest, type ToolCallStreamUnion, ToolInvocationError, ToolResult, ToolStrategy, ToolsToMessageToolSet, type TypedToolStrategy, UserInput, WithStateGraphNodes, type WrapModelCallHandler, type WrapModelCallHook, type WrapToolCallHook, createMiddleware, createSubagentTransformer, createToolCallTransformer, providerStrategy, toolStrategy };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/agents/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/agents/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+KgB,YACd,iCAAiC,sBAAsB,qBACvD,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,0BACA,cACA,eACA,eAAe;EAEf,gBAAgB,eAAe;EAC/B,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,0BACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,0CAA0C,uBAC1C,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,qBAAqB,kCAAkC,sBACnD,qBAAqB,4BACrB,qBACJ,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,qBAAqB,kCAAkC,sBACnD,qBAAqB,4BACrB,qBACJ,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,yBACA,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,yBACA,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,yBACA,cACA,eACA,mBAAmB;EAEnB,gBAAgB,mBAAmB;EACnC,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,yBACA,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,yBACA,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,iCAAiC,sBAAsB,qBACvD,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,0BACA,cACA,eACA,kBAAkB;EAElB,gBAAgB,kBAAkB;EAClC,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,0BACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,iCAAiC,sBAAsB,qBACvD,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,0BACA,cACA,eACA,aAAa;EAEb,gBAAgB,aAAa;EAC7B,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,0BACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,iCAAiC,sBAAsB,qBACvD,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,0BACA,cACA,eACA,iBAAiB;EAEjB,gBAAgB,iBAAiB;EACjC,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,0BACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,KACN,kBACE,yBACA,cACA;EAKF,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,KACN,kBACE,yBACA,cACA;EAKF;EACA,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,yBACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB;wBAKnC,YACd,iCAAiC,sBAAsB,qBACvD,qBAAqB,6CACrB,sBAAsB,oBAAoB,mBACxC,yBACI,6BAA6B,gCACxB,4BACL,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAC1B,uCAGR,QAAQ,kBACN,0BACA,cACA,eACA;EAEA,gBAAgB;EAChB,aAAa;EACb,QAAQ;EACR,qBAAqB;IAEtB,WACD,gBACE,0BACA,cACA,eACA,aACA,aAAa,QAAQ,cACrB,0BAA0B,qBAAqB"}

package/dist/agents/index.d.ts

@@ -158,83 +158,83 @@ import { SerializableSchema } from "@langchain/core/utils/standard_schema";
  * });
  * ```
  */
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {
   responseFormat: InteropZodType<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {
+export declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {
   responseFormat: StructuredResponseFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {
   responseFormat: JsonSchemaFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema> & {
   responseFormat: SerializableSchema;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema[]> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, SerializableSchema[]> & {
   responseFormat: SerializableSchema[];
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {
   responseFormat: TypedToolStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {
   responseFormat: ToolStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {
   responseFormat: ProviderStrategy<StructuredResponseFormat>;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
+export declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, "responseFormat"> & {
   responseFormat?: undefined;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {
+export declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AnyAgentMiddleware[] = readonly AnyAgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {
   responseFormat: ResponseFormat;
   middleware?: TMiddleware;
   tools?: TTools;
   streamTransformers?: TStreamTransformers;
 }): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>, CombineStreamTransformers<TStreamTransformers, TMiddleware>>>;
 //#endregion
-export { type AfterAgentHook, type AfterModelHook, type AgentMiddleware, type AgentRunStream, AgentTypeConfig, type AnyAgentMiddleware, type AnyAnnotationRoot, type BeforeAgentHook, type BeforeModelHook, BuiltInState, CombineStreamTransformers, CombineTools, CreateAgentParams, DefaultAgentTypeConfig, type DefaultMiddlewareTypeConfig, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, InferAgentContext, InferAgentContextSchema, InferAgentMiddleware, InferAgentResponse, InferAgentState, InferAgentStateSchema, InferAgentStreamTransformers, InferAgentTools, InferAgentType, type InferChannelType, type InferContextInput, type InferMergedInputState, type InferMergedState, type InferMiddlewareContext, type InferMiddlewareContextInput, type InferMiddlewareContextInputs, type InferMiddlewareContextSchema, type InferMiddlewareContexts, type InferMiddlewareFullContext, type InferMiddlewareInputState, type InferMiddlewareInputStates, type InferMiddlewareSchema, type InferMiddlewareState, type InferMiddlewareStates, InferMiddlewareStreamTransformers, InferMiddlewareStreamTransformersArray, type InferMiddlewareStreamTransformersFromConfig, InferMiddlewareTools, InferMiddlewareToolsArray, type InferMiddlewareToolsFromConfig, type InferMiddlewareType, type InferSchemaInput, type InferSchemaUpdateType, type InferSchemaValue, type InferSchemaValueType, Interrupt, JumpTo, type JumpToTarget, MIDDLEWARE_BRAND, MiddlewareError, type MiddlewareResult, type MiddlewareTypeConfig, ModelRequest, MultipleStructuredOutputsError, MultipleToolsBoundError, N, type NormalizedSchemaInput, type NormalizedSchemaUpdate, ProviderStrategy, type ReactAgent, ResolveAgentTypeConfig, type ResolveMiddlewareTypeConfig, type ResponseFormat, type ResponseFormatUndefined, type Runtime$1 as Runtime, StructuredOutputParsingError, type SubagentRunStream, type ToAnnotationRoot, ToolCall, type ToolCallHandler, type ToolCallRequest, type ToolCallStreamUnion, ToolInvocationError, ToolResult, ToolStrategy, ToolsToMessageToolSet, type TypedToolStrategy, UserInput, WithStateGraphNodes, type WrapModelCallHandler, type WrapModelCallHook, type WrapToolCallHook, createAgent, createMiddleware, createSubagentTransformer, createToolCallTransformer, providerStrategy, toolStrategy };
+export { type AfterAgentHook, type AfterModelHook, type AgentMiddleware, type AgentRunStream, AgentTypeConfig, type AnyAgentMiddleware, type AnyAnnotationRoot, type BeforeAgentHook, type BeforeModelHook, BuiltInState, CombineStreamTransformers, CombineTools, CreateAgentParams, DefaultAgentTypeConfig, type DefaultMiddlewareTypeConfig, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, InferAgentContext, InferAgentContextSchema, InferAgentMiddleware, InferAgentResponse, InferAgentState, InferAgentStateSchema, InferAgentStreamTransformers, InferAgentTools, InferAgentType, type InferChannelType, type InferContextInput, type InferMergedInputState, type InferMergedState, type InferMiddlewareContext, type InferMiddlewareContextInput, type InferMiddlewareContextInputs, type InferMiddlewareContextSchema, type InferMiddlewareContexts, type InferMiddlewareFullContext, type InferMiddlewareInputState, type InferMiddlewareInputStates, type InferMiddlewareSchema, type InferMiddlewareState, type InferMiddlewareStates, InferMiddlewareStreamTransformers, InferMiddlewareStreamTransformersArray, type InferMiddlewareStreamTransformersFromConfig, InferMiddlewareTools, InferMiddlewareToolsArray, type InferMiddlewareToolsFromConfig, type InferMiddlewareType, type InferSchemaInput, type InferSchemaUpdateType, type InferSchemaValue, type InferSchemaValueType, Interrupt, JumpTo, type JumpToTarget, MIDDLEWARE_BRAND, MiddlewareError, type MiddlewareResult, type MiddlewareTypeConfig, ModelRequest, MultipleStructuredOutputsError, MultipleToolsBoundError, N, type NormalizedSchemaInput, type NormalizedSchemaUpdate, ProviderStrategy, type ReactAgent, ResolveAgentTypeConfig, type ResolveMiddlewareTypeConfig, type ResponseFormat, type ResponseFormatUndefined, type Runtime$1 as Runtime, StructuredOutputParsingError, type SubagentRunStream, type ToAnnotationRoot, ToolCall, type ToolCallHandler, type ToolCallRequest, type ToolCallStreamUnion, ToolInvocationError, ToolResult, ToolStrategy, ToolsToMessageToolSet, type TypedToolStrategy, UserInput, WithStateGraphNodes, type WrapModelCallHandler, type WrapModelCallHook, type WrapToolCallHook, createMiddleware, createSubagentTransformer, createToolCallTransformer, providerStrategy, toolStrategy };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/agents/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/agents/index.ts"],"mappings":"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"}

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

@@ -42,7 +42,7 @@ import { BaseLanguageModel } from "@langchain/core/language_models/base";
  * }
  * ```
  */
-interface ContextEdit {
+export interface ContextEdit {
   /**
    * Apply an edit to the message list, returning the new token count.
    *
@@ -72,7 +72,7 @@ interface ContextEdit {
 /**
  * Configuration for clearing tool outputs when token limits are exceeded.
  */
-interface ClearToolUsesEditConfig {
+export interface ClearToolUsesEditConfig {
   /**
    * Trigger conditions for context editing.
    * Can be a single condition object (all properties must be met) or an array of conditions (any condition must be met).
@@ -175,7 +175,7 @@ interface ClearToolUsesEditConfig {
  * });
  * ```
  */
-declare class ClearToolUsesEdit implements ContextEdit {
+export declare class ClearToolUsesEdit implements ContextEdit {
   #private;
   trigger: ContextSize | ContextSize[];
   keep: KeepSize;
@@ -194,7 +194,7 @@ declare class ClearToolUsesEdit implements ContextEdit {
 /**
  * Configuration for the Context Editing Middleware.
  */
-interface ContextEditingMiddlewareConfig {
+export interface ContextEditingMiddlewareConfig {
   /**
    * Sequence of edit strategies to apply. Defaults to a single
    * ClearToolUsesEdit mirroring Anthropic defaults.
@@ -331,7 +331,6 @@ interface ContextEditingMiddlewareConfig {
  * @param config - Configuration options for the middleware
  * @returns A middleware instance that can be used with `createAgent`
  */
-declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+export declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, contextEditingMiddleware };
 //# sourceMappingURL=contextEditing.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"contextEditing.d.cts","names":[],"sources":["../../../src/agents/middleware/contextEditing.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuEiB;;;;;;;;;;;;EAYf,MAAM;;;;IAIJ,UAAU;;;;IAIV,aAAa;;;;IAIb,QAAQ;aACC;;;;;UAMI;;;;;;;;;;;;;;;;;;;;EAoBf,UAAU,cAAc;;;;;;;;;;;;;;;;;EAkBxB,OAAO;;;;;EAMP;;;;;EAMA;;;;;EAMA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCW,6BAA6B;;EAGxC,SAAS,cAAc;EACvB,MAAM;EACN;EACA,cAAc;EACd;EACA,OAAO;EACP;EAEA,YAAY,SAAQ;EA2Dd,MAAM;IACV,UAAU;IACV,OAAO;IACP,aAAa;MACX;;;;;UA0dW;;;;;EAKf,QAAQ;;;;;;;EAQR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Hc,yBACd,SAAQ,iCAAA,yFAAmC,6CAAA"}
+{"version":3,"file":"contextEditing.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEiB;;;;;;;;;;;;EAYf,MAAM;;;;IAIJ,UAAU;;;;IAIV,aAAa;;;;IAIb,QAAQ;aACC;;;;;iBAMI;;;;;;;;;;;;;;;;;;;;EAoBf,UAAU,cAAc;;;;;;;;;;;;;;;;;EAkBxB,OAAO;;;;;EAMP;;;;;EAMA;;;;;EAMA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuCW,6BAA6B;;EAGxC,SAAS,cAAc;EACvB,MAAM;EACN;EACA,cAAc;EACd;EACA,OAAO;EACP;EAEA,YAAY,SAAQ;EA2Dd,MAAM;IACV,UAAU;IACV,OAAO;IACP,aAAa;MACX;;;;;iBA0dW;;;;;EAKf,QAAQ;;;;;;;EAQR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Hc,yBACd,SAAQ,iCAAAA,yFAAmC,6CAAA"}

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

@@ -42,7 +42,7 @@ import { BaseLanguageModel } from "@langchain/core/language_models/base";
  * }
  * ```
  */
-interface ContextEdit {
+export interface ContextEdit {
   /**
    * Apply an edit to the message list, returning the new token count.
    *
@@ -72,7 +72,7 @@ interface ContextEdit {
 /**
  * Configuration for clearing tool outputs when token limits are exceeded.
  */
-interface ClearToolUsesEditConfig {
+export interface ClearToolUsesEditConfig {
   /**
    * Trigger conditions for context editing.
    * Can be a single condition object (all properties must be met) or an array of conditions (any condition must be met).
@@ -175,7 +175,7 @@ interface ClearToolUsesEditConfig {
  * });
  * ```
  */
-declare class ClearToolUsesEdit implements ContextEdit {
+export declare class ClearToolUsesEdit implements ContextEdit {
   #private;
   trigger: ContextSize | ContextSize[];
   keep: KeepSize;
@@ -194,7 +194,7 @@ declare class ClearToolUsesEdit implements ContextEdit {
 /**
  * Configuration for the Context Editing Middleware.
  */
-interface ContextEditingMiddlewareConfig {
+export interface ContextEditingMiddlewareConfig {
   /**
    * Sequence of edit strategies to apply. Defaults to a single
    * ClearToolUsesEdit mirroring Anthropic defaults.
@@ -331,7 +331,6 @@ interface ContextEditingMiddlewareConfig {
  * @param config - Configuration options for the middleware
  * @returns A middleware instance that can be used with `createAgent`
  */
-declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+export declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, contextEditingMiddleware };
 //# sourceMappingURL=contextEditing.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"contextEditing.d.ts","names":[],"sources":["../../../src/agents/middleware/contextEditing.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuEiB;;;;;;;;;;;;EAYf,MAAM;;;;IAIJ,UAAU;;;;IAIV,aAAa;;;;IAIb,QAAQ;aACC;;;;;UAMI;;;;;;;;;;;;;;;;;;;;EAoBf,UAAU,cAAc;;;;;;;;;;;;;;;;;EAkBxB,OAAO;;;;;EAMP;;;;;EAMA;;;;;EAMA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCW,6BAA6B;;EAGxC,SAAS,cAAc;EACvB,MAAM;EACN;EACA,cAAc;EACd;EACA,OAAO;EACP;EAEA,YAAY,SAAQ;EA2Dd,MAAM;IACV,UAAU;IACV,OAAO;IACP,aAAa;MACX;;;;;UA0dW;;;;;EAKf,QAAQ;;;;;;;EAQR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Hc,yBACd,SAAQ,iCAAA,yFAAmC,6CAAA"}
+{"version":3,"file":"contextEditing.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEiB;;;;;;;;;;;;EAYf,MAAM;;;;IAIJ,UAAU;;;;IAIV,aAAa;;;;IAIb,QAAQ;aACC;;;;;iBAMI;;;;;;;;;;;;;;;;;;;;EAoBf,UAAU,cAAc;;;;;;;;;;;;;;;;;EAkBxB,OAAO;;;;;EAMP;;;;;EAMA;;;;;EAMA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuCW,6BAA6B;;EAGxC,SAAS,cAAc;EACvB,MAAM;EACN;EACA,cAAc;EACd;EACA,OAAO;EACP;EAEA,YAAY,SAAQ;EA2Dd,MAAM;IACV,UAAU;IACV,OAAO;IACP,aAAa;MACX;;;;;iBA0dW;;;;;EAKf,QAAQ;;;;;;;EAQR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Hc,yBACd,SAAQ,iCAAAA,yFAAmC,6CAAA"}

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

@@ -2,7 +2,7 @@ import { AgentBuiltInState, Runtime } from "../runtime.cjs";
 import { AgentMiddleware } from "./types.cjs";
 import { SystemMessage } from "@langchain/core/messages";
 //#region src/agents/middleware/dynamicSystemPrompt.d.ts
-type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | SystemMessage | Promise<string | SystemMessage>;
+export type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | SystemMessage | Promise<string | SystemMessage>;
 /**
  * Dynamic System Prompt Middleware
  *
@@ -41,7 +41,6 @@ type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInS
  *
  * @public
  */
-declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+export declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
 //# sourceMappingURL=dynamicSystemPrompt.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dynamicSystemPrompt.d.cts","names":[],"sources":["../../../src/agents/middleware/dynamicSystemPrompt.ts"],"mappings":";;;;KAIY,oCAAoC,mBAC9C,OAAO,mBACP,SAAS,QAAQ,6BACL,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC/B,8BAA8B,0BAC5C,IAAI,oCAAoC,kBAApC,yFAAmD,6CAAA"}
+{"version":3,"file":"dynamicSystemPrompt.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/dynamicSystemPrompt.ts"],"mappings":";;;;YAIY,oCAAoC,mBAC9C,OAAO,mBACP,SAAS,QAAQ,6BACL,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwC/B,8BAA8B,0BAC5C,IAAI,oCAAoC,kBAApCA,yFAAmD,6CAAA"}

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

@@ -2,7 +2,7 @@ import { AgentBuiltInState, Runtime } from "../runtime.js";
 import { AgentMiddleware } from "./types.js";
 import { SystemMessage } from "@langchain/core/messages";
 //#region src/agents/middleware/dynamicSystemPrompt.d.ts
-type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | SystemMessage | Promise<string | SystemMessage>;
+export type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | SystemMessage | Promise<string | SystemMessage>;
 /**
  * Dynamic System Prompt Middleware
  *
@@ -41,7 +41,6 @@ type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInS
  *
  * @public
  */
-declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+export declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
 //# sourceMappingURL=dynamicSystemPrompt.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dynamicSystemPrompt.d.ts","names":[],"sources":["../../../src/agents/middleware/dynamicSystemPrompt.ts"],"mappings":";;;;KAIY,oCAAoC,mBAC9C,OAAO,mBACP,SAAS,QAAQ,6BACL,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC/B,8BAA8B,0BAC5C,IAAI,oCAAoC,kBAApC,yFAAmD,6CAAA"}
+{"version":3,"file":"dynamicSystemPrompt.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/dynamicSystemPrompt.ts"],"mappings":";;;;YAIY,oCAAoC,mBAC9C,OAAO,mBACP,SAAS,QAAQ,6BACL,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwC/B,8BAA8B,0BAC5C,IAAI,oCAAoC,kBAApCA,yFAAmD,6CAAA"}

package/dist/agents/middleware/hitl.cjs

@@ -6,15 +6,17 @@ let zod_v3 = require("zod/v3");
 //#region src/agents/middleware/hitl.ts
 const WhenFunctionSchema = zod_v3.z.function().args(zod_v3.z.custom()).returns(zod_v3.z.union([zod_v3.z.boolean(), zod_v3.z.promise(zod_v3.z.boolean())]));
 const DescriptionFunctionSchema = zod_v3.z.function().args(zod_v3.z.custom(), zod_v3.z.custom(), zod_v3.z.custom()).returns(zod_v3.z.union([zod_v3.z.string(), zod_v3.z.promise(zod_v3.z.string())]));
-/**
-* The type of decision a human can make.
-*/
-const ALLOWED_DECISIONS = [
+const DecisionType = zod_v3.z.enum([
+	"approve",
+	"edit",
+	"reject",
+	"respond"
+]);
+const DEFAULT_ALLOWED_DECISIONS = [
 	"approve",
 	"edit",
 	"reject"
 ];
-const DecisionType = zod_v3.z.enum(ALLOWED_DECISIONS);
 const InterruptOnConfigSchema = zod_v3.z.object({
 	/**
 	* The decisions that are allowed for this action.
@@ -405,6 +407,18 @@ function humanInTheLoopMiddleware(options) {
 				})
 			};
 		}
+		if (decision.type === "respond" && allowedDecisions.includes("respond")) {
+			if (typeof decision.message !== "string") throw new Error(`Tool call response for "${toolCall.name}" must be a string, got ${typeof decision.message}`);
+			return {
+				revisedToolCall: toolCall,
+				toolMessage: new _langchain_core_messages.ToolMessage({
+					content: decision.message,
+					name: toolCall.name,
+					tool_call_id: toolCall.id,
+					status: "success"
+				})
+			};
+		}
 		const msg = `Unexpected human decision: ${JSON.stringify(decision)}. Decision type '${decision.type}' is not allowed for tool '${toolCall.name}'. Expected one of ${JSON.stringify(allowedDecisions)} based on the tool's configuration.`;
 		throw new Error(msg);
 	};
@@ -435,7 +449,7 @@ function humanInTheLoopMiddleware(options) {
 				*/
 				const resolvedConfigs = {};
 				for (const [toolName, toolConfig] of Object.entries(config.interruptOn)) if (typeof toolConfig === "boolean") {
-					if (toolConfig === true) resolvedConfigs[toolName] = { allowedDecisions: [...ALLOWED_DECISIONS] };
+					if (toolConfig === true) resolvedConfigs[toolName] = { allowedDecisions: [...DEFAULT_ALLOWED_DECISIONS] };
 				} else if (toolConfig.allowedDecisions) resolvedConfigs[toolName] = toolConfig;
 				const interruptToolCalls = [];
 				const autoApprovedToolCalls = [];
@@ -482,6 +496,7 @@ function humanInTheLoopMiddleware(options) {
 				const revisedToolCalls = [...autoApprovedToolCalls];
 				const artificialToolMessages = [];
 				const hasRejectedToolCalls = decisions.some((decision) => decision.type === "reject");
+				const hasRespondedToolCalls = decisions.some((decision) => decision.type === "respond");
 				/**
 				* Process each decision using helper method
 				*/
@@ -490,14 +505,15 @@ function humanInTheLoopMiddleware(options) {
 					const toolCall = interruptToolCalls[i];
 					const interruptConfig = resolvedConfigs[toolCall.name];
 					const { revisedToolCall, toolMessage } = processDecision(decision, toolCall, interruptConfig);
-					if (revisedToolCall && (!hasRejectedToolCalls || decision.type === "reject")) revisedToolCalls.push(revisedToolCall);
+					if (revisedToolCall && (!hasRejectedToolCalls || decision.type === "reject" || decision.type === "respond")) revisedToolCalls.push(revisedToolCall);
 					if (toolMessage) artificialToolMessages.push(toolMessage);
 				}
 				/**
 				* Update the AI message to only include approved tool calls
 				*/
 				if (_langchain_core_messages.AIMessage.isInstance(lastMessage)) lastMessage.tool_calls = revisedToolCalls;
-				const jumpTo = hasRejectedToolCalls ? "model" : void 0;
+				const hasPendingToolCalls = revisedToolCalls.some((toolCall) => !artificialToolMessages.some((message) => message.tool_call_id === toolCall.id));
+				const jumpTo = hasRejectedToolCalls || hasRespondedToolCalls && !hasPendingToolCalls ? "model" : void 0;
 				return {
 					messages: [lastMessage, ...artificialToolMessages],
 					jumpTo