langchain 1.5.15 → 1.5.17

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

@@ -13,7 +13,6 @@ import { BaseMessage } from "@langchain/core/messages";
  *   LangChain tool instances are converted to OpenAI tool format before counting.
  * @returns Approximate token count
  */
-declare function countTokensApproximately(messages: BaseMessage[], tools?: Array<Record<string, any>> | null): number;
+export declare function countTokensApproximately(messages: BaseMessage[], tools?: Array<Record<string, any>> | null): number;
 //#endregion
-export { countTokensApproximately };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/agents/middleware/utils.ts"],"mappings":";;;;;;;;;;;;;;;iBA0BgB,yBACd,UAAU,eAEV,QAAQ,MAAM"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/agents/middleware/utils.ts"],"mappings":";;;;;;;;;;;;;;;wBA0BgB,yBACd,UAAU,eAEV,QAAQ,MAAM"}

package/dist/agents/middleware.d.cts

@@ -57,7 +57,7 @@ import { StateDefinitionInit, StreamTransformer } from "@langchain/langgraph";
  * });
  * ```
  */
-declare function createMiddleware<TSchema extends StateDefinitionInit | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined, const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(config: {
+export declare function createMiddleware<TSchema extends StateDefinitionInit | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined, const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(config: {
   /**
    * The name of the middleware
    */
@@ -206,5 +206,4 @@ declare function createMiddleware<TSchema extends StateDefinitionInit | undefine
 }): AgentMiddleware<TSchema, TContextSchema, NormalizeContextSchema<TContextSchema>, TTools, TStreamTransformers>;
 type NormalizeContextSchema<TContextSchema extends InteropZodObject | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : unknown;
 //#endregion
-export { createMiddleware };
 //# sourceMappingURL=middleware.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../src/agents/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2EgB,iBACd,gBAAgB,6CAChB,uBAAuB,gDACjB,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAE1B,uCAER;;;;EAIA;;;;;;;;EAQA,cAAc;;;;;;;;EAQd,gBAAgB;;;;EAIhB,QAAQ;;;;;EAKR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDrB,eAAe,iBACb,SACA,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCzB,gBAAgB,kBACd,SACA,uBAAuB;;;;;;;;;EAUzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,aAAa,eAAe,SAAS,uBAAuB;;;;;;;;;EAU5D,aAAa,eAAe,SAAS,uBAAuB;IAC1D,gBACF,SACA,gBACA,uBAAuB,iBACvB,QACA;KA0BG,uBACH,uBAAuB,4CACrB,uBAAuB,mBACvB,sBAAsB"}
+{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../src/agents/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2EgB,iBACd,gBAAgB,6CAChB,uBAAuB,gDACjB,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAE1B,uCAER;;;;EAIA;;;;;;;;EAQA,cAAc;;;;;;;;EAQd,gBAAgB;;;;EAIhB,QAAQ;;;;;EAKR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDrB,eAAe,iBACb,SACA,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCzB,gBAAgB,kBACd,SACA,uBAAuB;;;;;;;;;EAUzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,aAAa,eAAe,SAAS,uBAAuB;;;;;;;;;EAU5D,aAAa,eAAe,SAAS,uBAAuB;IAC1D,gBACF,SACA,gBACA,uBAAuB,iBACvB,QACA;KA0BG,uBACH,uBAAuB,4CACrB,uBAAuB,mBACvB,sBAAsB"}

package/dist/agents/middleware.d.ts

@@ -57,7 +57,7 @@ import { InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/t
  * });
  * ```
  */
-declare function createMiddleware<TSchema extends StateDefinitionInit | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined, const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(config: {
+export declare function createMiddleware<TSchema extends StateDefinitionInit | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined, const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(config: {
   /**
    * The name of the middleware
    */
@@ -206,5 +206,4 @@ declare function createMiddleware<TSchema extends StateDefinitionInit | undefine
 }): AgentMiddleware<TSchema, TContextSchema, NormalizeContextSchema<TContextSchema>, TTools, TStreamTransformers>;
 type NormalizeContextSchema<TContextSchema extends InteropZodObject | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : unknown;
 //#endregion
-export { createMiddleware };
 //# sourceMappingURL=middleware.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/agents/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2EgB,iBACd,gBAAgB,6CAChB,uBAAuB,gDACjB,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAE1B,uCAER;;;;EAIA;;;;;;;;EAQA,cAAc;;;;;;;;EAQd,gBAAgB;;;;EAIhB,QAAQ;;;;;EAKR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDrB,eAAe,iBACb,SACA,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCzB,gBAAgB,kBACd,SACA,uBAAuB;;;;;;;;;EAUzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,aAAa,eAAe,SAAS,uBAAuB;;;;;;;;;EAU5D,aAAa,eAAe,SAAS,uBAAuB;IAC1D,gBACF,SACA,gBACA,uBAAuB,iBACvB,QACA;KA0BG,uBACH,uBAAuB,4CACrB,uBAAuB,mBACvB,sBAAsB"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/agents/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2EgB,iBACd,gBAAgB,6CAChB,uBAAuB,gDACjB,yBAAyB,aAAa,0BACxC,aACA,qBAEE,4BAA4B,oBAE1B,uCAER;;;;EAIA;;;;;;;;EAQA,cAAc;;;;;;;;EAQd,gBAAgB;;;;EAIhB,QAAQ;;;;;EAKR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDrB,eAAe,iBACb,SACA,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCzB,gBAAgB,kBACd,SACA,uBAAuB;;;;;;;;;EAUzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,cAAc,gBACZ,SACA,uBAAuB;;;;;;;;;EAWzB,aAAa,eAAe,SAAS,uBAAuB;;;;;;;;;EAU5D,aAAa,eAAe,SAAS,uBAAuB;IAC1D,gBACF,SACA,gBACA,uBAAuB,iBACvB,QACA;KA0BG,uBACH,uBAAuB,4CACrB,uBAAuB,mBACvB,sBAAsB"}

package/dist/agents/model.d.cts

@@ -2,7 +2,6 @@ import { BaseLanguageModelInput, LanguageModelOutput } from "@langchain/core/lan
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { RunnableInterface } from "@langchain/core/runnables";
 //#region src/agents/model.d.ts
-type AgentLanguageModelLike = RunnableInterface<BaseLanguageModelInput, LanguageModelOutput>;
+export type AgentLanguageModelLike = RunnableInterface<BaseLanguageModelInput, LanguageModelOutput>;
 //#endregion
-export { AgentLanguageModelLike };
 //# sourceMappingURL=model.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"model.d.cts","names":[],"sources":["../../src/agents/model.ts"],"mappings":";;;;KAOY,yBAAyB,kBACnC,wBACA"}
+{"version":3,"file":"model.d.cts","names":[],"sources":["../../src/agents/model.ts"],"mappings":";;;;YAOY,yBAAyB,kBACnC,wBACA"}

package/dist/agents/model.d.ts

@@ -2,7 +2,6 @@ import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { RunnableInterface } from "@langchain/core/runnables";
 import { BaseLanguageModelInput, LanguageModelOutput } from "@langchain/core/language_models/base";
 //#region src/agents/model.d.ts
-type AgentLanguageModelLike = RunnableInterface<BaseLanguageModelInput, LanguageModelOutput>;
+export type AgentLanguageModelLike = RunnableInterface<BaseLanguageModelInput, LanguageModelOutput>;
 //#endregion
-export { AgentLanguageModelLike };
 //# sourceMappingURL=model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","names":[],"sources":["../../src/agents/model.ts"],"mappings":";;;;KAOY,yBAAyB,kBACnC,wBACA"}
+{"version":3,"file":"model.d.ts","names":[],"sources":["../../src/agents/model.ts"],"mappings":";;;;YAOY,yBAAyB,kBACnC,wBACA"}

package/dist/agents/nodes/types.d.cts

@@ -11,7 +11,7 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
  * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
  * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
  */
-interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown, TResponseFormat extends ResponseFormatInput = ResponseFormatInput> {
+export interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown, TResponseFormat extends ResponseFormatInput = ResponseFormatInput> {
   /**
    * The model to use for this step.
    */
@@ -108,5 +108,4 @@ interface ModelRequest<TState extends Record<string, unknown> = Record<string, u
   modelSettings?: Record<string, unknown>;
 }
 //#endregion
-export { ModelRequest };
 //# sourceMappingURL=types.d.cts.map

package/dist/agents/nodes/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/agents/nodes/types.ts"],"mappings":";;;;;;;;;;;;;UAciB,aACf,eAAe,0BAA0B,yBACzC,oBACA,wBAAwB,sBAAsB;;;;EAK9C,OAAO;;;;EAIP,UAAU;;;;;;;EAOV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,eAAe;;;;;;;;;EASf;IAIM;IAAkB;MAAY;;;;;;EAKpC,QAAQ,aAAa;;;;EAKrB,OAAO,SAAS;;;;;EAMhB,iBAAiB;;;;EAKjB,SAAS,QAAQ;;;;;;;;;;;;;;;EAgBjB,gBAAgB"}
+{"version":3,"file":"types.d.cts","names":["LanguageModelLike"],"sources":["../../../src/agents/nodes/types.ts"],"mappings":";;;;;;;;;;;;;iBAciB,aACf,eAAe,0BAA0B,yBACzC,oBACA,wBAAwB,sBAAsB;;;;EAK9C,OAAOA;;;;EAIP,UAAU;;;;;;;EAOV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,eAAe;;;;;;;;;EASf;IAIM;IAAkB;MAAY;;;;;;EAKpC,QAAQ,aAAa;;;;EAKrB,OAAO,SAAS;;;;;EAMhB,iBAAiB;;;;EAKjB,SAAS,QAAQ;;;;;;;;;;;;;;;EAgBjB,gBAAgB"}

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

@@ -11,7 +11,7 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
  * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
  * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
  */
-interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown, TResponseFormat extends ResponseFormatInput = ResponseFormatInput> {
+export interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown, TResponseFormat extends ResponseFormatInput = ResponseFormatInput> {
   /**
    * The model to use for this step.
    */
@@ -108,5 +108,4 @@ interface ModelRequest<TState extends Record<string, unknown> = Record<string, u
   modelSettings?: Record<string, unknown>;
 }
 //#endregion
-export { ModelRequest };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/agents/nodes/types.ts"],"mappings":";;;;;;;;;;;;;UAciB,aACf,eAAe,0BAA0B,yBACzC,oBACA,wBAAwB,sBAAsB;;;;EAK9C,OAAO;;;;EAIP,UAAU;;;;;;;EAOV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,eAAe;;;;;;;;;EASf;IAIM;IAAkB;MAAY;;;;;;EAKpC,QAAQ,aAAa;;;;EAKrB,OAAO,SAAS;;;;;EAMhB,iBAAiB;;;;EAKjB,SAAS,QAAQ;;;;;;;;;;;;;;;EAgBjB,gBAAgB"}
+{"version":3,"file":"types.d.ts","names":["LanguageModelLike"],"sources":["../../../src/agents/nodes/types.ts"],"mappings":";;;;;;;;;;;;;iBAciB,aACf,eAAe,0BAA0B,yBACzC,oBACA,wBAAwB,sBAAsB;;;;EAK9C,OAAOA;;;;EAIP,UAAU;;;;;;;EAOV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,eAAe;;;;;;;;;EASf;IAIM;IAAkB;MAAY;;;;;;EAKpC,QAAQ,aAAa;;;;EAKrB,OAAO,SAAS;;;;;EAMhB,iBAAiB;;;;EAKjB,SAAS,QAAQ;;;;;;;;;;;;;;;EAgBjB,gBAAgB"}

package/dist/agents/responses.d.cts

@@ -9,7 +9,7 @@ import { SerializableSchema } from "@langchain/core/utils/standard_schema";
  * Special type to indicate that no response format is provided.
  * When this type is used, the structuredResponse property should not be present in the result.
  */
-type ResponseFormatUndefined = {
+export type ResponseFormatUndefined = {
   __responseFormatUndefined: true;
 };
 /**
@@ -18,7 +18,7 @@ type ResponseFormatUndefined = {
  * via tool calls, including the original schema, its type classification, and the
  * corresponding tool implementation used by the tools strategy.
  */
-declare class ToolStrategy<_T = unknown> {
+export declare class ToolStrategy<_T = unknown> {
   /**
    * The original JSON Schema provided for structured output
    */
@@ -48,7 +48,7 @@ declare class ToolStrategy<_T = unknown> {
    */
   parse(toolArgs: Record<string, unknown>): Record<string, unknown>;
 }
-declare class ProviderStrategy<T = unknown> {
+export declare class ProviderStrategy<T = unknown> {
   private _schemaType?;
   /**
    * The schema to use for the provider strategy
@@ -71,16 +71,16 @@ declare class ProviderStrategy<T = unknown> {
    */
   parse(response: AIMessage): any;
 }
-type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;
-type ResponseFormatInput<StructuredResponseType extends Record<string, any> = Record<string, any>> = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | SerializableSchema<StructuredResponseType> | SerializableSchema[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ResponseFormat[] | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined;
+export type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;
+export type ResponseFormatInput<StructuredResponseType extends Record<string, any> = Record<string, any>> = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | SerializableSchema<StructuredResponseType> | SerializableSchema[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ResponseFormat[] | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined;
 /**
  * Branded type for ToolStrategy arrays that preserves type information
  */
-interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
+export interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
   _schemaType?: T;
 }
-type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;
-interface ToolStrategyOptions {
+export type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;
+export interface ToolStrategyOptions {
   /**
    * Allows you to customize the message that appears in the conversation history when structured
    * output is generated.
@@ -102,12 +102,12 @@ interface ToolStrategyOptions {
    */
   handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);
 }
-declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;
-declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{ [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never; }[number]>;
-declare function toolStrategy(responseFormat: SerializableSchema, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: SerializableSchema[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;
+export declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{ [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never; }[number]>;
+export declare function toolStrategy(responseFormat: SerializableSchema, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: SerializableSchema[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
 /**
  * Creates a provider strategy for structured output using native JSON schema support.
  *
@@ -155,15 +155,15 @@ declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: Tool
  * });
  * ```
  */
-declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {
+export declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {
   schema: T;
   strict?: boolean;
 }): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;
-declare function providerStrategy(responseFormat: SerializableSchema | {
+export declare function providerStrategy(responseFormat: SerializableSchema | {
   schema: SerializableSchema;
   strict?: boolean;
 }): ProviderStrategy<Record<string, unknown>>;
-declare function providerStrategy(responseFormat: JsonSchemaFormat | {
+export declare function providerStrategy(responseFormat: JsonSchemaFormat | {
   schema: JsonSchemaFormat;
   strict?: boolean;
 }): ProviderStrategy<Record<string, unknown>>;
@@ -171,7 +171,7 @@ declare function providerStrategy(responseFormat: JsonSchemaFormat | {
  * Type representing a JSON Schema object format.
  * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.
  */
-type JsonSchemaFormat = {
+export type JsonSchemaFormat = {
   type: "null" | "boolean" | "object" | "array" | "number" | "string" | "integer";
   properties?: Record<string, unknown>;
   required?: string[];
@@ -181,5 +181,4 @@ type JsonSchemaFormat = {
   __brand?: never;
 };
 //#endregion
-export { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatInput, ResponseFormatUndefined, ToolStrategy, ToolStrategyError, ToolStrategyOptions, TypedToolStrategy, providerStrategy, toolStrategy };
 //# sourceMappingURL=responses.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"responses.d.cts","names":[],"sources":["../../src/agents/responses.ts"],"mappings":";;;;;;;;;;;KA2BY;EACV;;;;;;;;cAyBW,aAAa;;;;WAKN,QAAQ;;;;WAKR;IACd;IACA,UAAU;;;;;WAMI,UAAU;UAjBrB;MAoBH;SAIG,WAAW,UAAU,kBAC1B,QAAQ,GACR,gBAAgB,sBACf,aAAa,UAAU,qBAAqB,KAAK;SAE7C,WACL,QAAQ,oBACR,gBAAgB,sBACf,aAAa;SAET,WACL,QAAQ,yBACR,gBAAgB,sBACf,aAAa;;;;;;;;EA2DhB,MAAM,UAAU,0BAA0B;;cAa/B,iBAAiB;UAEpB;;;;WAKQ,QAAQ;;;;WAKR;UAET;UAIA;SAyBA,WAAW,GAChB,QAAQ,eAAe,IACvB,mBACC,iBAAiB;SAEb,WACL,QAAQ,oBACR,mBACC,iBAAiB;SAEb,WACL,QAAQ,yBACR,mBACC,iBAAiB;;;;;;;EAkBpB,MAAM,UAAU;;KAqDN,iBAAiB,oBAAoB;KAErC,oBACV,+BAA+B,sBAAsB,uBAEnD,eAAe,0BACf,4BACA,mBAAmB,0BACnB,uBACA,mBACA,qBACA,iBACA,mBACA,kBAAkB,0BAClB,aAAa,0BACb,iBAAiB,0BACjB;;;;UAyIa,kBAAkB,qBAAqB,MACtD;EAEA,cAAc;;KAEJ,oBACR,+BACA;UACa;;;;;EAKf;;;;;;;;;;;;;;;EAeA,mCAGM,OAAO,sBAAsB;;iBAGrB,aAAa,UAAU,qBACrC,gBAAgB,GAChB,UAAU,sBACT,kBAAkB,UAAU,qBAAqB,KAAK;iBACzC,aAAa,mBAAmB,uBAC9C,gBAAgB,GAChB,UAAU,sBACT,qBACE,WAAW,IAAI,EAAE,WAAW,qBAAqB,KAAK;iBAE3C,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,sBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,kBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgHL,iBAAiB,UAAU,yBACzC,gBAAgB;EAAM,QAAQ;EAAG;IAChC,iBAAiB,UAAU,qBAAqB,KAAK;iBACxC,iBACd,gBACI;EACE,QAAQ;EAAoB;IACjC,iBAAiB;iBACJ,iBACd,gBACI;EACE,QAAQ;EAAkB;IAC/B,iBAAiB;;;;;KA4CR;EACV;EAQA,aAAa;EACb;EACA;GACC;;EAGD"}
+{"version":3,"file":"responses.d.cts","names":[],"sources":["../../src/agents/responses.ts"],"mappings":";;;;;;;;;;;YA2BY;EACV;;;;;;;;qBAyBW,aAAa;;;;WAKN,QAAQ;;;;WAKR;IACd;IACA,UAAU;;;;;WAMI,UAAU;UAjBrB;MAoBH;SAIG,WAAW,UAAU,kBAC1B,QAAQ,GACR,gBAAgB,sBACf,aAAa,UAAU,qBAAqB,KAAK;SAE7C,WACL,QAAQ,oBACR,gBAAgB,sBACf,aAAa;SAET,WACL,QAAQ,yBACR,gBAAgB,sBACf,aAAa;;;;;;;;EA2DhB,MAAM,UAAU,0BAA0B;;qBAa/B,iBAAiB;UAEpB;;;;WAKQ,QAAQ;;;;WAKR;UAET;UAIA;SAyBA,WAAW,GAChB,QAAQ,eAAe,IACvB,mBACC,iBAAiB;SAEb,WACL,QAAQ,oBACR,mBACC,iBAAiB;SAEb,WACL,QAAQ,yBACR,mBACC,iBAAiB;;;;;;;EAkBpB,MAAM,UAAU;;YAqDN,iBAAiB,oBAAoB;YAErC,oBACV,+BAA+B,sBAAsB,uBAEnD,eAAe,0BACf,4BACA,mBAAmB,0BACnB,uBACA,mBACA,qBACA,iBACA,mBACA,kBAAkB,0BAClB,aAAa,0BACb,iBAAiB,0BACjB;;;;iBAyIa,kBAAkB,qBAAqB,MACtD;EAEA,cAAc;;YAEJ,oBACR,+BACA;iBACa;;;;;EAKf;;;;;;;;;;;;;;;EAeA,mCAGM,OAAO,sBAAsB;;wBAGrB,aAAa,UAAU,qBACrC,gBAAgB,GAChB,UAAU,sBACT,kBAAkB,UAAU,qBAAqB,KAAK;wBACzC,aAAa,mBAAmB,uBAC9C,gBAAgB,GAChB,UAAU,sBACT,qBACE,WAAW,IAAI,EAAE,WAAW,qBAAqB,KAAK;wBAE3C,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,sBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,kBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgHL,iBAAiB,UAAU,yBACzC,gBAAgB;EAAM,QAAQ;EAAG;IAChC,iBAAiB,UAAU,qBAAqB,KAAK;wBACxC,iBACd,gBACI;EACE,QAAQ;EAAoB;IACjC,iBAAiB;wBACJ,iBACd,gBACI;EACE,QAAQ;EAAkB;IAC/B,iBAAiB;;;;;YA4CR;EACV;EAQA,aAAa;EACb;EACA;GACC;;EAGD"}

package/dist/agents/responses.d.ts

@@ -9,7 +9,7 @@ import { FunctionDefinition } from "@langchain/core/language_models/base";
  * Special type to indicate that no response format is provided.
  * When this type is used, the structuredResponse property should not be present in the result.
  */
-type ResponseFormatUndefined = {
+export type ResponseFormatUndefined = {
   __responseFormatUndefined: true;
 };
 /**
@@ -18,7 +18,7 @@ type ResponseFormatUndefined = {
  * via tool calls, including the original schema, its type classification, and the
  * corresponding tool implementation used by the tools strategy.
  */
-declare class ToolStrategy<_T = unknown> {
+export declare class ToolStrategy<_T = unknown> {
   /**
    * The original JSON Schema provided for structured output
    */
@@ -48,7 +48,7 @@ declare class ToolStrategy<_T = unknown> {
    */
   parse(toolArgs: Record<string, unknown>): Record<string, unknown>;
 }
-declare class ProviderStrategy<T = unknown> {
+export declare class ProviderStrategy<T = unknown> {
   private _schemaType?;
   /**
    * The schema to use for the provider strategy
@@ -71,16 +71,16 @@ declare class ProviderStrategy<T = unknown> {
    */
   parse(response: AIMessage): any;
 }
-type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;
-type ResponseFormatInput<StructuredResponseType extends Record<string, any> = Record<string, any>> = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | SerializableSchema<StructuredResponseType> | SerializableSchema[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ResponseFormat[] | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined;
+export type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;
+export type ResponseFormatInput<StructuredResponseType extends Record<string, any> = Record<string, any>> = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | SerializableSchema<StructuredResponseType> | SerializableSchema[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ResponseFormat[] | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined;
 /**
  * Branded type for ToolStrategy arrays that preserves type information
  */
-interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
+export interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
   _schemaType?: T;
 }
-type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;
-interface ToolStrategyOptions {
+export type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;
+export interface ToolStrategyOptions {
   /**
    * Allows you to customize the message that appears in the conversation history when structured
    * output is generated.
@@ -102,12 +102,12 @@ interface ToolStrategyOptions {
    */
   handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);
 }
-declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;
-declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{ [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never; }[number]>;
-declare function toolStrategy(responseFormat: SerializableSchema, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: SerializableSchema[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;
+export declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{ [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never; }[number]>;
+export declare function toolStrategy(responseFormat: SerializableSchema, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: SerializableSchema[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
+export declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
 /**
  * Creates a provider strategy for structured output using native JSON schema support.
  *
@@ -155,15 +155,15 @@ declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: Tool
  * });
  * ```
  */
-declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {
+export declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {
   schema: T;
   strict?: boolean;
 }): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;
-declare function providerStrategy(responseFormat: SerializableSchema | {
+export declare function providerStrategy(responseFormat: SerializableSchema | {
   schema: SerializableSchema;
   strict?: boolean;
 }): ProviderStrategy<Record<string, unknown>>;
-declare function providerStrategy(responseFormat: JsonSchemaFormat | {
+export declare function providerStrategy(responseFormat: JsonSchemaFormat | {
   schema: JsonSchemaFormat;
   strict?: boolean;
 }): ProviderStrategy<Record<string, unknown>>;
@@ -171,7 +171,7 @@ declare function providerStrategy(responseFormat: JsonSchemaFormat | {
  * Type representing a JSON Schema object format.
  * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.
  */
-type JsonSchemaFormat = {
+export type JsonSchemaFormat = {
   type: "null" | "boolean" | "object" | "array" | "number" | "string" | "integer";
   properties?: Record<string, unknown>;
   required?: string[];
@@ -181,5 +181,4 @@ type JsonSchemaFormat = {
   __brand?: never;
 };
 //#endregion
-export { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatInput, ResponseFormatUndefined, ToolStrategy, ToolStrategyError, ToolStrategyOptions, TypedToolStrategy, providerStrategy, toolStrategy };
 //# sourceMappingURL=responses.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"responses.d.ts","names":[],"sources":["../../src/agents/responses.ts"],"mappings":";;;;;;;;;;;KA2BY;EACV;;;;;;;;cAyBW,aAAa;;;;WAKN,QAAQ;;;;WAKR;IACd;IACA,UAAU;;;;;WAMI,UAAU;UAjBrB;MAoBH;SAIG,WAAW,UAAU,kBAC1B,QAAQ,GACR,gBAAgB,sBACf,aAAa,UAAU,qBAAqB,KAAK;SAE7C,WACL,QAAQ,oBACR,gBAAgB,sBACf,aAAa;SAET,WACL,QAAQ,yBACR,gBAAgB,sBACf,aAAa;;;;;;;;EA2DhB,MAAM,UAAU,0BAA0B;;cAa/B,iBAAiB;UAEpB;;;;WAKQ,QAAQ;;;;WAKR;UAET;UAIA;SAyBA,WAAW,GAChB,QAAQ,eAAe,IACvB,mBACC,iBAAiB;SAEb,WACL,QAAQ,oBACR,mBACC,iBAAiB;SAEb,WACL,QAAQ,yBACR,mBACC,iBAAiB;;;;;;;EAkBpB,MAAM,UAAU;;KAqDN,iBAAiB,oBAAoB;KAErC,oBACV,+BAA+B,sBAAsB,uBAEnD,eAAe,0BACf,4BACA,mBAAmB,0BACnB,uBACA,mBACA,qBACA,iBACA,mBACA,kBAAkB,0BAClB,aAAa,0BACb,iBAAiB,0BACjB;;;;UAyIa,kBAAkB,qBAAqB,MACtD;EAEA,cAAc;;KAEJ,oBACR,+BACA;UACa;;;;;EAKf;;;;;;;;;;;;;;;EAeA,mCAGM,OAAO,sBAAsB;;iBAGrB,aAAa,UAAU,qBACrC,gBAAgB,GAChB,UAAU,sBACT,kBAAkB,UAAU,qBAAqB,KAAK;iBACzC,aAAa,mBAAmB,uBAC9C,gBAAgB,GAChB,UAAU,sBACT,qBACE,WAAW,IAAI,EAAE,WAAW,qBAAqB,KAAK;iBAE3C,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,sBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,kBAChB,UAAU,sBACT,kBAAkB;iBACL,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgHL,iBAAiB,UAAU,yBACzC,gBAAgB;EAAM,QAAQ;EAAG;IAChC,iBAAiB,UAAU,qBAAqB,KAAK;iBACxC,iBACd,gBACI;EACE,QAAQ;EAAoB;IACjC,iBAAiB;iBACJ,iBACd,gBACI;EACE,QAAQ;EAAkB;IAC/B,iBAAiB;;;;;KA4CR;EACV;EAQA,aAAa;EACb;EACA;GACC;;EAGD"}
+{"version":3,"file":"responses.d.ts","names":[],"sources":["../../src/agents/responses.ts"],"mappings":";;;;;;;;;;;YA2BY;EACV;;;;;;;;qBAyBW,aAAa;;;;WAKN,QAAQ;;;;WAKR;IACd;IACA,UAAU;;;;;WAMI,UAAU;UAjBrB;MAoBH;SAIG,WAAW,UAAU,kBAC1B,QAAQ,GACR,gBAAgB,sBACf,aAAa,UAAU,qBAAqB,KAAK;SAE7C,WACL,QAAQ,oBACR,gBAAgB,sBACf,aAAa;SAET,WACL,QAAQ,yBACR,gBAAgB,sBACf,aAAa;;;;;;;;EA2DhB,MAAM,UAAU,0BAA0B;;qBAa/B,iBAAiB;UAEpB;;;;WAKQ,QAAQ;;;;WAKR;UAET;UAIA;SAyBA,WAAW,GAChB,QAAQ,eAAe,IACvB,mBACC,iBAAiB;SAEb,WACL,QAAQ,oBACR,mBACC,iBAAiB;SAEb,WACL,QAAQ,yBACR,mBACC,iBAAiB;;;;;;;EAkBpB,MAAM,UAAU;;YAqDN,iBAAiB,oBAAoB;YAErC,oBACV,+BAA+B,sBAAsB,uBAEnD,eAAe,0BACf,4BACA,mBAAmB,0BACnB,uBACA,mBACA,qBACA,iBACA,mBACA,kBAAkB,0BAClB,aAAa,0BACb,iBAAiB,0BACjB;;;;iBAyIa,kBAAkB,qBAAqB,MACtD;EAEA,cAAc;;YAEJ,oBACR,+BACA;iBACa;;;;;EAKf;;;;;;;;;;;;;;;EAeA,mCAGM,OAAO,sBAAsB;;wBAGrB,aAAa,UAAU,qBACrC,gBAAgB,GAChB,UAAU,sBACT,kBAAkB,UAAU,qBAAqB,KAAK;wBACzC,aAAa,mBAAmB,uBAC9C,gBAAgB,GAChB,UAAU,sBACT,qBACE,WAAW,IAAI,EAAE,WAAW,qBAAqB,KAAK;wBAE3C,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,sBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,kBAChB,UAAU,sBACT,kBAAkB;wBACL,aACd,gBAAgB,oBAChB,UAAU,sBACT,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgHL,iBAAiB,UAAU,yBACzC,gBAAgB;EAAM,QAAQ;EAAG;IAChC,iBAAiB,UAAU,qBAAqB,KAAK;wBACxC,iBACd,gBACI;EACE,QAAQ;EAAoB;IACjC,iBAAiB;wBACJ,iBACd,gBACI;EACE,QAAQ;EAAkB;IAC/B,iBAAiB;;;;;YA4CR;EACV;EAQA,aAAa;EACb;EACA;GACC;;EAGD"}

package/dist/agents/runtime.d.cts

@@ -7,7 +7,7 @@ import { PregelOptions, Runtime, StreamMode } from "@langchain/langgraph";
 /**
  * Type for the agent's built-in state properties.
  */
-type AgentBuiltInState = {
+export type AgentBuiltInState = {
   /**
    * Array of messages representing the conversation history.
    *
@@ -40,7 +40,7 @@ type AgentBuiltInState = {
  */
 type IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;
 type IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;
-type WithMaybeContext<TContext> = undefined extends TContext ? {
+export type WithMaybeContext<TContext> = undefined extends TContext ? {
   readonly context?: TContext;
 } : IsOptionalZodObject<TContext> extends true ? {
   readonly context?: TContext;
@@ -69,7 +69,7 @@ type ExtractNonUndefined<T> = T extends undefined ? never : T;
 /**
  * Helper type to check if all properties of a type are optional
  */
-type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
+export type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
 /**
  * Pregel options that are propagated to the agent
  */
@@ -81,7 +81,7 @@ type CreateAgentPregelStreamOptions = "encoding" | "streamMode";
 /**
  * Decide whether provided configuration requires a context
  */
-type InvokeConfiguration<ContextSchema extends Record<string, any>> =
+export type InvokeConfiguration<ContextSchema extends Record<string, any>> =
 /**
  * If the context schema is a default object, `context` can be optional
  */
@@ -90,7 +90,7 @@ ContextSchema extends InteropZodDefault<any> ? BaseCallbackConfig & Partial<Pick
 } : IsAllOptional<ContextSchema> extends true ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {
   context?: Partial<ContextSchema>;
 } : BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;
-type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends "text/event-stream" | undefined> =
+export type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends "text/event-stream" | undefined> =
 /**
  * If the context schema is a default object, `context` can be optional
  */
@@ -100,5 +100,5 @@ ContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, a
   context?: Partial<ContextSchema>;
 } : Partial<Pick<PregelOptions<any, any, any, TStreamMode, TSubgraphs, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & WithMaybeContext<ContextSchema>;
 //#endregion
-export { AgentBuiltInState, InvokeConfiguration, IsAllOptional, Runtime$1 as Runtime, StreamConfiguration, WithMaybeContext };
+export { Runtime$1 as Runtime };
 //# sourceMappingURL=runtime.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.cts","names":[],"sources":["../../src/agents/runtime.ts"],"mappings":";;;;;;;;;KAgBY;;;;;;;;;;;;;EAaV,UAAU;;;;;;;;;;;;;EAaV,qBAAqB;;;;;KAMlB,oBAAoB,KAAK,UAAU;KACnC,mBAAmB,KAAK,UAAU;KAE3B,iBAAiB,8BAA8B;WAC5C,UAAU;IACrB,oBAAoB;WACP,UAAU;IACrB,mBAAmB;WACN,UAAU;;WACV,SAAS;;;;;KAKhB,UAAQ,sBAAsB,QACxC,KAAK,QAAiB,0CAEtB,iBAAiB;EACf;IACE;KACC;;;;;;KAkBF,eAAe,uBAAuB;;;;KAKtC,oBAAoB,KAAK,8BAA8B;;;;KAKhD,cAAc,uBAEN,WAEd,eAAe,yBAEb,oBAAoB,WAAW,iCAClB,oBAAoB,oBAG/B,eAAe;;;;KAKpB;;;;KAeA;;;;KAKO,oBAAoB,sBAAsB;;;;AAIpD,sBAAsB,yBAClB,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAKtB,cAAc,8BACZ,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAEtB,qBACE,QACE,KAAK,8BAA8B,6BAErC,iBAAiB;KAEf,oBACV,sBAAsB,qBACtB,oBAAoB,aAAa,0BACjC,4BACA;;;;AAKA,sBAAsB,yBAClB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAKpB,cAAc,8BACZ,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAEpB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B,mCAG7B,iBAAiB"}
+{"version":3,"file":"runtime.d.cts","names":["Runtime","LangGraphRuntime"],"sources":["../../src/agents/runtime.ts"],"mappings":";;;;;;;;;YAgBY;;;;;;;;;;;;;EAaV,UAAU;;;;;;;;;;;;;EAaV,qBAAqB;;;;;KAMlB,oBAAoB,KAAK,UAAU;KACnC,mBAAmB,KAAK,UAAU;YAE3B,iBAAiB,8BAA8B;WAC5C,UAAU;IACrB,oBAAoB;WACP,UAAU;IACrB,mBAAmB;WACN,UAAU;;WACV,SAAS;;;;;KAKhBA,UAAQ,sBAAsB,QACxC,KAAKC,QAAiB,0CAEtB,iBAAiB;EACf;IACE;KACC;;;;;;KAkBF,eAAe,uBAAuB;;;;KAKtC,oBAAoB,KAAK,8BAA8B;;;;YAKhD,cAAc,uBAEN,WAEd,eAAe,yBAEb,oBAAoB,WAAW,iCAClB,oBAAoB,oBAG/B,eAAe;;;;KAKpB;;;;KAeA;;;;YAKO,oBAAoB,sBAAsB;;;;AAIpD,sBAAsB,yBAClB,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAKtB,cAAc,8BACZ,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAEtB,qBACE,QACE,KAAK,8BAA8B,6BAErC,iBAAiB;YAEf,oBACV,sBAAsB,qBACtB,oBAAoB,aAAa,0BACjC,4BACA;;;;AAKA,sBAAsB,yBAClB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAKpB,cAAc,8BACZ,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAEpB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B,mCAG7B,iBAAiB"}

package/dist/agents/runtime.d.ts

@@ -7,7 +7,7 @@ import { BaseCallbackConfig } from "@langchain/core/callbacks/manager";
 /**
  * Type for the agent's built-in state properties.
  */
-type AgentBuiltInState = {
+export type AgentBuiltInState = {
   /**
    * Array of messages representing the conversation history.
    *
@@ -40,7 +40,7 @@ type AgentBuiltInState = {
  */
 type IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;
 type IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;
-type WithMaybeContext<TContext> = undefined extends TContext ? {
+export type WithMaybeContext<TContext> = undefined extends TContext ? {
   readonly context?: TContext;
 } : IsOptionalZodObject<TContext> extends true ? {
   readonly context?: TContext;
@@ -69,7 +69,7 @@ type ExtractNonUndefined<T> = T extends undefined ? never : T;
 /**
  * Helper type to check if all properties of a type are optional
  */
-type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
+export type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
 /**
  * Pregel options that are propagated to the agent
  */
@@ -81,7 +81,7 @@ type CreateAgentPregelStreamOptions = "encoding" | "streamMode";
 /**
  * Decide whether provided configuration requires a context
  */
-type InvokeConfiguration<ContextSchema extends Record<string, any>> =
+export type InvokeConfiguration<ContextSchema extends Record<string, any>> =
 /**
  * If the context schema is a default object, `context` can be optional
  */
@@ -90,7 +90,7 @@ ContextSchema extends InteropZodDefault<any> ? BaseCallbackConfig & Partial<Pick
 } : IsAllOptional<ContextSchema> extends true ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {
   context?: Partial<ContextSchema>;
 } : BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;
-type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends "text/event-stream" | undefined> =
+export type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends "text/event-stream" | undefined> =
 /**
  * If the context schema is a default object, `context` can be optional
  */
@@ -100,5 +100,5 @@ ContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, a
   context?: Partial<ContextSchema>;
 } : Partial<Pick<PregelOptions<any, any, any, TStreamMode, TSubgraphs, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & WithMaybeContext<ContextSchema>;
 //#endregion
-export { AgentBuiltInState, InvokeConfiguration, IsAllOptional, Runtime$1 as Runtime, StreamConfiguration, WithMaybeContext };
+export { Runtime$1 as Runtime };
 //# sourceMappingURL=runtime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../src/agents/runtime.ts"],"mappings":";;;;;;;;;KAgBY;;;;;;;;;;;;;EAaV,UAAU;;;;;;;;;;;;;EAaV,qBAAqB;;;;;KAMlB,oBAAoB,KAAK,UAAU;KACnC,mBAAmB,KAAK,UAAU;KAE3B,iBAAiB,8BAA8B;WAC5C,UAAU;IACrB,oBAAoB;WACP,UAAU;IACrB,mBAAmB;WACN,UAAU;;WACV,SAAS;;;;;KAKhB,UAAQ,sBAAsB,QACxC,KAAK,QAAiB,0CAEtB,iBAAiB;EACf;IACE;KACC;;;;;;KAkBF,eAAe,uBAAuB;;;;KAKtC,oBAAoB,KAAK,8BAA8B;;;;KAKhD,cAAc,uBAEN,WAEd,eAAe,yBAEb,oBAAoB,WAAW,iCAClB,oBAAoB,oBAG/B,eAAe;;;;KAKpB;;;;KAeA;;;;KAKO,oBAAoB,sBAAsB;;;;AAIpD,sBAAsB,yBAClB,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAKtB,cAAc,8BACZ,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAEtB,qBACE,QACE,KAAK,8BAA8B,6BAErC,iBAAiB;KAEf,oBACV,sBAAsB,qBACtB,oBAAoB,aAAa,0BACjC,4BACA;;;;AAKA,sBAAsB,yBAClB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAKpB,cAAc,8BACZ,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAEpB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B,mCAG7B,iBAAiB"}
+{"version":3,"file":"runtime.d.ts","names":["Runtime","LangGraphRuntime"],"sources":["../../src/agents/runtime.ts"],"mappings":";;;;;;;;;YAgBY;;;;;;;;;;;;;EAaV,UAAU;;;;;;;;;;;;;EAaV,qBAAqB;;;;;KAMlB,oBAAoB,KAAK,UAAU;KACnC,mBAAmB,KAAK,UAAU;YAE3B,iBAAiB,8BAA8B;WAC5C,UAAU;IACrB,oBAAoB;WACP,UAAU;IACrB,mBAAmB;WACN,UAAU;;WACV,SAAS;;;;;KAKhBA,UAAQ,sBAAsB,QACxC,KAAKC,QAAiB,0CAEtB,iBAAiB;EACf;IACE;KACC;;;;;;KAkBF,eAAe,uBAAuB;;;;KAKtC,oBAAoB,KAAK,8BAA8B;;;;YAKhD,cAAc,uBAEN,WAEd,eAAe,yBAEb,oBAAoB,WAAW,iCAClB,oBAAoB,oBAG/B,eAAe;;;;KAKpB;;;;KAeA;;;;YAKO,oBAAoB,sBAAsB;;;;AAIpD,sBAAsB,yBAClB,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAKtB,cAAc,8BACZ,qBACE,QACE,KAAK,8BAA8B;EAEnC,UAAU,QAAQ;IAEtB,qBACE,QACE,KAAK,8BAA8B,6BAErC,iBAAiB;YAEf,oBACV,sBAAsB,qBACtB,oBAAoB,aAAa,0BACjC,4BACA;;;;AAKA,sBAAsB,yBAClB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAKpB,cAAc,8BACZ,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B;EAG7B,UAAU,QAAQ;IAEpB,QACE,KACE,6BAA6B,aAAa,YAAY,YACtD,2BAA2B,mCAG7B,iBAAiB"}

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

@@ -24,7 +24,7 @@ interface FakeToolCallingModelFields {
 /**
  * Fake chat model for testing tool calling functionality
  */
-declare class FakeToolCallingModel extends BaseChatModel {
+export declare class FakeToolCallingModel extends BaseChatModel {
   toolCalls: ToolCall$1[][];
   toolStyle: "openai" | "anthropic";
   private indexRef;
@@ -46,5 +46,4 @@ declare class FakeToolCallingModel extends BaseChatModel {
   _generate(messages: BaseMessage[], _options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
 //#endregion
-export { FakeToolCallingModel };
 //# sourceMappingURL=utils.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../../../src/agents/tests/utils.ts"],"mappings":";;;;;;;;;;;UA2UU;EACR;EACA,MAAM;EACN;EACA;;UAGQ;EACR,YAAY;EACZ;EACA;EACA;;;;;cAWW,6BAA6B;EACxC,WAAW;EAEX;UAGQ;EAER;UAEQ;EAER,cACE,WACA,WACA,OACA,oBACA,aACG,SACF;IAA+B;MAAa;;;MAU3C;MAIA,MAAM;EAIV;EAIA;EAIA,UACE,OAAO,mBAEL,uBACA;IAGU,cAAc;;EAa5B,qBAAqB,eAAY,6BAAA,eAAA;EAQ3B,UACJ,UAAU,eACV,sCACA,cAAc,2BACb,QAAQ"}
+{"version":3,"file":"utils.d.cts","names":["ToolCall"],"sources":["../../../src/agents/tests/utils.ts"],"mappings":";;;;;;;;;;;UA2UUA;EACR;EACA,MAAM;EACN;EACA;;UAGQ;EACR,YAAYA;EACZ;EACA;EACA;;;;;qBAWW,6BAA6B;EACxC,WAAWA;EAEX;UAGQ;EAER;UAEQ;EAER,cACE,WACA,WACA,OACA,oBACA,aACG,SACF;IAA+B;MAAa;;;MAU3C;MAIA,MAAM;EAIV;EAIA;EAIA,UACE,OAAO,mBAEL,uBACA;IAGU,cAAc;;EAa5B,qBAAqB,eAAY,6BAAA,eAAA;EAQ3B,UACJ,UAAU,eACV,sCACA,cAAc,2BACb,QAAQ"}

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

@@ -24,7 +24,7 @@ interface FakeToolCallingModelFields {
 /**
  * Fake chat model for testing tool calling functionality
  */
-declare class FakeToolCallingModel extends BaseChatModel {
+export declare class FakeToolCallingModel extends BaseChatModel {
   toolCalls: ToolCall$1[][];
   toolStyle: "openai" | "anthropic";
   private indexRef;
@@ -46,5 +46,4 @@ declare class FakeToolCallingModel extends BaseChatModel {
   _generate(messages: BaseMessage[], _options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
 //#endregion
-export { FakeToolCallingModel };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/agents/tests/utils.ts"],"mappings":";;;;;;;;;;;UA2UU;EACR;EACA,MAAM;EACN;EACA;;UAGQ;EACR,YAAY;EACZ;EACA;EACA;;;;;cAWW,6BAA6B;EACxC,WAAW;EAEX;UAGQ;EAER;UAEQ;EAER,cACE,WACA,WACA,OACA,oBACA,aACG,SACF;IAA+B;MAAa;;;MAU3C;MAIA,MAAM;EAIV;EAIA;EAIA,UACE,OAAO,mBAEL,uBACA;IAGU,cAAc;;EAa5B,qBAAqB,eAAY,6BAAA,eAAA;EAQ3B,UACJ,UAAU,eACV,sCACA,cAAc,2BACb,QAAQ"}
+{"version":3,"file":"utils.d.ts","names":["ToolCall"],"sources":["../../../src/agents/tests/utils.ts"],"mappings":";;;;;;;;;;;UA2UUA;EACR;EACA,MAAM;EACN;EACA;;UAGQ;EACR,YAAYA;EACZ;EACA;EACA;;;;;qBAWW,6BAA6B;EACxC,WAAWA;EAEX;UAGQ;EAER;UAEQ;EAER,cACE,WACA,WACA,OACA,oBACA,aACG,SACF;IAA+B;MAAa;;;MAU3C;MAIA,MAAM;EAIV;EAIA;EAIA,UACE,OAAO,mBAEL,uBACA;IAGU,cAAc;;EAa5B,qBAAqB,eAAY,6BAAA,eAAA;EAQ3B,UACJ,UAAU,eACV,sCACA,cAAc,2BACb,QAAQ"}

package/dist/agents/transformers/subagent.d.cts

@@ -27,7 +27,6 @@ interface SubagentProjection {
  *   uses `[]`; nested handles use their subagent's namespace, so grandchild
  *   subagents are discovered recursively.
  */
-declare function createSubagentTransformer(scope?: Namespace): () => NativeStreamTransformer<SubagentProjection>;
+export declare function createSubagentTransformer(scope?: Namespace): () => NativeStreamTransformer<SubagentProjection>;
 //#endregion
-export { createSubagentTransformer };
 //# sourceMappingURL=subagent.d.cts.map

package/dist/agents/transformers/subagent.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent.d.cts","names":[],"sources":["../../../src/agents/transformers/subagent.ts"],"mappings":";;;UAYU;EACR,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEX,0BACd,QAAO,kBACA,wBAAwB"}
+{"version":3,"file":"subagent.d.cts","names":[],"sources":["../../../src/agents/transformers/subagent.ts"],"mappings":";;;UAYU;EACR,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBAkEX,0BACd,QAAO,kBACA,wBAAwB"}

package/dist/agents/transformers/subagent.d.ts

@@ -27,7 +27,6 @@ interface SubagentProjection {
  *   uses `[]`; nested handles use their subagent's namespace, so grandchild
  *   subagents are discovered recursively.
  */
-declare function createSubagentTransformer(scope?: Namespace): () => NativeStreamTransformer<SubagentProjection>;
+export declare function createSubagentTransformer(scope?: Namespace): () => NativeStreamTransformer<SubagentProjection>;
 //#endregion
-export { createSubagentTransformer };
 //# sourceMappingURL=subagent.d.ts.map

package/dist/agents/transformers/subagent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent.d.ts","names":[],"sources":["../../../src/agents/transformers/subagent.ts"],"mappings":";;;UAYU;EACR,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEX,0BACd,QAAO,kBACA,wBAAwB"}
+{"version":3,"file":"subagent.d.ts","names":[],"sources":["../../../src/agents/transformers/subagent.ts"],"mappings":";;;UAYU;EACR,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBAkEX,0BACd,QAAO,kBACA,wBAAwB"}

package/dist/agents/transformers/tool-call.d.cts

@@ -10,7 +10,6 @@ interface ToolCallProjection {
  * Marked `__native: true` — projection keys land directly on the
  * `GraphRunStream` instance as `run.toolCalls`.
  */
-declare function createToolCallTransformer(path: Namespace): () => NativeStreamTransformer<ToolCallProjection>;
+export declare function createToolCallTransformer(path: Namespace): () => NativeStreamTransformer<ToolCallProjection>;
 //#endregion
-export { createToolCallTransformer };
 //# sourceMappingURL=tool-call.d.cts.map

package/dist/agents/transformers/tool-call.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call.d.cts","names":[],"sources":["../../../src/agents/transformers/tool-call.ts"],"mappings":";;UAWU;EACR,WAAW,cAAc;;;;;;;;;iBAkGX,0BACd,MAAM,kBACC,wBAAwB"}
+{"version":3,"file":"tool-call.d.cts","names":[],"sources":["../../../src/agents/transformers/tool-call.ts"],"mappings":";;UAWU;EACR,WAAW,cAAc;;;;;;;;;wBAkGX,0BACd,MAAM,kBACC,wBAAwB"}

package/dist/agents/transformers/tool-call.d.ts

@@ -10,7 +10,6 @@ interface ToolCallProjection {
  * Marked `__native: true` — projection keys land directly on the
  * `GraphRunStream` instance as `run.toolCalls`.
  */
-declare function createToolCallTransformer(path: Namespace): () => NativeStreamTransformer<ToolCallProjection>;
+export declare function createToolCallTransformer(path: Namespace): () => NativeStreamTransformer<ToolCallProjection>;
 //#endregion
-export { createToolCallTransformer };
 //# sourceMappingURL=tool-call.d.ts.map

package/dist/agents/transformers/tool-call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call.d.ts","names":[],"sources":["../../../src/agents/transformers/tool-call.ts"],"mappings":";;UAWU;EACR,WAAW,cAAc;;;;;;;;;iBAkGX,0BACd,MAAM,kBACC,wBAAwB"}
+{"version":3,"file":"tool-call.d.ts","names":[],"sources":["../../../src/agents/transformers/tool-call.ts"],"mappings":";;UAWU;EACR,WAAW,cAAc;;;;;;;;;wBAkGX,0BACd,MAAM,kBACC,wBAAwB"}