@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

package/dist/tools/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TInput","TConfig","TOutput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","TArg","ToolOutputT","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\nexport type ToolOutputType = any;\nexport type ContentAndArtifact = [MessageContent, any];\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Default config object for the tool runnable.\n     */\n    defaultConfig?: ToolRunnableConfig;\n    /**\n     * Whether to show full details in the thrown parsing errors.\n     *\n     * @default false\n     */\n    verboseParsingErrors?: boolean;\n    /**\n     * Metadata for the tool.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\" | \"extras\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\n}\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, any>;\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\n    /**\n     * Invokes the tool with the provided argument and configuration.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration for the tool call.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument, configuration, and tags. It\n     * parses the input according to the schema, handles any errors, and\n     * manages callbacks.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration or callbacks for the tool.\n     * @param tags Optional tags for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect: boolean;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument and callbacks. It handles\n     * string inputs specifically.\n     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n     * @param callbacks Optional callbacks for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n    name: string;\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect?: boolean;\n}\n/**\n * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\n}\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    /**\n     * Tool handler function - the function that will be called when the tool is invoked.\n     *\n     * @param input - The input to the tool.\n     * @param runManager - The run manager for the tool.\n     * @param config - The configuration for the tool.\n     * @returns The result of the tool.\n     */\n    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\n}\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;\n    /**\n     * The ID of the current tool call.\n     */\n    toolCallId: string;\n    /**\n     * The current tool call.\n     */\n    toolCall?: ToolCall;\n    /**\n     * RunnableConfig for the current execution.\n     */\n    config: ToolRunnableConfig;\n    /**\n     * Runtime context (from langgraph `Runtime`).\n     */\n    context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;\n    /**\n     * BaseStore instance for persistent storage (from langgraph `Runtime`).\n     */\n    store: BaseStore<string, unknown> | null;\n    /**\n     * Stream writer for streaming output (from langgraph `Runtime`).\n     */\n    writer: ((chunk: unknown) => void) | null;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}

package/dist/tools/types.d.ts

@@ -13,9 +13,7 @@ import { z } from "zod/v3";
 
 //#region src/tools/types.d.ts
 type ResponseFormat = "content" | "content_and_artifact" | string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ToolOutputType = any;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ContentAndArtifact = [MessageContent, any];
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
@@ -77,11 +75,7 @@ interface ToolParams extends BaseLangChainParams {
    */
   extras?: Record<string, unknown>;
 }
-type ToolRunnableConfig<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ConfigurableFieldType extends Record<string, any> = Record<string, any>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {
+type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {
   toolCall?: ToolCall;
   context?: ContextSchema;
 };
@@ -136,9 +130,7 @@ type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolI
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-any>;
+type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef, any>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -213,9 +205,7 @@ interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInpu
    * @param callbacks Optional callbacks for the tool.
    * @returns A Promise that resolves with a string.
    */
-  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(
-  // TODO: shouldn't this be narrowed based on SchemaT?
-  arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
  * Base interface for the input parameters of the {@link DynamicTool} and

package/dist/tools/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TInput","TConfig","TOutput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","TArg","ToolOutputT","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\nexport type ToolOutputType = any;\nexport type ContentAndArtifact = [MessageContent, any];\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Default config object for the tool runnable.\n     */\n    defaultConfig?: ToolRunnableConfig;\n    /**\n     * Whether to show full details in the thrown parsing errors.\n     *\n     * @default false\n     */\n    verboseParsingErrors?: boolean;\n    /**\n     * Metadata for the tool.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\" | \"extras\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\n}\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, any>;\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\n    /**\n     * Invokes the tool with the provided argument and configuration.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration for the tool call.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument, configuration, and tags. It\n     * parses the input according to the schema, handles any errors, and\n     * manages callbacks.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration or callbacks for the tool.\n     * @param tags Optional tags for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect: boolean;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument and callbacks. It handles\n     * string inputs specifically.\n     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n     * @param callbacks Optional callbacks for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n    name: string;\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect?: boolean;\n}\n/**\n * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\n}\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    /**\n     * Tool handler function - the function that will be called when the tool is invoked.\n     *\n     * @param input - The input to the tool.\n     * @param runManager - The run manager for the tool.\n     * @param config - The configuration for the tool.\n     * @returns The result of the tool.\n     */\n    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\n}\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;\n    /**\n     * The ID of the current tool call.\n     */\n    toolCallId: string;\n    /**\n     * The current tool call.\n     */\n    toolCall?: ToolCall;\n    /**\n     * RunnableConfig for the current execution.\n     */\n    config: ToolRunnableConfig;\n    /**\n     * Runtime context (from langgraph `Runtime`).\n     */\n    context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;\n    /**\n     * BaseStore instance for persistent storage (from langgraph `Runtime`).\n     */\n    store: BaseStore<string, unknown> | null;\n    /**\n     * Stream writer for streaming output (from langgraph `Runtime`).\n     */\n    writer: ((chunk: unknown) => void) | null;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;;;KAUYkB,cAAAA;KACAC,cAAAA;KACAC,kBAAAA,IAAsBT;;AAFlC;AACA;AACA;AAOA;;AAAuEH,KAA3Da,cAA2Db,CAAAA,MAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAhBgB,OAAgBhB,SAAAA,gBAAAA,GAAmBgB,OAAnBhB,GAA6Be,OAA7Bf,SAAAA;EAAmBgB,QAAAA,EAAAA;IAAUD,EAAAA,EAAAA,MAAAA;EAIhGb,CAAAA;CAAca,GAAdb,WAAca,GAAAA,OAAAA,SAAAA;EAIdC,QAAAA,EAAAA;IAAUD,EAAAA,EAAAA,SAAAA;EAIVC,CAAAA;CAAUd,GAJVc,OAIUd,GAJAa,OAIAb,SAAAA;EAAcY,QAAAA,EAAAA;IAAeb,EAAAA,CAAAA,EAAAA,MAAAA;EAAWC,CAAAA;CAAcc,GAAhEA,OAAgEA,GAAtDd,WAAsDc,GAAxCF,MAAwCE,SAAzBf,QAAyBe,GAAdd,WAAcc,GAAAA,OAAAA;AAAO;AAK3E;AAIA;;AAcoBI,KAlBRH,mBAAAA,GAAsBxB,CAAAA,CAAGyB,UAkBjBE,GAlB8BZ,eAkB9BY;;;;AAdmC,UAAtCD,UAAAA,SAAmBxB,mBAAmB,CAAA;EAiC3CyB;;;;;;;AAEe;AAO3B;EAiBYO,cAAAA,CAAAA,EAjDSjB,cAiDgB;EAAMkB;;;EAA2BvB,aAAAA,CAAAA,EA7ClDe,kBA6CkDf;EAA2BuB;;AAAoB;AAYrH;;EAAoDtB,oBAAAA,CAAAA,EAAAA,OAAAA;EAAsCsB;;;EAAepB,QAAAA,CAAAA,EA/C1Fa,MA+C0Fb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAU;AAOnH;;;;;EAAwHmB,MAAAA,CAAAA,EA/C3GN,MA+C2GM,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;AAAqF1B,KA7CjMmB,kBA6CiMnB,CAAAA,8BA7ChJoB,MA6CgJpB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GA7C1HoB,MA6C0HpB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,gBAAAA,GAAAA,CAAAA,GA7C9EJ,cA6C8EI,CA7C/DqB,qBA6C+DrB,CAAAA,GAAAA;EAAQ,QAAA,CAAA,EA5CtMA,QA4CsM;EAUzMgC,OAAAA,CAAAA,EArDEV,aAqDFU;AAuBZ,CAAA;;;;;;AAAmND,UArElMR,oBAAAA,SAA6BE,IAqEqKM,CArEhKP,uBAqEgKO,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,QAAAA,CAAAA,CAAAA;EAAjCF;;;EAKtKC,WAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;;;;;;AAmB2CC,KA5E3CL,yBA4E2CK,CAAAA,CAAAA,CAAAA,GA5EZJ,CA4EYI,SA5EF1B,cA4EE0B,GA5Ee3B,qBA4Ef2B,CA5EqCJ,CA4ErCI,CAAAA,GA5E0CJ,CA4E1CI,SA5EoDxB,eA4EpDwB,GAAAA,OAAAA,GAAAA,KAAAA;;;;;;;;;;;;AAxB0H,KAxCrKH,wBAwCqK,CAAA,CAAA,CAAA,GAxCvID,CAwCuI,SAxC7HtB,cAwC6H,GAxC5GF,oBAwC4G,CAxCvFwB,CAwCuF,CAAA,GAxClFA,CAwCkF,SAxCxEpB,eAwCwE,GAAA,OAAA,GAAA,KAAA;AAwDjL;;;;;;AAAyLwB,KAzF7KF,uBAyF6KE,CAAAA,UAzF3If,mBAyF2Ie,EAAAA,eAzFvGH,wBAyFuGG,CAzF9ED,OAyF8EC,CAAAA,CAAAA,GAAAA,CAzFjEL,yBAyFiEK,CAzFvCD,OAyFuCC,CAAAA,SAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA,CAAAA,GAzFKA,YAyFLA,GAzFoB/B,QAyFpB+B;;;;;;;;;;AAUQjB,KAzFrLkB,qBAAAA,GAAwBxC,CAAAA,CAAG0C,OAyF0JpB,CAAAA,MAAAA,GAAAA,SAAAA,EAzF9HtB,CAAAA,CAAGyC,UAyF2HnB,EAAAA,GAAAA,CAAAA;AAoBrG;AAS5F;;;;;;;;AAS6GuB,UAxG5Fb,uBAwG4Fa,CAAAA,UAxG1DrB,mBAwG0DqB,EAAAA,eAxGtBT,wBAwGsBS,CAxGGP,OAwGHO,CAAAA,EAAAA,cAxG2B3B,cAwG3B2B,CAAAA,SAxGmDvC,iBAwGnDuC,CAxGqER,uBAwGrEQ,CAxG6FP,OAwG7FO,EAxGsGN,YAwGtGM,CAAAA,EAxGqHA,WAwGrHA,GAxGmIpC,WAwGnIoC,CAAAA,CAAAA;EAARC,YAAAA,EAAAA,MAAAA,EAAAA;EACzFR;;AAV6K;EAkBjKe,MAAAA,EA5GZf,OA4GYe;EAAwBrB;;;;AAAuF;AAOvI;EAOwBuB,MAAAA,CAAAA,aAnHAlB,uBAmHgDN,CAnHxBO,OAmHwBP,EAnHfQ,YAmHmC,CAAA,EAAA,gBAnHJZ,kBAmHI,GAAA,SAAA,CAAA,CAAA,GAAA,EAnHiCiB,IAmHjC,EAAA,SAAA,CAAA,EAnHmDtB,OAmHnD,CAAA,EAnH6DwB,OAmH7D,CAnHqE1B,cAmHrE,CAnHoFwB,IAmHpF,EAnH0FtB,OAmH1F,EAnHmGuB,WAmHnG,CAAA,CAAA;EASpEW;AA8DxB;;;;;;;;;;EAgBY7B,IAAAA,CAAAA,aA9LUU,uBA8LVV,CA9LkCW,OA8LlCX,EA9L2CY,YA8L3CZ,CAAAA,EAAAA,gBA9L0EA,kBA8L1EA,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EA9L+GiB,IA8L/GjB,EAAAA,SAAAA,CAAAA,EA9LiIL,OA8LjIK,EAICgC;EAAiB7C,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAhMRgC,OAgMQhC,CAhMAM,cAgMAN,CAhMe8B,IAgMf9B,EAhMqBQ,OAgMrBR,EAhM8B+B,WAgM9B/B,CAAAA,CAAAA;EAAyC6C;;;EAA6B/B,IAAAA,EAAAA,MAAAA;EAA0B+B;;AAI1G;;;;;;;;;;;;;;;WA9KP/B;;;;;;;;UAQImB,wBAAwBP,sCAAsCJ,yBAAyBE,wBAAwBpB,wBAAwBc,wBAAwBM,SAASC,cAAcM;;;;;;;;;;oBAUjLR,wBAAwBC,SAASC,+BAA+BZ,qCAAqCiB,kBAAkBtB,UAAUwB,QAAQ1B,eAAe4B,YAAYJ,OAAOtB,SAASuB;;;;;;UAMzLI,oBAAAA,SAA6BvB;;;;;;;;;;;;;;UAc7BwB,+BAA+BhC,wBAAwB+B;qCACjChD,oCAAoC0B,uBAAuBmB,QAAQD;;;;;;;;UAQzFM,qCAAqC3B,qCAAqCU,0BAA0BI,wBAAwBpB,wBAAwB+B;;;;;;;;;gBASnJG,4BAA4BnD,oCAAoCG,mBAAmB0C,QAAQD;UACjGP;;;;;;;;iBAQYe,gBAAAA,QAAwBrB,0BAA0B7B,iBAAiBY,0BAAqBiB;;;;;;;iBAOxFsB,kBAAAA,0BAA4CjD;;;;;;;iBAO5CkD,sBAAAA,0BAAgDxB;;;;;;;;;iBAShDyB,eAAAA,0BAAyCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8DrD0B,oDAAoDrD;;;;SAIrDsD,eAAe5C,mBAAmBF,sBAAsB8C,UAAUA,eAAe9B,0BAA0B8B;;;;;;;;aAQvGlD;;;;UAIHmB;;;;WAICgC,iBAAiB7C,mBAAmBF,sBAAsB+C,YAAYA,iBAAiB/B,0BAA0B+B;;;;SAInH3C"}

package/dist/tools/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}

package/dist/tools/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}

package/dist/tracers/base.d.cts

@@ -11,14 +11,11 @@ import { RunTree } from "langsmith/run_trees";
 
 //#region src/tracers/base.d.ts
 type RunType = string;
-// TODO: Remove this type and just use the base LangSmith Run type.
 interface Run extends BaseRun {
-  // some optional fields are always present here
   id: string;
   start_time: number;
   end_time?: number;
   execution_order: number;
-  // some additional fields that don't exist in sdk runs
   child_runs: this[];
   child_execution_order: number;
   events: Array<{
@@ -58,12 +55,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -95,12 +90,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -131,12 +124,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -169,12 +160,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -211,12 +200,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -230,7 +217,6 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     _serialized_start_time?: string | undefined;
   };
   handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   handleToolEnd(output: any, runId: string): Promise<Run>;
   handleToolError(error: unknown, runId: string): Promise<Run>;
   handleAgentAction(action: AgentAction, runId: string): Promise<void>;
@@ -252,12 +238,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -275,7 +259,6 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
   handleRetrieverError(error: unknown, runId: string): Promise<Run>;
   handleText(text: string, runId: string): Promise<void>;
   handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;
-  // custom event handlers
   onRunCreate?(run: Run): void | Promise<void>;
   onRunUpdate?(run: Run): void | Promise<void>;
   onLLMStart?(run: Run): void | Promise<void>;
@@ -293,9 +276,7 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
   onRetrieverEnd?(run: Run): void | Promise<void>;
   onRetrieverError?(run: Run): void | Promise<void>;
   onText?(run: Run): void | Promise<void>;
-  onLLMNewToken?(run: Run, token: string,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  kwargs?: {
+  onLLMNewToken?(run: Run, token: string, kwargs?: {
     chunk: any;
   }): void | Promise<void>;
 }

package/dist/tracers/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["KVMap","BaseRun","RunTree","ChainValues","AgentAction","AgentFinish","LLMResult","BaseMessage","Serialized","BaseCallbackHandler","BaseCallbackHandlerInput","HandleLLMNewTokenCallbackFields","NewTokenIndices","Document","RunType","Run","Record","Array","AgentRun","isBaseTracer","BaseTracer","Map","Promise","langsmith_schemas0","Attachments"],"sources":["../../src/tracers/base.d.ts"],"sourcesContent":["import { KVMap, BaseRun } from \"langsmith/schemas\";\nimport { RunTree } from \"langsmith/run_trees\";\nimport type { ChainValues } from \"../utils/types/index.js\";\nimport type { AgentAction, AgentFinish } from \"../agents.js\";\nimport type { LLMResult } from \"../outputs.js\";\nimport type { BaseMessage } from \"../messages/base.js\";\nimport { Serialized } from \"../load/serializable.js\";\nimport { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields, NewTokenIndices } from \"../callbacks/base.js\";\nimport type { Document } from \"../documents/document.js\";\nexport type RunType = string;\nexport interface Run extends BaseRun {\n    id: string;\n    start_time: number;\n    end_time?: number;\n    execution_order: number;\n    child_runs: this[];\n    child_execution_order: number;\n    events: Array<{\n        name: string;\n        time: string;\n        kwargs?: Record<string, unknown>;\n    }>;\n    trace_id?: string;\n    dotted_order?: string;\n    /** @internal */\n    _serialized_start_time?: string;\n}\nexport interface AgentRun extends Run {\n    actions: AgentAction[];\n}\nexport declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;\nexport declare abstract class BaseTracer extends BaseCallbackHandler {\n    /** @deprecated Use `runTreeMap` instead. */\n    protected runMap: Map<string, Run>;\n    protected runTreeMap: Map<string, RunTree>;\n    protected usesRunTreeMap: boolean;\n    constructor(_fields?: BaseCallbackHandlerInput);\n    copy(): this;\n    protected getRunById(runId?: string): Run | undefined;\n    protected stringifyError(error: unknown): string;\n    protected abstract persistRun(run: Run): Promise<void>;\n    protected _addChildRun(parentRun: Run, childRun: Run): void;\n    _addRunToRunMap(run: Run): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    protected _endTrace(run: Run): Promise<void>;\n    protected _getExecutionOrder(parentRunId: string | undefined): number;\n    /**\n     * Create and add a run to the run map for LLM start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chat model start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleLLMEnd(output: LLMResult, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    handleLLMError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chain start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;\n    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    /**\n     * Create and add a run to the run map for tool start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleToolEnd(output: any, runId: string): Promise<Run>;\n    handleToolError(error: unknown, runId: string): Promise<Run>;\n    handleAgentAction(action: AgentAction, runId: string): Promise<void>;\n    handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;\n    /**\n     * Create and add a run to the run map for retriever start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;\n    handleRetrieverError(error: unknown, runId: string): Promise<Run>;\n    handleText(text: string, runId: string): Promise<void>;\n    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;\n    onRunCreate?(run: Run): void | Promise<void>;\n    onRunUpdate?(run: Run): void | Promise<void>;\n    onLLMStart?(run: Run): void | Promise<void>;\n    onLLMEnd?(run: Run): void | Promise<void>;\n    onLLMError?(run: Run): void | Promise<void>;\n    onChainStart?(run: Run): void | Promise<void>;\n    onChainEnd?(run: Run): void | Promise<void>;\n    onChainError?(run: Run): void | Promise<void>;\n    onToolStart?(run: Run): void | Promise<void>;\n    onToolEnd?(run: Run): void | Promise<void>;\n    onToolError?(run: Run): void | Promise<void>;\n    onAgentAction?(run: Run): void | Promise<void>;\n    onAgentEnd?(run: Run): void | Promise<void>;\n    onRetrieverStart?(run: Run): void | Promise<void>;\n    onRetrieverEnd?(run: Run): void | Promise<void>;\n    onRetrieverError?(run: Run): void | Promise<void>;\n    onText?(run: Run): void | Promise<void>;\n    onLLMNewToken?(run: Run, token: string, kwargs?: {\n        chunk: any;\n    }): void | Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":"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"}

package/dist/tracers/base.d.ts

@@ -11,14 +11,11 @@ import { BaseRun, KVMap } from "langsmith/schemas";
 
 //#region src/tracers/base.d.ts
 type RunType = string;
-// TODO: Remove this type and just use the base LangSmith Run type.
 interface Run extends BaseRun {
-  // some optional fields are always present here
   id: string;
   start_time: number;
   end_time?: number;
   execution_order: number;
-  // some additional fields that don't exist in sdk runs
   child_runs: this[];
   child_execution_order: number;
   events: Array<{
@@ -58,12 +55,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -95,12 +90,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -131,12 +124,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -169,12 +160,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -211,12 +200,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -230,7 +217,6 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     _serialized_start_time?: string | undefined;
   };
   handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   handleToolEnd(output: any, runId: string): Promise<Run>;
   handleToolError(error: unknown, runId: string): Promise<Run>;
   handleAgentAction(action: AgentAction, runId: string): Promise<void>;
@@ -252,12 +238,10 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
     parent_run_id?: string | undefined;
     tags?: string[] | undefined;
     attachments?: langsmith_schemas0.Attachments | undefined;
-    // some optional fields are always present here
     id: string;
     start_time: number;
     end_time?: number | undefined;
     execution_order: number;
-    // some additional fields that don't exist in sdk runs
     child_runs: Run[];
     child_execution_order: number;
     events: {
@@ -275,7 +259,6 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
   handleRetrieverError(error: unknown, runId: string): Promise<Run>;
   handleText(text: string, runId: string): Promise<void>;
   handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;
-  // custom event handlers
   onRunCreate?(run: Run): void | Promise<void>;
   onRunUpdate?(run: Run): void | Promise<void>;
   onLLMStart?(run: Run): void | Promise<void>;
@@ -293,9 +276,7 @@ declare abstract class BaseTracer extends BaseCallbackHandler {
   onRetrieverEnd?(run: Run): void | Promise<void>;
   onRetrieverError?(run: Run): void | Promise<void>;
   onText?(run: Run): void | Promise<void>;
-  onLLMNewToken?(run: Run, token: string,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  kwargs?: {
+  onLLMNewToken?(run: Run, token: string, kwargs?: {
     chunk: any;
   }): void | Promise<void>;
 }

package/dist/tracers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["KVMap","BaseRun","RunTree","ChainValues","AgentAction","AgentFinish","LLMResult","BaseMessage","Serialized","BaseCallbackHandler","BaseCallbackHandlerInput","HandleLLMNewTokenCallbackFields","NewTokenIndices","Document","RunType","Run","Record","Array","AgentRun","isBaseTracer","BaseTracer","Map","Promise","langsmith_schemas0","Attachments"],"sources":["../../src/tracers/base.d.ts"],"sourcesContent":["import { KVMap, BaseRun } from \"langsmith/schemas\";\nimport { RunTree } from \"langsmith/run_trees\";\nimport type { ChainValues } from \"../utils/types/index.js\";\nimport type { AgentAction, AgentFinish } from \"../agents.js\";\nimport type { LLMResult } from \"../outputs.js\";\nimport type { BaseMessage } from \"../messages/base.js\";\nimport { Serialized } from \"../load/serializable.js\";\nimport { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields, NewTokenIndices } from \"../callbacks/base.js\";\nimport type { Document } from \"../documents/document.js\";\nexport type RunType = string;\nexport interface Run extends BaseRun {\n    id: string;\n    start_time: number;\n    end_time?: number;\n    execution_order: number;\n    child_runs: this[];\n    child_execution_order: number;\n    events: Array<{\n        name: string;\n        time: string;\n        kwargs?: Record<string, unknown>;\n    }>;\n    trace_id?: string;\n    dotted_order?: string;\n    /** @internal */\n    _serialized_start_time?: string;\n}\nexport interface AgentRun extends Run {\n    actions: AgentAction[];\n}\nexport declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;\nexport declare abstract class BaseTracer extends BaseCallbackHandler {\n    /** @deprecated Use `runTreeMap` instead. */\n    protected runMap: Map<string, Run>;\n    protected runTreeMap: Map<string, RunTree>;\n    protected usesRunTreeMap: boolean;\n    constructor(_fields?: BaseCallbackHandlerInput);\n    copy(): this;\n    protected getRunById(runId?: string): Run | undefined;\n    protected stringifyError(error: unknown): string;\n    protected abstract persistRun(run: Run): Promise<void>;\n    protected _addChildRun(parentRun: Run, childRun: Run): void;\n    _addRunToRunMap(run: Run): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    protected _endTrace(run: Run): Promise<void>;\n    protected _getExecutionOrder(parentRunId: string | undefined): number;\n    /**\n     * Create and add a run to the run map for LLM start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chat model start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleLLMEnd(output: LLMResult, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    handleLLMError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chain start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;\n    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    /**\n     * Create and add a run to the run map for tool start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleToolEnd(output: any, runId: string): Promise<Run>;\n    handleToolError(error: unknown, runId: string): Promise<Run>;\n    handleAgentAction(action: AgentAction, runId: string): Promise<void>;\n    handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;\n    /**\n     * Create and add a run to the run map for retriever start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;\n    handleRetrieverError(error: unknown, runId: string): Promise<Run>;\n    handleText(text: string, runId: string): Promise<void>;\n    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;\n    onRunCreate?(run: Run): void | Promise<void>;\n    onRunUpdate?(run: Run): void | Promise<void>;\n    onLLMStart?(run: Run): void | Promise<void>;\n    onLLMEnd?(run: Run): void | Promise<void>;\n    onLLMError?(run: Run): void | Promise<void>;\n    onChainStart?(run: Run): void | Promise<void>;\n    onChainEnd?(run: Run): void | Promise<void>;\n    onChainError?(run: Run): void | Promise<void>;\n    onToolStart?(run: Run): void | Promise<void>;\n    onToolEnd?(run: Run): void | Promise<void>;\n    onToolError?(run: Run): void | Promise<void>;\n    onAgentAction?(run: Run): void | Promise<void>;\n    onAgentEnd?(run: Run): void | Promise<void>;\n    onRetrieverStart?(run: Run): void | Promise<void>;\n    onRetrieverEnd?(run: Run): void | Promise<void>;\n    onRetrieverError?(run: Run): void | Promise<void>;\n    onText?(run: Run): void | Promise<void>;\n    onLLMNewToken?(run: Run, token: string, kwargs?: {\n        chunk: any;\n    }): void | Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":"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"}

package/dist/tracers/console.d.cts

@@ -26,7 +26,6 @@ declare class ConsoleCallbackHandler extends BaseTracer {
    * @returns A resolved promise.
    */
   protected persistRun(_run: Run): Promise<void>;
-  // utility methods
   /**
    * Method used to get all the parent runs of a given run.
    * @param run The run whose parents are to be retrieved.
@@ -40,7 +39,6 @@ declare class ConsoleCallbackHandler extends BaseTracer {
    * @returns A string representation of the run's lineage.
    */
   getBreadcrumbs(run: Run): string;
-  // logging methods
   /**
    * Method used to log the start of a chain run.
    * @param run The chain run that has started.

package/dist/tracers/console.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.cts","names":["BaseTracer","Run","ConsoleCallbackHandler","Promise"],"sources":["../../src/tracers/console.d.ts"],"sourcesContent":["import { BaseTracer, type Run } from \"./base.js\";\n/**\n * A tracer that logs all events to the console. It extends from the\n * `BaseTracer` class and overrides its methods to provide custom logging\n * functionality.\n * @example\n * ```typescript\n *\n * const llm = new ChatAnthropic({\n *   temperature: 0,\n *   tags: [\"example\", \"callbacks\", \"constructor\"],\n *   callbacks: [new ConsoleCallbackHandler()],\n * });\n *\n * ```\n */\nexport declare class ConsoleCallbackHandler extends BaseTracer {\n    name: \"console_callback_handler\";\n    /**\n     * Method used to persist the run. In this case, it simply returns a\n     * resolved promise as there's no persistence logic.\n     * @param _run The run to persist.\n     * @returns A resolved promise.\n     */\n    protected persistRun(_run: Run): Promise<void>;\n    /**\n     * Method used to get all the parent runs of a given run.\n     * @param run The run whose parents are to be retrieved.\n     * @returns An array of parent runs.\n     */\n    getParents(run: Run): Run[];\n    /**\n     * Method used to get a string representation of the run's lineage, which\n     * is used in logging.\n     * @param run The run whose lineage is to be retrieved.\n     * @returns A string representation of the run's lineage.\n     */\n    getBreadcrumbs(run: Run): string;\n    /**\n     * Method used to log the start of a chain run.\n     * @param run The chain run that has started.\n     * @returns void\n     */\n    onChainStart(run: Run): void;\n    /**\n     * Method used to log the end of a chain run.\n     * @param run The chain run that has ended.\n     * @returns void\n     */\n    onChainEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a chain run.\n     * @param run The chain run that has errored.\n     * @returns void\n     */\n    onChainError(run: Run): void;\n    /**\n     * Method used to log the start of an LLM run.\n     * @param run The LLM run that has started.\n     * @returns void\n     */\n    onLLMStart(run: Run): void;\n    /**\n     * Method used to log the end of an LLM run.\n     * @param run The LLM run that has ended.\n     * @returns void\n     */\n    onLLMEnd(run: Run): void;\n    /**\n     * Method used to log any errors of an LLM run.\n     * @param run The LLM run that has errored.\n     * @returns void\n     */\n    onLLMError(run: Run): void;\n    /**\n     * Method used to log the start of a tool run.\n     * @param run The tool run that has started.\n     * @returns void\n     */\n    onToolStart(run: Run): void;\n    /**\n     * Method used to log the end of a tool run.\n     * @param run The tool run that has ended.\n     * @returns void\n     */\n    onToolEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a tool run.\n     * @param run The tool run that has errored.\n     * @returns void\n     */\n    onToolError(run: Run): void;\n    /**\n     * Method used to log the start of a retriever run.\n     * @param run The retriever run that has started.\n     * @returns void\n     */\n    onRetrieverStart(run: Run): void;\n    /**\n     * Method used to log the end of a retriever run.\n     * @param run The retriever run that has ended.\n     * @returns void\n     */\n    onRetrieverEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a retriever run.\n     * @param run The retriever run that has errored.\n     * @returns void\n     */\n    onRetrieverError(run: Run): void;\n    /**\n     * Method used to log the action selected by the agent.\n     * @param run The run in which the agent action occurred.\n     * @returns void\n     */\n    onAgentAction(run: Run): void;\n}\n//# sourceMappingURL=console.d.ts.map"],"mappings":";;;;;;AAgBA;;;;;;;;;;;;;AAqEmBC,cArEEC,sBAAAA,SAA+BF,UAAAA,CAqEjCC;EAMEA,IAAAA,EAAAA,0BAAAA;EAMKA;;;;;AAjFoC;6BAQ/BA,MAAME;;;;;;kBAMjBF,MAAMA;;;;;;;sBAOFA;;;;;;oBAMFA;;;;;;kBAMFA;;;;;;oBAMEA;;;;;;kBAMFA;;;;;;gBAMFA;;;;;;kBAMEA;;;;;;mBAMCA;;;;;;iBAMFA;;;;;;mBAMEA;;;;;;wBAMKA;;;;;;sBAMFA;;;;;;wBAMEA;;;;;;qBAMHA"}

package/dist/tracers/console.d.ts

@@ -26,7 +26,6 @@ declare class ConsoleCallbackHandler extends BaseTracer {
    * @returns A resolved promise.
    */
   protected persistRun(_run: Run): Promise<void>;
-  // utility methods
   /**
    * Method used to get all the parent runs of a given run.
    * @param run The run whose parents are to be retrieved.
@@ -40,7 +39,6 @@ declare class ConsoleCallbackHandler extends BaseTracer {
    * @returns A string representation of the run's lineage.
    */
   getBreadcrumbs(run: Run): string;
-  // logging methods
   /**
    * Method used to log the start of a chain run.
    * @param run The chain run that has started.

package/dist/tracers/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","names":["BaseTracer","Run","ConsoleCallbackHandler","Promise"],"sources":["../../src/tracers/console.d.ts"],"sourcesContent":["import { BaseTracer, type Run } from \"./base.js\";\n/**\n * A tracer that logs all events to the console. It extends from the\n * `BaseTracer` class and overrides its methods to provide custom logging\n * functionality.\n * @example\n * ```typescript\n *\n * const llm = new ChatAnthropic({\n *   temperature: 0,\n *   tags: [\"example\", \"callbacks\", \"constructor\"],\n *   callbacks: [new ConsoleCallbackHandler()],\n * });\n *\n * ```\n */\nexport declare class ConsoleCallbackHandler extends BaseTracer {\n    name: \"console_callback_handler\";\n    /**\n     * Method used to persist the run. In this case, it simply returns a\n     * resolved promise as there's no persistence logic.\n     * @param _run The run to persist.\n     * @returns A resolved promise.\n     */\n    protected persistRun(_run: Run): Promise<void>;\n    /**\n     * Method used to get all the parent runs of a given run.\n     * @param run The run whose parents are to be retrieved.\n     * @returns An array of parent runs.\n     */\n    getParents(run: Run): Run[];\n    /**\n     * Method used to get a string representation of the run's lineage, which\n     * is used in logging.\n     * @param run The run whose lineage is to be retrieved.\n     * @returns A string representation of the run's lineage.\n     */\n    getBreadcrumbs(run: Run): string;\n    /**\n     * Method used to log the start of a chain run.\n     * @param run The chain run that has started.\n     * @returns void\n     */\n    onChainStart(run: Run): void;\n    /**\n     * Method used to log the end of a chain run.\n     * @param run The chain run that has ended.\n     * @returns void\n     */\n    onChainEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a chain run.\n     * @param run The chain run that has errored.\n     * @returns void\n     */\n    onChainError(run: Run): void;\n    /**\n     * Method used to log the start of an LLM run.\n     * @param run The LLM run that has started.\n     * @returns void\n     */\n    onLLMStart(run: Run): void;\n    /**\n     * Method used to log the end of an LLM run.\n     * @param run The LLM run that has ended.\n     * @returns void\n     */\n    onLLMEnd(run: Run): void;\n    /**\n     * Method used to log any errors of an LLM run.\n     * @param run The LLM run that has errored.\n     * @returns void\n     */\n    onLLMError(run: Run): void;\n    /**\n     * Method used to log the start of a tool run.\n     * @param run The tool run that has started.\n     * @returns void\n     */\n    onToolStart(run: Run): void;\n    /**\n     * Method used to log the end of a tool run.\n     * @param run The tool run that has ended.\n     * @returns void\n     */\n    onToolEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a tool run.\n     * @param run The tool run that has errored.\n     * @returns void\n     */\n    onToolError(run: Run): void;\n    /**\n     * Method used to log the start of a retriever run.\n     * @param run The retriever run that has started.\n     * @returns void\n     */\n    onRetrieverStart(run: Run): void;\n    /**\n     * Method used to log the end of a retriever run.\n     * @param run The retriever run that has ended.\n     * @returns void\n     */\n    onRetrieverEnd(run: Run): void;\n    /**\n     * Method used to log any errors of a retriever run.\n     * @param run The retriever run that has errored.\n     * @returns void\n     */\n    onRetrieverError(run: Run): void;\n    /**\n     * Method used to log the action selected by the agent.\n     * @param run The run in which the agent action occurred.\n     * @returns void\n     */\n    onAgentAction(run: Run): void;\n}\n//# sourceMappingURL=console.d.ts.map"],"mappings":";;;;;;AAgBA;;;;;;;;;;;;;AAqEmBC,cArEEC,sBAAAA,SAA+BF,UAAAA,CAqEjCC;EAMEA,IAAAA,EAAAA,0BAAAA;EAMKA;;;;;AAjFoC;6BAQ/BA,MAAME;;;;;;kBAMjBF,MAAMA;;;;;;;sBAOFA;;;;;;oBAMFA;;;;;;kBAMFA;;;;;;oBAMEA;;;;;;kBAMFA;;;;;;gBAMFA;;;;;;kBAMEA;;;;;;mBAMCA;;;;;;iBAMFA;;;;;;mBAMEA;;;;;;wBAMKA;;;;;;sBAMFA;;;;;;wBAMEA;;;;;;qBAMHA"}

package/dist/tracers/event_stream.d.cts

@@ -14,7 +14,6 @@ type StreamEventData = {
    * won't be known until the *END* of the runnable when it has finished streaming
    * its inputs.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   input?: any;
   /**
    * The output of the runnable that generated the event.
@@ -23,14 +22,12 @@ type StreamEventData = {
    * though there might be some exceptions for special cased runnables (e.g., like
    * chat models), which may return more information.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   output?: any;
   /**
    * A streaming chunk from the output that generated the event.
    * chunks support addition in general, and adding them up should result
    * in the output of the runnable that generated the event.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   chunk?: any;
 };
 /**
@@ -74,7 +71,6 @@ type StreamEvent = {
    */
   tags?: string[];
   /** Metadata associated with the runnable that generated this event. */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   metadata: Record<string, any>;
   /**
    * Event data.

package/dist/tracers/event_stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_stream.d.cts","names":["BaseTracer","Run","BaseCallbackHandler","BaseCallbackHandlerInput","CallbackHandlerPrefersStreaming","IterableReadableStream","StreamEventData","StreamEvent","Record","RunInfo","EventStreamCallbackHandlerInput","isStreamEventsHandler","EventStreamCallbackHandler","T","TransformStream","WritableStreamDefaultWriter","Symbol","asyncIterator","Promise","AsyncGenerator"],"sources":["../../src/tracers/event_stream.d.ts"],"sourcesContent":["import { BaseTracer, type Run } from \"./base.js\";\nimport { BaseCallbackHandler, BaseCallbackHandlerInput, CallbackHandlerPrefersStreaming } from \"../callbacks/base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\n/**\n * Data associated with a StreamEvent.\n */\nexport type StreamEventData = {\n    /**\n     * The input passed to the runnable that generated the event.\n     * Inputs will sometimes be available at the *START* of the runnable, and\n     * sometimes at the *END* of the runnable.\n     * If a runnable is able to stream its inputs, then its input by definition\n     * won't be known until the *END* of the runnable when it has finished streaming\n     * its inputs.\n     */\n    input?: any;\n    /**\n     * The output of the runnable that generated the event.\n     * Outputs will only be available at the *END* of the runnable.\n     * For most runnables, this field can be inferred from the `chunk` field,\n     * though there might be some exceptions for special cased runnables (e.g., like\n     * chat models), which may return more information.\n     */\n    output?: any;\n    /**\n     * A streaming chunk from the output that generated the event.\n     * chunks support addition in general, and adding them up should result\n     * in the output of the runnable that generated the event.\n     */\n    chunk?: any;\n};\n/**\n * A streaming event.\n *\n * Schema of a streaming event which is produced from the streamEvents method.\n */\nexport type StreamEvent = {\n    /**\n     * Event names are of the format: on_[runnable_type]_(start|stream|end).\n     *\n     * Runnable types are one of:\n     * - llm - used by non chat models\n     * - chat_model - used by chat models\n     * - prompt --  e.g., ChatPromptTemplate\n     * - tool -- LangChain tools\n     * - chain - most Runnables are of this type\n     *\n     * Further, the events are categorized as one of:\n     * - start - when the runnable starts\n     * - stream - when the runnable is streaming\n     * - end - when the runnable ends\n     *\n     * start, stream and end are associated with slightly different `data` payload.\n     *\n     * Please see the documentation for `EventData` for more details.\n     */\n    event: string;\n    /** The name of the runnable that generated the event. */\n    name: string;\n    /**\n     * An randomly generated ID to keep track of the execution of the given runnable.\n     *\n     * Each child runnable that gets invoked as part of the execution of a parent runnable\n     * is assigned its own unique ID.\n     */\n    run_id: string;\n    /**\n     * Tags associated with the runnable that generated this event.\n     * Tags are always inherited from parent runnables.\n     */\n    tags?: string[];\n    /** Metadata associated with the runnable that generated this event. */\n    metadata: Record<string, any>;\n    /**\n     * Event data.\n     *\n     * The contents of the event data depend on the event type.\n     */\n    data: StreamEventData;\n};\ntype RunInfo = {\n    name: string;\n    tags: string[];\n    metadata: Record<string, any>;\n    runType: string;\n    inputs?: Record<string, any>;\n};\nexport interface EventStreamCallbackHandlerInput extends BaseCallbackHandlerInput {\n    autoClose?: boolean;\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n}\nexport declare const isStreamEventsHandler: (handler: BaseCallbackHandler) => handler is EventStreamCallbackHandler;\n/**\n * Class that extends the `BaseTracer` class from the\n * `langchain.callbacks.tracers.base` module. It represents a callback\n * handler that logs the execution of runs and emits `RunLog` instances to a\n * `RunLogStream`.\n */\nexport declare class EventStreamCallbackHandler extends BaseTracer implements CallbackHandlerPrefersStreaming {\n    protected autoClose: boolean;\n    protected includeNames?: string[];\n    protected includeTypes?: string[];\n    protected includeTags?: string[];\n    protected excludeNames?: string[];\n    protected excludeTypes?: string[];\n    protected excludeTags?: string[];\n    private runInfoMap;\n    private tappedPromises;\n    protected transformStream: TransformStream;\n    writer: WritableStreamDefaultWriter;\n    receiveStream: IterableReadableStream<StreamEvent>;\n    name: string;\n    lc_prefer_streaming: boolean;\n    constructor(fields?: EventStreamCallbackHandlerInput);\n    [Symbol.asyncIterator](): IterableReadableStream<StreamEvent>;\n    protected persistRun(_run: Run): Promise<void>;\n    _includeRun(run: RunInfo): boolean;\n    tapOutputIterable<T>(runId: string, outputStream: AsyncGenerator<T>): AsyncGenerator<T>;\n    send(payload: StreamEvent, run: RunInfo): Promise<void>;\n    sendEndEvent(payload: StreamEvent, run: RunInfo): Promise<void>;\n    onLLMStart(run: Run): Promise<void>;\n    onLLMNewToken(run: Run, token: string, kwargs?: {\n        chunk: any;\n    }): Promise<void>;\n    onLLMEnd(run: Run): Promise<void>;\n    onChainStart(run: Run): Promise<void>;\n    onChainEnd(run: Run): Promise<void>;\n    onToolStart(run: Run): Promise<void>;\n    onToolEnd(run: Run): Promise<void>;\n    onRetrieverStart(run: Run): Promise<void>;\n    onRetrieverEnd(run: Run): Promise<void>;\n    handleCustomEvent(eventName: string, data: any, runId: string): Promise<void>;\n    finish(): Promise<void>;\n}\nexport {};\n//# sourceMappingURL=event_stream.d.ts.map"],"mappings":";;;;AAMA;AA8BA;AAmDA;KAjFYM,eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BAC,WAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoCEC;;;;;;QAMJF;;UASOI,+BAAAA,SAAwCP"}