@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["AIMessage","AIMessageChunk","BaseMessageLike","BaseMessage","StoredMessage","ChatMessage","ChatMessageChunk","FunctionMessage","FunctionMessageChunk","HumanMessage","HumanMessageChunk","SystemMessage","SystemMessageChunk","InvalidToolCall","ToolCall","ToolCallChunk","ToolMessage","$Expand","T","U","K","$KnownKeys","$HasIndexSignature","$OnlyIndexSignatures","$MergeObjects","Record","$MergeDiscriminatedUnion","A","B","Key","PropertyKey","Extract","Constructor","iife","coerceMessageLikeToMessage","getBufferString","mapStoredMessageToChatMessage","__message_js0","MessageStructure","mapStoredMessagesToChatMessages","mapChatMessagesToStoredMessages","convertToChunk","collapseToolCallChunks"],"sources":["../../src/messages/utils.d.ts"],"sourcesContent":["import { AIMessage, AIMessageChunk } from \"./ai.js\";\nimport { BaseMessageLike, BaseMessage, StoredMessage } from \"./base.js\";\nimport { ChatMessage, ChatMessageChunk } from \"./chat.js\";\nimport { FunctionMessage, FunctionMessageChunk } from \"./function.js\";\nimport { HumanMessage, HumanMessageChunk } from \"./human.js\";\nimport { SystemMessage, SystemMessageChunk } from \"./system.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk, ToolMessage } from \"./tool.js\";\nexport type $Expand<T> = T extends infer U ? {\n    [K in keyof U]: U[K];\n} : never;\n/**\n * Extracts the explicitly declared keys from a type T.\n *\n * @template T - The type to extract keys from\n * @returns A union of keys that are not string, number, or symbol\n */\ntype $KnownKeys<T> = {\n    [K in keyof T]: string extends K ? never : number extends K ? never : symbol extends K ? never : K;\n}[keyof T];\n/**\n * Detects if T has an index signature.\n *\n * @template T - The type to check for index signatures\n * @returns True if T has an index signature, false otherwise\n */\ntype $HasIndexSignature<T> = string extends keyof T ? true : number extends keyof T ? true : symbol extends keyof T ? true : false;\n/**\n * Detects if T has an index signature and no known keys.\n *\n * @template T - The type to check for index signatures and no known keys\n * @returns True if T has an index signature and no known keys, false otherwise\n */\ntype $OnlyIndexSignatures<T> = $HasIndexSignature<T> extends true ? [$KnownKeys<T>] extends [never] ? true : false : false;\n/**\n * Recursively merges two object types T and U, with U taking precedence over T.\n *\n * This utility type performs a deep merge of two object types:\n * - For keys that exist in both T and U:\n *   - If both values are objects (Record<string, unknown>), recursively merge them\n *   - Otherwise, U's value takes precedence\n * - For keys that exist only in T, use T's value\n * - For keys that exist only in U, use U's value\n *\n * @template T - The first object type to merge\n * @template U - The second object type to merge (takes precedence over T)\n *\n * @example\n * ```ts\n * type ObjectA = {\n *   shared: { a: string; b: number };\n *   onlyInA: boolean;\n * };\n *\n * type ObjectB = {\n *   shared: { b: string; c: Date };\n *   onlyInB: symbol;\n * };\n *\n * type Merged = $MergeObjects<ObjectA, ObjectB>;\n * // Result: {\n * //   shared: { a: string; b: string; c: Date };\n * //   onlyInA: boolean;\n * //   onlyInB: symbol;\n * // }\n * ```\n */\nexport type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : {\n    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never;\n};\n/**\n * Merges two discriminated unions A and B based on a discriminator key (defaults to \"type\").\n * For each possible value of the discriminator across both unions:\n * - If B has a member with that discriminator value, use B's member\n * - Otherwise use A's member with that discriminator value\n * This effectively merges the unions while giving B's members precedence over A's members.\n *\n * @template A - First discriminated union type that extends Record<Key, PropertyKey>\n * @template B - Second discriminated union type that extends Record<Key, PropertyKey>\n * @template Key - The discriminator key property, defaults to \"type\"\n */\nexport type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = \"type\"> = {\n    [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [\n        Extract<A, Record<Key, T>>\n    ] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>;\n}[A[Key] | B[Key]];\nexport type Constructor<T> = new (...args: unknown[]) => T;\n/**\n * Immediately-invoked function expression.\n *\n * @param fn - The function to execute\n * @returns The result of the function\n */\nexport declare const iife: <T>(fn: () => T) => T;\nexport declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;\n/**\n * This function is used by memory classes to get a string representation\n * of the chat message history, based on the message content and role.\n */\nexport declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;\nexport declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<import(\"./message.js\").MessageStructure> | ChatMessage<import(\"./message.js\").MessageStructure> | FunctionMessage<import(\"./message.js\").MessageStructure> | HumanMessage<import(\"./message.js\").MessageStructure> | SystemMessage<import(\"./message.js\").MessageStructure> | ToolMessage<import(\"./message.js\").MessageStructure>;\n/**\n * Transforms an array of `StoredMessage` instances into an array of\n * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`\n * function to ensure all messages are in the `StoredMessage` format, then\n * creates new instances of the appropriate `BaseMessage` subclass based\n * on the type of each message. This function is used to prepare stored\n * messages for use in a chat context.\n */\nexport declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];\n/**\n * Transforms an array of `BaseMessage` instances into an array of\n * `StoredMessage` instances. It does this by calling the `toDict` method\n * on each `BaseMessage`, which returns a `StoredMessage`. This function\n * is used to prepare chat messages for storage.\n */\nexport declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];\nexport declare function convertToChunk(message: BaseMessage): AIMessageChunk<import(\"./message.js\").MessageStructure> | ChatMessageChunk<import(\"./message.js\").MessageStructure> | FunctionMessageChunk<import(\"./message.js\").MessageStructure> | HumanMessageChunk<import(\"./message.js\").MessageStructure> | SystemMessageChunk<import(\"./message.js\").MessageStructure>;\n/**\n * Collapses an array of tool call chunks into complete tool calls.\n *\n * This function groups tool call chunks by their id and/or index, then attempts to\n * parse and validate the accumulated arguments for each group. Successfully parsed\n * tool calls are returned as valid `ToolCall` objects, while malformed ones are\n * returned as `InvalidToolCall` objects.\n *\n * @param chunks - An array of `ToolCallChunk` objects to collapse\n * @returns An object containing:\n *   - `tool_call_chunks`: The original input chunks\n *   - `tool_calls`: An array of successfully parsed and validated tool calls\n *   - `invalid_tool_calls`: An array of tool calls that failed parsing or validation\n *\n * @remarks\n * Chunks are grouped using the following matching logic:\n * - If a chunk has both an id and index, it matches chunks with the same id and index\n * - If a chunk has only an id, it matches chunks with the same id\n * - If a chunk has only an index, it matches chunks with the same index\n *\n * For each group, the function:\n * 1. Concatenates all `args` strings from the chunks\n * 2. Attempts to parse the concatenated string as JSON\n * 3. Validates that the result is a non-null object with a valid id\n * 4. Creates either a `ToolCall` (if valid) or `InvalidToolCall` (if invalid)\n */\nexport declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {\n    tool_call_chunks: ToolCallChunk[];\n    tool_calls: ToolCall[];\n    invalid_tool_calls: InvalidToolCall[];\n};\nexport {};\n//# sourceMappingURL=utils.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Runnable","RunnableConfig","BasePromptValueInterface","BaseMessage","ContentBlock","Callbacks","Generation","ChatGeneration","FormatInstructionsOptions","BaseLLMOutputParser","T","Promise","BaseOutputParser","OutputParserException","Error"],"sources":["../../src/output_parsers/base.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/index.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport type { BaseMessage, ContentBlock } from \"../messages/index.js\";\nimport type { Callbacks } from \"../callbacks/manager.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\n/**\n * Options for formatting instructions.\n */\nexport interface FormatInstructionsOptions {\n}\n/**\n * Abstract base class for parsing the output of a Large Language Model\n * (LLM) call. It provides methods for parsing the result of an LLM call\n * and invoking the parser with a given input.\n */\nexport declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {\n    /**\n     * Parses the result of an LLM call. This method is meant to be\n     * implemented by subclasses to define how the output from the LLM should\n     * be parsed.\n     * @param generations The generations from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parses the result of an LLM call with a given prompt. By default, it\n     * simply calls `parseResult`.\n     * @param generations The generations from an LLM call.\n     * @param _prompt The prompt used in the LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    protected _baseMessageToString(message: BaseMessage): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n    /**\n     * Calls the parser with a given input and optional configuration options.\n     * If the input is a string, it creates a generation with the input as\n     * text and calls `parseResult`. If the input is a `BaseMessage`, it\n     * creates a generation with the input as a message and the content of the\n     * input as text, and then calls `parseResult`.\n     * @param input The input to the parser, which can be a string or a `BaseMessage`.\n     * @param options Optional configuration options.\n     * @returns A promise of the parsed output.\n     */\n    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;\n}\n/**\n * Class to parse the output of an LLM call.\n */\nexport declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {\n    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parse the output of an LLM call.\n     *\n     * @param text - LLM output to parse.\n     * @returns Parsed output.\n     */\n    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;\n    parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Return a string describing the format of the output.\n     * @returns Format instructions.\n     * @param options - Options for formatting instructions.\n     * @example\n     * ```json\n     * {\n     *  \"foo\": \"bar\"\n     * }\n     * ```\n     */\n    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;\n    /**\n     * Return the string type key uniquely identifying this class of parser\n     */\n    _type(): string;\n}\n/**\n * Exception that output parsers should raise to signify a parsing error.\n *\n * This exists to differentiate parsing errors from other code or execution errors\n * that also may arise inside the output parser. OutputParserExceptions will be\n * available to catch and handle in ways to fix the parsing error, while other\n * errors will be raised.\n *\n * @param message - The error that's being re-raised or an error message.\n * @param llmOutput - String model output which is error-ing.\n * @param observation - String explanation of error which can be passed to a\n *     model to try and remediate the issue.\n * @param sendToLLM - Whether to send the observation and llm_output back to an Agent\n *     after an OutputParserException has been raised. This gives the underlying\n *     model driving the agent the context that the previous output was improperly\n *     structured, in the hopes that it will update the output to the correct\n *     format.\n */\nexport declare class OutputParserException extends Error {\n    llmOutput?: string;\n    observation?: string;\n    sendToLLM: boolean;\n    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;;;;;;AASiBQ,UAAAA,yBAAAA,CAAyB,CAO1C;;;;;;AASuGE,uBATzED,mBASyEC,CAAAA,IAAAA,OAAAA,CAAAA,SAThCV,QASgCU,CAAAA,MAAAA,GATdP,WAScO,EATDA,CASCA,CAAAA,CAAAA;EAARC;;;;;;;;EAW5CP,SAAAA,WAAAA,CAAAA,WAAAA,EAXbE,UAWaF,EAAAA,GAXEG,cAWFH,EAAAA,EAAAA,SAAAA,CAAAA,EAXgCC,SAWhCD,CAAAA,EAX4CO,OAW5CP,CAXoDM,CAWpDN,CAAAA;EAWxBD;;;;;AA/BoD;AAoC/E;;EAC6BG,qBAAAA,CAAAA,WAAAA,EAnBUA,UAmBVA,EAAAA,GAnByBC,cAmBzBD,EAAAA,EAAAA,OAAAA,EAnBoDJ,wBAmBpDI,EAAAA,SAAAA,CAAAA,EAnB0FD,SAmB1FC,CAAAA,EAnBsGK,OAmBtGL,CAnB8GI,CAmB9GJ,CAAAA;EAAeC,UAAAA,oBAAAA,CAAAA,OAAAA,EAlBAJ,WAkBAI,CAAAA,EAAAA,MAAAA;EAA8BF,UAAAA,2BAAAA,CAAAA,OAAAA,EAjBvBD,YAiBuBC,EAAAA,CAAAA,EAAAA,MAAAA;EAAoBK;;;;;;;;;;EAD1BD,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GALzCN,WAKyCM,EAAAA,OAAAA,CAAAA,EALlBR,cAKkBQ,CAAAA,EALDE,OAKCF,CALOC,CAKPD,CAAAA;AAAmB;AA6CvF;;;uBA7C8BG,sCAAsCH,oBAAoBC;2BAC3DJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Runnable","RunnableConfig","BasePromptValueInterface","BaseMessage","ContentBlock","Callbacks","Generation","ChatGeneration","FormatInstructionsOptions","BaseLLMOutputParser","T","Promise","BaseOutputParser","OutputParserException","Error"],"sources":["../../src/output_parsers/base.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/index.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport type { BaseMessage, ContentBlock } from \"../messages/index.js\";\nimport type { Callbacks } from \"../callbacks/manager.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\n/**\n * Options for formatting instructions.\n */\nexport interface FormatInstructionsOptions {\n}\n/**\n * Abstract base class for parsing the output of a Large Language Model\n * (LLM) call. It provides methods for parsing the result of an LLM call\n * and invoking the parser with a given input.\n */\nexport declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {\n    /**\n     * Parses the result of an LLM call. This method is meant to be\n     * implemented by subclasses to define how the output from the LLM should\n     * be parsed.\n     * @param generations The generations from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parses the result of an LLM call with a given prompt. By default, it\n     * simply calls `parseResult`.\n     * @param generations The generations from an LLM call.\n     * @param _prompt The prompt used in the LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    protected _baseMessageToString(message: BaseMessage): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n    /**\n     * Calls the parser with a given input and optional configuration options.\n     * If the input is a string, it creates a generation with the input as\n     * text and calls `parseResult`. If the input is a `BaseMessage`, it\n     * creates a generation with the input as a message and the content of the\n     * input as text, and then calls `parseResult`.\n     * @param input The input to the parser, which can be a string or a `BaseMessage`.\n     * @param options Optional configuration options.\n     * @returns A promise of the parsed output.\n     */\n    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;\n}\n/**\n * Class to parse the output of an LLM call.\n */\nexport declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {\n    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parse the output of an LLM call.\n     *\n     * @param text - LLM output to parse.\n     * @returns Parsed output.\n     */\n    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;\n    parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Return a string describing the format of the output.\n     * @returns Format instructions.\n     * @param options - Options for formatting instructions.\n     * @example\n     * ```json\n     * {\n     *  \"foo\": \"bar\"\n     * }\n     * ```\n     */\n    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;\n    /**\n     * Return the string type key uniquely identifying this class of parser\n     */\n    _type(): string;\n}\n/**\n * Exception that output parsers should raise to signify a parsing error.\n *\n * This exists to differentiate parsing errors from other code or execution errors\n * that also may arise inside the output parser. OutputParserExceptions will be\n * available to catch and handle in ways to fix the parsing error, while other\n * errors will be raised.\n *\n * @param message - The error that's being re-raised or an error message.\n * @param llmOutput - String model output which is error-ing.\n * @param observation - String explanation of error which can be passed to a\n *     model to try and remediate the issue.\n * @param sendToLLM - Whether to send the observation and llm_output back to an Agent\n *     after an OutputParserException has been raised. This gives the underlying\n *     model driving the agent the context that the previous output was improperly\n *     structured, in the hopes that it will update the output to the correct\n *     format.\n */\nexport declare class OutputParserException extends Error {\n    llmOutput?: string;\n    observation?: string;\n    sendToLLM: boolean;\n    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;;;;;;;;;UASiBQ,yBAAAA;;AAAjB;AAOA;;;AASsCF,uBATRG,mBASQH,CAAAA,IAAAA,OAAAA,CAAAA,SATiCN,QASjCM,CAAAA,MAAAA,GATmDH,WASnDG,EATgEI,CAShEJ,CAAAA,CAAAA;EAAeC;;;;;;;;EASsFG,SAAAA,WAAAA,CAAAA,WAAAA,EATrGJ,UASqGI,EAAAA,GATtFH,cASsFG,EAAAA,EAAAA,SAAAA,CAAAA,EATxDL,SASwDK,CAAAA,EAT5CC,OAS4CD,CATpCA,CASoCA,CAAAA;EAARC;;;;;;;;EAlBpD,qBAAA,CAAA,WAAA,EAkBxCL,UAlBwC,EAAA,GAkBzBC,cAlByB,EAAA,EAAA,OAAA,EAkBEL,wBAlBF,EAAA,SAAA,CAAA,EAkBwCG,SAlBxC,CAAA,EAkBoDM,OAlBpD,CAkB4DD,CAlB5D,CAAA;EAoCjDE,UAAAA,oBAAgBF,CAAAA,OAAA,EAjBFP,WAiBE,CAAA,EAAA,MAAA;EAA0CO,UAAAA,2BAAAA,CAAAA,OAAAA,EAhBrCN,YAgBqCM,EAAAA,CAAAA,EAAAA,MAAAA;EAC3DJ;;;;;;;;;;EAQwEI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GAd1EP,WAc0EO,EAAAA,OAAAA,CAAAA,EAdnDT,cAcmDS,CAAAA,EAdlCC,OAckCD,CAd1BA,CAc0BA,CAAAA;;;;AATd;AA6ClEG,uBA7CSD,gBA6C0B,CAAA,IAAA,OAAA,CAAA,SA7CYH,mBA6CZ,CA7CgCC,CA6ChC,CAAA,CAAA;2BA5C3BJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}

package/dist/output_parsers/bytes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.cts","names":["BaseTransformOutputParser","BytesOutputParser","Uint8Array","TextEncoder","InstanceType","Promise"],"sources":["../../src/output_parsers/bytes.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected textEncoder: InstanceType<typeof TextEncoder>;\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=bytes.d.ts.map"],"mappings":";;;;;;AAKA;;AAI+CG,cAJ1BF,iBAAAA,SAA0BD,yBAIAG,CAJ0BD,UAI1BC,CAAAA,CAAAA;EAApBC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACMF,YAAAA,EAAAA,MAAAA,EAAAA;EAARG,eAAAA,EAAAA,OAAAA;EALsBL,UAAAA,WAAAA,EAIpBI,YAJoBJ,CAAAA,OAIAG,WAJAH,CAAAA;EAAyB,KAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAK/CK,OAL+C,CAKvCH,UALuC,CAAA"}

package/dist/output_parsers/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","names":["BaseTransformOutputParser","BytesOutputParser","Uint8Array","TextEncoder","InstanceType","Promise"],"sources":["../../src/output_parsers/bytes.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected textEncoder: InstanceType<typeof TextEncoder>;\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=bytes.d.ts.map"],"mappings":";;;;;;AAKA;;AAI+CG,cAJ1BF,iBAAAA,SAA0BD,yBAIAG,CAJ0BD,UAI1BC,CAAAA,CAAAA;EAApBC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACMF,YAAAA,EAAAA,MAAAA,EAAAA;EAARG,eAAAA,EAAAA,OAAAA;EALsBL,UAAAA,WAAAA,EAIpBI,YAJoBJ,CAAAA,OAIAG,WAJAH,CAAAA;EAAyB,KAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAK/CK,OAL+C,CAKvCH,UALuC,CAAA"}

package/dist/output_parsers/json.d.cts

@@ -8,17 +8,13 @@ import { parseJsonMarkdown, parsePartialJson } from "../utils/json.cjs";
 /**
  * Class for parsing the output of an LLM into a JSON object.
  */
-declare class JsonOutputParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {
+declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
   /** @internal */
   _concatOutputChunks<T>(first: T, second: T): T;
   protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;
-  // This should actually return Partial<T>, but there's no way
-  // to specify emitted chunks as instances separate from the main output type.
   parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;
   parse(text: string): Promise<T>;
   getFormatInstructions(): string;

package/dist/output_parsers/json.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.cts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAAgDQ,cAA3BF,gBAA2BE,CAAAA,UAAAA,MAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAAsBA,MAAtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SAAmDR,mCAAnDQ,CAAuFD,CAAvFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiED,YAAAA,EAAAA,MAAAA,EAAAA;EAKrGA,eAAAA,EAAAA,OAAAA;EAAWA;EAAIA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAfA,CAAeA,EAAAA,MAAAA,EAAJA,CAAIA,CAAAA,EAAAA,CAAAA;EACcN,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,SAAAA,EAAAA,GAAAA,SAAAA;EAC3BC,kBAAAA,CAAAA,WAAAA,EAAAA,cAAAA,EAAAA,GAAmBC,UAAnBD,EAAAA,CAAAA,EAAkCO,OAAlCP,CAA0CK,CAA1CL,GAAAA,SAAAA,CAAAA;EAAmBC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAC9BM,OAD8BN,CACtBI,CADsBJ,CAAAA;EAAuBI,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA"}

package/dist/output_parsers/json.d.ts

@@ -8,17 +8,13 @@ import { parseJsonMarkdown, parsePartialJson } from "../utils/json.js";
 /**
  * Class for parsing the output of an LLM into a JSON object.
  */
-declare class JsonOutputParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {
+declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
   /** @internal */
   _concatOutputChunks<T>(first: T, second: T): T;
   protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;
-  // This should actually return Partial<T>, but there's no way
-  // to specify emitted chunks as instances separate from the main output type.
   parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;
   parse(text: string): Promise<T>;
   getFormatInstructions(): string;

package/dist/output_parsers/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAAgDQ,cAA3BF,gBAA2BE,CAAAA,UAAAA,MAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAAsBA,MAAtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SAAmDR,mCAAnDQ,CAAuFD,CAAvFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiED,YAAAA,EAAAA,MAAAA,EAAAA;EAKrGA,eAAAA,EAAAA,OAAAA;EAAWA;EAAIA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAfA,CAAeA,EAAAA,MAAAA,EAAJA,CAAIA,CAAAA,EAAAA,CAAAA;EACcN,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,SAAAA,EAAAA,GAAAA,SAAAA;EAC3BC,kBAAAA,CAAAA,WAAAA,EAAAA,cAAAA,EAAAA,GAAmBC,UAAnBD,EAAAA,CAAAA,EAAkCO,OAAlCP,CAA0CK,CAA1CL,GAAAA,SAAAA,CAAAA;EAAmBC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAC9BM,OAD8BN,CACtBI,CADsBJ,CAAAA;EAAuBI,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA"}

package/dist/output_parsers/list.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.cts","names":["BaseMessage","BaseTransformOutputParser","ListOutputParser","RegExp","AsyncGenerator","CommaSeparatedListOutputParser","Promise","CustomListOutputParser","length","separator","NumberedListOutputParser","MarkdownListOutputParser"],"sources":["../../src/output_parsers/list.d.ts"],"sourcesContent":["import { BaseMessage } from \"../messages/index.js\";\nimport { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * Class to parse the output of an LLM call to a list.\n * @augments BaseOutputParser\n */\nexport declare abstract class ListOutputParser extends BaseTransformOutputParser<string[]> {\n    re?: RegExp;\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<string[]>;\n}\n/**\n * Class to parse the output of an LLM call as a comma-separated list.\n * @augments ListOutputParser\n */\nexport declare class CommaSeparatedListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * Parses the given text into an array of strings, using a comma as the\n     * separator. If the parsing fails, throws an OutputParserException.\n     * @param text The text to parse.\n     * @returns An array of strings obtained by splitting the input text at each comma.\n     */\n    parse(text: string): Promise<string[]>;\n    /**\n     * Provides instructions on the expected format of the response for the\n     * CommaSeparatedListOutputParser.\n     * @returns A string containing instructions on the expected format of the response.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * Class to parse the output of an LLM call to a list with a specific length and separator.\n * @augments ListOutputParser\n */\nexport declare class CustomListOutputParser extends ListOutputParser {\n    lc_namespace: string[];\n    private length;\n    private separator;\n    constructor({ length, separator }: {\n        length?: number;\n        separator?: string;\n    });\n    /**\n     * Parses the given text into an array of strings, using the specified\n     * separator. If the parsing fails or the number of items in the list\n     * doesn't match the expected length, throws an OutputParserException.\n     * @param text The text to parse.\n     * @returns An array of strings obtained by splitting the input text at each occurrence of the specified separator.\n     */\n    parse(text: string): Promise<string[]>;\n    /**\n     * Provides instructions on the expected format of the response for the\n     * CustomListOutputParser, including the number of items and the\n     * separator.\n     * @returns A string containing instructions on the expected format of the response.\n     */\n    getFormatInstructions(): string;\n}\nexport declare class NumberedListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    getFormatInstructions(): string;\n    re: RegExp;\n    parse(text: string): Promise<string[]>;\n}\nexport declare class MarkdownListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    getFormatInstructions(): string;\n    re: RegExp;\n    parse(text: string): Promise<string[]>;\n}\n//# sourceMappingURL=list.d.ts.map"],"mappings":";;;;;;;AAMA;;AAEuDA,uBAFzBE,gBAAAA,SAAyBD,yBAEAD,CAAAA,MAAAA,EAAAA,CAAAA,CAAAA;EAAxBI,EAAAA,CAAAA,EADtBD,MACsBC;EAAuCA,UAAAA,CAAAA,cAAAA,EAAvCA,cAAuCA,CAAAA,MAAAA,GAAfJ,WAAeI,CAAAA,CAAAA,EAAAA,cAAAA,CAAAA,MAAAA,EAAAA,CAAAA;;AAFU;AAQhF;AAsBA;;AAI0BK,cA1BLJ,8BAAAA,SAAuCH,gBAAgB,CA0BlDO;EAWDH,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAf2BJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAgB,eAAA,EAAA,OAAA;EAwB/CQ;;;;AAAiD;AAQtE;EAKQP,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAjDiBG,OAiDjBH,CAAAA,MAAAA,EAAAA,CAAAA;EACiBG;;AAN6C;;;;;;;;;cAhCjDC,sBAAAA,SAA+BL,gBAAAA;;;;;;;;;;;;;;;;;;uBAe3BI;;;;;;;;;cASJI,wBAAAA,SAAiCR,gBAAAA;;;;;MAK9CC;uBACiBG;;cAEJK,wBAAAA,SAAiCT,gBAAAA;;;;;MAK9CC;uBACiBG"}

package/dist/output_parsers/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","names":["BaseMessage","BaseTransformOutputParser","ListOutputParser","RegExp","AsyncGenerator","CommaSeparatedListOutputParser","Promise","CustomListOutputParser","length","separator","NumberedListOutputParser","MarkdownListOutputParser"],"sources":["../../src/output_parsers/list.d.ts"],"sourcesContent":["import { BaseMessage } from \"../messages/index.js\";\nimport { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * Class to parse the output of an LLM call to a list.\n * @augments BaseOutputParser\n */\nexport declare abstract class ListOutputParser extends BaseTransformOutputParser<string[]> {\n    re?: RegExp;\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<string[]>;\n}\n/**\n * Class to parse the output of an LLM call as a comma-separated list.\n * @augments ListOutputParser\n */\nexport declare class CommaSeparatedListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * Parses the given text into an array of strings, using a comma as the\n     * separator. If the parsing fails, throws an OutputParserException.\n     * @param text The text to parse.\n     * @returns An array of strings obtained by splitting the input text at each comma.\n     */\n    parse(text: string): Promise<string[]>;\n    /**\n     * Provides instructions on the expected format of the response for the\n     * CommaSeparatedListOutputParser.\n     * @returns A string containing instructions on the expected format of the response.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * Class to parse the output of an LLM call to a list with a specific length and separator.\n * @augments ListOutputParser\n */\nexport declare class CustomListOutputParser extends ListOutputParser {\n    lc_namespace: string[];\n    private length;\n    private separator;\n    constructor({ length, separator }: {\n        length?: number;\n        separator?: string;\n    });\n    /**\n     * Parses the given text into an array of strings, using the specified\n     * separator. If the parsing fails or the number of items in the list\n     * doesn't match the expected length, throws an OutputParserException.\n     * @param text The text to parse.\n     * @returns An array of strings obtained by splitting the input text at each occurrence of the specified separator.\n     */\n    parse(text: string): Promise<string[]>;\n    /**\n     * Provides instructions on the expected format of the response for the\n     * CustomListOutputParser, including the number of items and the\n     * separator.\n     * @returns A string containing instructions on the expected format of the response.\n     */\n    getFormatInstructions(): string;\n}\nexport declare class NumberedListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    getFormatInstructions(): string;\n    re: RegExp;\n    parse(text: string): Promise<string[]>;\n}\nexport declare class MarkdownListOutputParser extends ListOutputParser {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    getFormatInstructions(): string;\n    re: RegExp;\n    parse(text: string): Promise<string[]>;\n}\n//# sourceMappingURL=list.d.ts.map"],"mappings":";;;;;;;;;AAMA;AACSG,uBADqBD,gBAAAA,SAAyBD,yBAC9CE,CAAAA,MAAAA,EAAAA,CAAAA,CAAAA;EAC8CH,EAAAA,CAAAA,EAD9CG,MAC8CH;EAAxBI,UAAAA,CAAAA,cAAAA,EAAAA,cAAAA,CAAAA,MAAAA,GAAwBJ,WAAxBI,CAAAA,CAAAA,EAAuCA,cAAvCA,CAAAA,MAAAA,EAAAA,CAAAA;;;AAFiD;AAQhF;AAsBA;AAIkBI,cA1BGH,8BAAAA,SAAuCH,gBAAgB,CA0B1DM;EAAQC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAWDH,YAAAA,EAAAA,MAAAA,EAAAA;EAf2BJ,eAAAA,EAAAA,OAAAA;EAAgB;AAwBpE;;;;AAAsE;EAQjDS,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA5CIL,OA4CoB,CAAA,MAAA,EAAA,CAAA;EAKrCH;;;AAL8D;;;;;;;;cAhCjDI,sBAAAA,SAA+BL,gBAAAA;;;;;;;;;;;;;;;;;;uBAe3BI;;;;;;;;;cASJI,wBAAAA,SAAiCR,gBAAAA;;;;;MAK9CC;uBACiBG;;cAEJK,wBAAAA,SAAiCT,gBAAAA;;;;;MAK9CC;uBACiBG"}

package/dist/output_parsers/openai_functions/json_output_functions_parsers.d.cts

@@ -35,9 +35,7 @@ declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {
  * Class for parsing the output of an LLM into a JSON object. Uses an
  * instance of `OutputFunctionsParser` to parse the output.
  */
-declare class JsonOutputFunctionsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {
+declare class JsonOutputFunctionsParser<Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -63,9 +61,7 @@ Output extends Record<string, any> = Record<string, any>> extends BaseCumulative
  * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`
  * to parse the output.
  */
-declare class JsonKeyOutputFunctionsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+declare class JsonKeyOutputFunctionsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;

package/dist/output_parsers/openai_functions/json_output_functions_parsers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_output_functions_parsers.d.cts","names":["Optional","Generation","ChatGeneration","BaseLLMOutputParser","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","JsonSchema7ObjectType","Operation","JSONPatchOperation","FunctionParameters","OutputFunctionsParser","Promise","JsonOutputFunctionsParser","Output","Record","JsonKeyOutputFunctionsParser","T"],"sources":["../../../src/output_parsers/openai_functions/json_output_functions_parsers.d.ts"],"sourcesContent":["import { Optional } from \"../../types/type-utils.js\";\nimport { Generation, ChatGeneration } from \"../../outputs.js\";\nimport { BaseLLMOutputParser } from \"../base.js\";\nimport { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"../transform.js\";\nimport { JsonSchema7ObjectType } from \"../../utils/json_schema.js\";\nimport { type Operation as JSONPatchOperation } from \"../../utils/json_patch.js\";\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<JsonSchema7ObjectType, \"additionalProperties\">;\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    });\n    /**\n     * Parses the output and returns a string representation of the function\n     * call or its arguments.\n     * @param generations The output of the LLM to parse.\n     * @returns A string representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<string>;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport declare class JsonOutputFunctionsParser<Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: OutputFunctionsParser;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    } & BaseCumulativeTransformOutputParserInput);\n    protected _diff(prev: unknown | undefined, next: unknown): JSONPatchOperation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[]): Promise<Output | undefined>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<Output>;\n    parse(text: string): Promise<Output>;\n    getFormatInstructions(): string;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport declare class JsonKeyOutputFunctionsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: JsonOutputFunctionsParser<Record<string, any>>;\n    attrName: string;\n    get lc_aliases(): {\n        attrName: string;\n    };\n    constructor(fields: {\n        attrName: string;\n    });\n    /**\n     * Parses the output and returns a specific attribute of the parsed JSON\n     * object.\n     * @param generations The output of the LLM to parse.\n     * @returns The value of a specific attribute of the parsed JSON object.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<T>;\n}\n//# sourceMappingURL=json_output_functions_parsers.d.ts.map"],"mappings":";;;;;;;;;;;AASA;AAKqBU,KALTD,kBAAAA,GAAqBT,QAKS,CALAM,qBAKA,EAAA,sBAAA,CAAA;;;;;AAA4B,cAAjDI,qBAAAA,SAA8BP,mBAAmB,CAAA,MAAA,CAAA,CAAA;EAoBjDS,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAyCE,YAAAA,EAAAA,MAAAA,EAAAA;EAAsBA,eAAAA,EAAAA,OAAAA;EAAiED,QAAAA,EAAAA,OAAAA;EAInIH,WAAAA,CAAAA,MAK6CF,CAL7CE,EAAAA;IAIVL,QAAAA,CAAAA,EAAAA,OAAAA;EACuDG,CAAAA;EAC3BN;;;;;;EAO2BS,WAAAA,CAAAA,WAAAA,EAvBlCV,UAuBkCU,EAAAA,GAvBnBT,cAuBmBS,EAAAA,CAAAA,EAvBAA,OAuBAA,CAAAA,MAAAA,CAAAA;;;;AAjBqF;AA0BpJ;AAA4DG,cA1BvCF,yBA0BuCE,CAAAA,eA1BEA,MA0BFA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GA1BwBA,MA0BxBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SA1BqDV,mCA0BrDU,CA1ByFD,MA0BzFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiDE,YAAAA,EAAAA,MAAAA,EAAAA;EAIvFF,eAAAA,EAAAA,OAAAA;EAA1BF,YAAAA,EA1BAF,qBA0BAE;EAcWX,QAAAA,EAAAA,OAAAA;EAAeC,WAAAA,CAAAA,MAAmBS,CAAnBT,EAAAA;IAA2Bc,QAAAA,CAAAA,EAAAA,OAAAA;EAARL,CAAAA,GApCvDN,wCAoCuDM;EAlBgDR,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAjBhDK,SAiBgDL,EAAAA,GAAAA,SAAAA;EAAmB,kBAAA,CAAA,WAAA,EAhB9FD,cAgB8F,EAAA,CAAA,EAhB3ES,OAgB2E,CAhBnEE,MAgBmE,GAAA,SAAA,CAAA;;;;;;;2BATrGZ,eAAeC,mBAAmBS,QAAQE;uBAC9CF,QAAQE;;;;;;;;cAQZE,uCAAuCD,sBAAsBA,6BAA6BX,oBAAoBa;;;;gBAIjHJ,0BAA0BE;;;;;;;;;;;;;;2BAcfb,eAAeC,mBAAmBS,QAAQK"}

package/dist/output_parsers/openai_functions/json_output_functions_parsers.d.ts

@@ -35,9 +35,7 @@ declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {
  * Class for parsing the output of an LLM into a JSON object. Uses an
  * instance of `OutputFunctionsParser` to parse the output.
  */
-declare class JsonOutputFunctionsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {
+declare class JsonOutputFunctionsParser<Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -63,9 +61,7 @@ Output extends Record<string, any> = Record<string, any>> extends BaseCumulative
  * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`
  * to parse the output.
  */
-declare class JsonKeyOutputFunctionsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+declare class JsonKeyOutputFunctionsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;

package/dist/output_parsers/openai_functions/json_output_functions_parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_output_functions_parsers.d.ts","names":["Optional","Generation","ChatGeneration","BaseLLMOutputParser","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","JsonSchema7ObjectType","Operation","JSONPatchOperation","FunctionParameters","OutputFunctionsParser","Promise","JsonOutputFunctionsParser","Output","Record","JsonKeyOutputFunctionsParser","T"],"sources":["../../../src/output_parsers/openai_functions/json_output_functions_parsers.d.ts"],"sourcesContent":["import { Optional } from \"../../types/type-utils.js\";\nimport { Generation, ChatGeneration } from \"../../outputs.js\";\nimport { BaseLLMOutputParser } from \"../base.js\";\nimport { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"../transform.js\";\nimport { JsonSchema7ObjectType } from \"../../utils/json_schema.js\";\nimport { type Operation as JSONPatchOperation } from \"../../utils/json_patch.js\";\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<JsonSchema7ObjectType, \"additionalProperties\">;\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    });\n    /**\n     * Parses the output and returns a string representation of the function\n     * call or its arguments.\n     * @param generations The output of the LLM to parse.\n     * @returns A string representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<string>;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport declare class JsonOutputFunctionsParser<Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: OutputFunctionsParser;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    } & BaseCumulativeTransformOutputParserInput);\n    protected _diff(prev: unknown | undefined, next: unknown): JSONPatchOperation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[]): Promise<Output | undefined>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<Output>;\n    parse(text: string): Promise<Output>;\n    getFormatInstructions(): string;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport declare class JsonKeyOutputFunctionsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: JsonOutputFunctionsParser<Record<string, any>>;\n    attrName: string;\n    get lc_aliases(): {\n        attrName: string;\n    };\n    constructor(fields: {\n        attrName: string;\n    });\n    /**\n     * Parses the output and returns a specific attribute of the parsed JSON\n     * object.\n     * @param generations The output of the LLM to parse.\n     * @returns The value of a specific attribute of the parsed JSON object.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<T>;\n}\n//# sourceMappingURL=json_output_functions_parsers.d.ts.map"],"mappings":";;;;;;;;;;;;AASYS,KAAAA,kBAAAA,GAAqBT,QAASM,CAAAA,qBAATN,EAAAA,sBAAQ,CAAA;AAKzC;;;;AAAmDG,cAA9BO,qBAAAA,SAA8BP,mBAAAA,CAAAA,MAAAA,CAAAA,CAAAA;EAAmB,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAoBjDS,YAAAA,EAAAA,MAAAA,EAAAA;EAAyCE,eAAAA,EAAAA,OAAAA;EAAsBA,QAAAA,EAAAA,OAAAA;EAAiED,WAAAA,CAAAA,MAQ7IR,CAR6IQ,EAAAA;IAInIH,QAAAA,CAAAA,EAAAA,OAAAA;EAIVL,CAAAA;EACuDG;;;;;;EAQQK,WAAAA,CAAAA,WAAAA,EAvB1CZ,UAuB0CY,EAAAA,GAvB3BX,cAuB2BW,EAAAA,CAAAA,EAvBRF,OAuBQE,CAAAA,MAAAA,CAAAA;;;;;AAjB6E;AA0B/HE,cA1BAH,yBA0B4BI,CAAAA,eA1BaF,MA0Bb,CAAA,MAAA,EAAA,GAAA,CAAA,GA1BmCA,MA0BnC,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SA1BgEV,mCA0BhE,CA1BoGS,MA0BpG,CAAA,CAAA;EAAWC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsBA,YAAAA,EAAAA,MAAAA,EAAAA;EAAiDE,eAAAA,EAAAA,OAAAA;EAIvFF,YAAAA,EA1B1BJ,qBA0B0BI;EAA1BF,QAAAA,EAAAA,OAAAA;EAcWX,WAAAA,CAAAA,MAA0Ce,CAA1Cf,EAAAA;IAAeC,QAAAA,CAAAA,EAAAA,OAAAA;EAA2Bc,CAAAA,GApC/DX,wCAoC+DW;EAARL,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAnCAH,SAmCAG,EAAAA,GAAAA,SAAAA;EAlBgDR,kBAAAA,CAAAA,WAAAA,EAhB3ED,cAgB2EC,EAAAA,CAAAA,EAhBxDQ,OAgBwDR,CAhBhDU,MAgBgDV,GAAAA,SAAAA,CAAAA;EAAmB;;;;;;2BATrGF,eAAeC,mBAAmBS,QAAQE;uBAC9CF,QAAQE;;;;;;;;cAQZE,uCAAuCD,sBAAsBA,6BAA6BX,oBAAoBa;;;;gBAIjHJ,0BAA0BE;;;;;;;;;;;;;;2BAcfb,eAAeC,mBAAmBS,QAAQK"}

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.cts

@@ -9,28 +9,21 @@ import * as z4 from "zod/v4/core";
 type ParsedToolCall = {
   id?: string;
   type: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   args: Record<string, any>;
 };
 type JsonOutputToolsParserParams = {
   /** Whether to return the tool call id. */
   returnId?: boolean;
 } & BaseCumulativeTransformOutputParserInput;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options: {
   returnId?: boolean;
   partial: true;
 }): ToolCall | undefined;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options?: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options?: {
   returnId?: boolean;
   partial?: false;
 }): ToolCall;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options?: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options?: {
   returnId?: boolean;
   partial?: boolean;
 }): ToolCall | undefined;
@@ -42,9 +35,7 @@ declare function convertLangChainToolCallToOpenAI(toolCall: ToolCall): {
     arguments: string;
   };
 };
-declare function makeInvalidToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;
+declare function makeInvalidToolCall(rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
@@ -63,40 +54,27 @@ declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOutputPars
    * @param generations The output of the LLM to parse.
    * @returns A JSON object representation of the function call or its arguments.
    */
-  parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): Promise<any>;
+  parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;
 }
 type JsonOutputKeyToolsParserParamsBase = {
   keyName: string;
   returnSingle?: boolean;
 } & JsonOutputToolsParserParams;
-type JsonOutputKeyToolsParserParamsV3<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsV3<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: z3.ZodType<T>;
 } & JsonOutputKeyToolsParserParamsBase;
-type JsonOutputKeyToolsParserParamsV4<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsV4<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: z4.$ZodType<T, T>;
 } & JsonOutputKeyToolsParserParamsBase;
-type JsonOutputKeyToolsParserParamsInterop<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsInterop<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: InteropZodType<T>;
 } & JsonOutputKeyToolsParserParamsBase;
-// Use Zod 3 for backwards compatibility
-type JsonOutputKeyToolsParserParams<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;
+type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
  */
-declare class JsonOutputKeyToolsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {
+declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -110,9 +88,7 @@ T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsPars
   constructor(params: JsonOutputKeyToolsParserParamsV4<T>);
   constructor(params: JsonOutputKeyToolsParserParamsInterop<T>);
   protected _validateResult(result: unknown): Promise<T>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parsePartialResult(generations: ChatGeneration[]): Promise<any>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parseResult(generations: ChatGeneration[]): Promise<any>;
 }
 //#endregion

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_output_tools_parsers.d.cts","names":["z3","z4","ChatGeneration","ChatGenerationChunk","InvalidToolCall","ToolCall","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","InteropZodType","ParsedToolCall","Record","JsonOutputToolsParserParams","parseToolCall","convertLangChainToolCallToOpenAI","makeInvalidToolCall","JsonOutputToolsParser","T","Promise","JsonOutputKeyToolsParserParamsBase","JsonOutputKeyToolsParserParamsV3","ZodType","JsonOutputKeyToolsParserParamsV4","$ZodType","JsonOutputKeyToolsParserParamsInterop","JsonOutputKeyToolsParserParams","JsonOutputKeyToolsParser"],"sources":["../../../src/output_parsers/openai_tools/json_output_tools_parsers.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { ChatGeneration, ChatGenerationChunk } from \"../../outputs.js\";\nimport { InvalidToolCall, ToolCall } from \"../../messages/tool.js\";\nimport { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"../transform.js\";\nimport { type InteropZodType } from \"../../utils/types/zod.js\";\nexport type ParsedToolCall = {\n    id?: string;\n    type: string;\n    args: Record<string, any>;\n};\nexport type JsonOutputToolsParserParams = {\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n} & BaseCumulativeTransformOutputParserInput;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options: {\n    returnId?: boolean;\n    partial: true;\n}): ToolCall | undefined;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options?: {\n    returnId?: boolean;\n    partial?: false;\n}): ToolCall;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options?: {\n    returnId?: boolean;\n    partial?: boolean;\n}): ToolCall | undefined;\nexport declare function convertLangChainToolCallToOpenAI(toolCall: ToolCall): {\n    id: string;\n    type: string;\n    function: {\n        name: string;\n        arguments: string;\n    };\n};\nexport declare function makeInvalidToolCall(rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;\n/**\n * Class for parsing the output of a tool-calling LLM into a JSON object.\n */\nexport declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    returnId: boolean;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    constructor(fields?: JsonOutputToolsParserParams);\n    protected _diff(): void;\n    parse(): Promise<T>;\n    parseResult(generations: ChatGeneration[]): Promise<T>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;\n}\ntype JsonOutputKeyToolsParserParamsBase = {\n    keyName: string;\n    returnSingle?: boolean;\n} & JsonOutputToolsParserParams;\ntype JsonOutputKeyToolsParserParamsV3<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: z3.ZodType<T>;\n} & JsonOutputKeyToolsParserParamsBase;\ntype JsonOutputKeyToolsParserParamsV4<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: z4.$ZodType<T, T>;\n} & JsonOutputKeyToolsParserParamsBase;\nexport type JsonOutputKeyToolsParserParamsInterop<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: InteropZodType<T>;\n} & JsonOutputKeyToolsParserParamsBase;\nexport type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;\n/**\n * Class for parsing the output of a tool-calling LLM into a JSON object if you are\n * expecting only a single tool to be called.\n */\nexport declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    returnId: boolean;\n    /** The type of tool calls to return. */\n    keyName: string;\n    /** Whether to return only the first tool call. */\n    returnSingle: boolean;\n    zodSchema?: InteropZodType<T>;\n    constructor(params: JsonOutputKeyToolsParserParamsV3<T>);\n    constructor(params: JsonOutputKeyToolsParserParamsV4<T>);\n    constructor(params: JsonOutputKeyToolsParserParamsInterop<T>);\n    protected _validateResult(result: unknown): Promise<T>;\n    parsePartialResult(generations: ChatGeneration[]): Promise<any>;\n    parseResult(generations: ChatGeneration[]): Promise<any>;\n}\nexport {};\n//# sourceMappingURL=json_output_tools_parsers.d.ts.map"],"mappings":"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"}

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.ts

@@ -9,28 +9,21 @@ import * as z4 from "zod/v4/core";
 type ParsedToolCall = {
   id?: string;
   type: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   args: Record<string, any>;
 };
 type JsonOutputToolsParserParams = {
   /** Whether to return the tool call id. */
   returnId?: boolean;
 } & BaseCumulativeTransformOutputParserInput;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options: {
   returnId?: boolean;
   partial: true;
 }): ToolCall | undefined;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options?: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options?: {
   returnId?: boolean;
   partial?: false;
 }): ToolCall;
-declare function parseToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, options?: {
+declare function parseToolCall(rawToolCall: Record<string, any>, options?: {
   returnId?: boolean;
   partial?: boolean;
 }): ToolCall | undefined;
@@ -42,9 +35,7 @@ declare function convertLangChainToolCallToOpenAI(toolCall: ToolCall): {
     arguments: string;
   };
 };
-declare function makeInvalidToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;
+declare function makeInvalidToolCall(rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
@@ -63,40 +54,27 @@ declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOutputPars
    * @param generations The output of the LLM to parse.
    * @returns A JSON object representation of the function call or its arguments.
    */
-  parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): Promise<any>;
+  parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;
 }
 type JsonOutputKeyToolsParserParamsBase = {
   keyName: string;
   returnSingle?: boolean;
 } & JsonOutputToolsParserParams;
-type JsonOutputKeyToolsParserParamsV3<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsV3<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: z3.ZodType<T>;
 } & JsonOutputKeyToolsParserParamsBase;
-type JsonOutputKeyToolsParserParamsV4<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsV4<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: z4.$ZodType<T, T>;
 } & JsonOutputKeyToolsParserParamsBase;
-type JsonOutputKeyToolsParserParamsInterop<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsInterop<T extends Record<string, any> = Record<string, any>> = {
   zodSchema?: InteropZodType<T>;
 } & JsonOutputKeyToolsParserParamsBase;
-// Use Zod 3 for backwards compatibility
-type JsonOutputKeyToolsParserParams<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;
+type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
  */
-declare class JsonOutputKeyToolsParser<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {
+declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -110,9 +88,7 @@ T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsPars
   constructor(params: JsonOutputKeyToolsParserParamsV4<T>);
   constructor(params: JsonOutputKeyToolsParserParamsInterop<T>);
   protected _validateResult(result: unknown): Promise<T>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parsePartialResult(generations: ChatGeneration[]): Promise<any>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parseResult(generations: ChatGeneration[]): Promise<any>;
 }
 //#endregion

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_output_tools_parsers.d.ts","names":["z3","z4","ChatGeneration","ChatGenerationChunk","InvalidToolCall","ToolCall","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","InteropZodType","ParsedToolCall","Record","JsonOutputToolsParserParams","parseToolCall","convertLangChainToolCallToOpenAI","makeInvalidToolCall","JsonOutputToolsParser","T","Promise","JsonOutputKeyToolsParserParamsBase","JsonOutputKeyToolsParserParamsV3","ZodType","JsonOutputKeyToolsParserParamsV4","$ZodType","JsonOutputKeyToolsParserParamsInterop","JsonOutputKeyToolsParserParams","JsonOutputKeyToolsParser"],"sources":["../../../src/output_parsers/openai_tools/json_output_tools_parsers.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { ChatGeneration, ChatGenerationChunk } from \"../../outputs.js\";\nimport { InvalidToolCall, ToolCall } from \"../../messages/tool.js\";\nimport { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"../transform.js\";\nimport { type InteropZodType } from \"../../utils/types/zod.js\";\nexport type ParsedToolCall = {\n    id?: string;\n    type: string;\n    args: Record<string, any>;\n};\nexport type JsonOutputToolsParserParams = {\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n} & BaseCumulativeTransformOutputParserInput;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options: {\n    returnId?: boolean;\n    partial: true;\n}): ToolCall | undefined;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options?: {\n    returnId?: boolean;\n    partial?: false;\n}): ToolCall;\nexport declare function parseToolCall(rawToolCall: Record<string, any>, options?: {\n    returnId?: boolean;\n    partial?: boolean;\n}): ToolCall | undefined;\nexport declare function convertLangChainToolCallToOpenAI(toolCall: ToolCall): {\n    id: string;\n    type: string;\n    function: {\n        name: string;\n        arguments: string;\n    };\n};\nexport declare function makeInvalidToolCall(rawToolCall: Record<string, any>, errorMsg?: string): InvalidToolCall;\n/**\n * Class for parsing the output of a tool-calling LLM into a JSON object.\n */\nexport declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    returnId: boolean;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    constructor(fields?: JsonOutputToolsParserParams);\n    protected _diff(): void;\n    parse(): Promise<T>;\n    parseResult(generations: ChatGeneration[]): Promise<T>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;\n}\ntype JsonOutputKeyToolsParserParamsBase = {\n    keyName: string;\n    returnSingle?: boolean;\n} & JsonOutputToolsParserParams;\ntype JsonOutputKeyToolsParserParamsV3<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: z3.ZodType<T>;\n} & JsonOutputKeyToolsParserParamsBase;\ntype JsonOutputKeyToolsParserParamsV4<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: z4.$ZodType<T, T>;\n} & JsonOutputKeyToolsParserParamsBase;\nexport type JsonOutputKeyToolsParserParamsInterop<T extends Record<string, any> = Record<string, any>> = {\n    zodSchema?: InteropZodType<T>;\n} & JsonOutputKeyToolsParserParamsBase;\nexport type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;\n/**\n * Class for parsing the output of a tool-calling LLM into a JSON object if you are\n * expecting only a single tool to be called.\n */\nexport declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    returnId: boolean;\n    /** The type of tool calls to return. */\n    keyName: string;\n    /** Whether to return only the first tool call. */\n    returnSingle: boolean;\n    zodSchema?: InteropZodType<T>;\n    constructor(params: JsonOutputKeyToolsParserParamsV3<T>);\n    constructor(params: JsonOutputKeyToolsParserParamsV4<T>);\n    constructor(params: JsonOutputKeyToolsParserParamsInterop<T>);\n    protected _validateResult(result: unknown): Promise<T>;\n    parsePartialResult(generations: ChatGeneration[]): Promise<any>;\n    parseResult(generations: ChatGeneration[]): Promise<any>;\n}\nexport {};\n//# sourceMappingURL=json_output_tools_parsers.d.ts.map"],"mappings":"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"}

package/dist/output_parsers/string.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.cts","names":["BaseTransformOutputParser","ContentBlock","StringOutputParser","Promise","Text","Data","URLContentBlock"],"sources":["../../src/output_parsers/string.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\nimport { ContentBlock } from \"../messages/index.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string.\n * @example\n * ```typescript\n * const promptTemplate = PromptTemplate.fromTemplate(\n *   \"Tell me a joke about {topic}\",\n * );\n *\n * const chain = RunnableSequence.from([\n *   promptTemplate,\n *   new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   new StringOutputParser(),\n * ]);\n *\n * const result = await chain.invoke({ topic: \"bears\" });\n * console.log(\"What do you call a bear with no teeth? A gummy bear!\");\n * ```\n */\nexport declare class StringOutputParser extends BaseTransformOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * Parses a string output from an LLM call. This method is meant to be\n     * implemented by subclasses to define how a string output from an LLM\n     * should be parsed.\n     * @param text The string output from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parse(text: string): Promise<string>;\n    getFormatInstructions(): string;\n    protected _textContentToString(content: ContentBlock.Text): string;\n    protected _imageUrlContentToString(_content: ContentBlock.Data.URLContentBlock): string;\n    protected _messageContentToString(content: ContentBlock): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n}\n//# sourceMappingURL=string.d.ts.map"],"mappings":";;;;;;;AAoBA;;;;;;;AAAyE;;;;;;;;;cAApDE,kBAAAA,SAA2BF;;;;;;;;;;;;uBAYvBG;;0CAEmBF,YAAAA,CAAaG;+CACRH,YAAAA,CAAaI,IAAAA,CAAKC;6CACpBL;iDACIA"}

package/dist/output_parsers/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","names":["BaseTransformOutputParser","ContentBlock","StringOutputParser","Promise","Text","Data","URLContentBlock"],"sources":["../../src/output_parsers/string.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\nimport { ContentBlock } from \"../messages/index.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string.\n * @example\n * ```typescript\n * const promptTemplate = PromptTemplate.fromTemplate(\n *   \"Tell me a joke about {topic}\",\n * );\n *\n * const chain = RunnableSequence.from([\n *   promptTemplate,\n *   new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   new StringOutputParser(),\n * ]);\n *\n * const result = await chain.invoke({ topic: \"bears\" });\n * console.log(\"What do you call a bear with no teeth? A gummy bear!\");\n * ```\n */\nexport declare class StringOutputParser extends BaseTransformOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * Parses a string output from an LLM call. This method is meant to be\n     * implemented by subclasses to define how a string output from an LLM\n     * should be parsed.\n     * @param text The string output from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parse(text: string): Promise<string>;\n    getFormatInstructions(): string;\n    protected _textContentToString(content: ContentBlock.Text): string;\n    protected _imageUrlContentToString(_content: ContentBlock.Data.URLContentBlock): string;\n    protected _messageContentToString(content: ContentBlock): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n}\n//# sourceMappingURL=string.d.ts.map"],"mappings":";;;;;;;;;AAoBA;;;;;;;AAAyE;;;;;;;;cAApDE,kBAAAA,SAA2BF;;;;;;;;;;;;uBAYvBG;;0CAEmBF,YAAAA,CAAaG;+CACRH,YAAAA,CAAaI,IAAAA,CAAKC;6CACpBL;iDACIA"}

package/dist/output_parsers/structured.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.cts","names":["z","BaseOutputParser","FormatInstructionsOptions","InteropZodType","InferInteropZodOutput","JsonMarkdownStructuredOutputParserInput","JsonMarkdownFormatInstructionsOptions","StructuredOutputParser","T","S","___load_serializable_js0","SerializedNotImplemented","ZodString","ZodTypeAny","ZodObject","Promise","JsonMarkdownStructuredOutputParser","AsymmetricStructuredOutputParserFields","AsymmetricStructuredOutputParser","Y","inputSchema"],"sources":["../../src/output_parsers/structured.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseOutputParser, FormatInstructionsOptions } from \"./base.js\";\nimport { type InteropZodType, type InferInteropZodOutput } from \"../utils/types/zod.js\";\nexport type JsonMarkdownStructuredOutputParserInput = {\n    interpolationDepth?: number;\n};\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n    interpolationDepth?: number;\n}\nexport declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutputParser<InferInteropZodOutput<T>> {\n    schema: T;\n    static lc_name(): string;\n    lc_namespace: string[];\n    toJSON(): import(\"../load/serializable.js\").SerializedNotImplemented;\n    constructor(schema: T);\n    /**\n     * Creates a new StructuredOutputParser from a Zod schema.\n     * @param schema The Zod schema which the output should match\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromZodSchema<T extends InteropZodType>(schema: T): StructuredOutputParser<T>;\n    /**\n     * Creates a new StructuredOutputParser from a set of names and\n     * descriptions.\n     * @param schemas An object where each key is a name and each value is a description\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): StructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n    /**\n     * Returns a markdown code snippet with a JSON object formatted according\n     * to the schema.\n     * @param options Optional. The options for formatting the instructions\n     * @returns A markdown code snippet with a JSON object formatted according to the schema.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Parses the given text according to the schema.\n     * @param text The text to parse\n     * @returns The parsed output.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<T>>;\n}\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport declare class JsonMarkdownStructuredOutputParser<T extends InteropZodType> extends StructuredOutputParser<T> {\n    static lc_name(): string;\n    getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;\n    private _schemaToInstruction;\n    static fromZodSchema<T extends InteropZodType>(schema: T): JsonMarkdownStructuredOutputParser<T>;\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n}\nexport interface AsymmetricStructuredOutputParserFields<T extends InteropZodType> {\n    inputSchema: T;\n}\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport declare abstract class AsymmetricStructuredOutputParser<T extends InteropZodType, Y = unknown> extends BaseOutputParser<Y> {\n    private structuredInputParser;\n    constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);\n    /**\n     * Processes the parsed input into the desired output format. Must be\n     * implemented by subclasses.\n     * @param input The parsed input\n     * @returns The processed output.\n     */\n    abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n    parse(text: string): Promise<Y>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;KAGYK,uCAAAA;;;AAAAA,UAGKC,qCAAAA,SAA8CJ,yBAHZ,CAAA;EAGlCI,kBAAAA,CAAAA,EAAAA,MAAAA;AAGjB;AAAsDH,cAAjCI,sBAAiCJ,CAAAA,UAAAA,cAAAA,CAAAA,SAAwBF,gBAAxBE,CAAyCC,qBAAzCD,CAA+DK,CAA/DL,CAAAA,CAAAA,CAAAA;EAA+DK,MAAAA,EACzGA,CADyGA;EAAtBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACnFI,YAAAA,EAAAA,MAAAA,EAAAA;;EAIYA,WAAAA,CAAAA,MAAAA,EAAAA,CAAAA;EAMWL;;;;;EAUZS,OAAAA,aAAAA,CAAAA,UAVYT,cAUZS,CAAAA,CAAAA,MAAAA,EAVoCJ,CAUpCI,CAAAA,EAVwCL,sBAUxCK,CAV+DJ,CAU/DI,CAAAA;EACLC;;;;;;EAtB4DZ,OAAAA,wBAAAA,CAAAA,UAAAA;IAAgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EA6CzEe,CAAAA,CAAAA,CAAAA,OAAAA,EAzBLP,CAyBKO,CAAAA,EAzBDT,sBAyBmC,CAzBZP,CAAAA,CAAEc,SAyBUL,CAAAA;IAAWN,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAxB7CH,CAAAA,CAAEY,SAwB2CT;EAA+CK,CAAAA,EAAAA,OAAAA,EAvBjGR,CAAAA,CAAEa,UAuB+FL,EAAAA;IAE7EF,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAEDH,CAAAA,EAAAA;IAAwBK,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAuCA,CAAAA,CAAAA,CAAAA;EAAnCQ;;;;;;EAJ2BT,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB;AAehH;AAOA;;;EAEkBa,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9BOL,OA8BPK,CA9BehB,qBA8BfgB,CA9BqCZ,CA8BrCY,CAAAA,CAAAA;;;;;;AAO6CL,cA/B1CC,kCA+B0CD,CAAAA,UA/BGZ,cA+BHY,CAAAA,SA/B2BR,sBA+B3BQ,CA/BkDP,CA+BlDO,CAAAA,CAAAA;EAC9BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAARJ,qBAAAA,CAAAA,OAAAA,CAAAA,EA9BWT,qCA8BXS,CAAAA,EAAAA,MAAAA;EAVqFd,QAAAA,oBAAAA;EAAgB,OAAA,aAAA,CAAA,UAlB3FE,cAkB2F,CAAA,CAAA,MAAA,EAlBnEK,CAkBmE,CAAA,EAlB/DQ,kCAkB+D,CAlB5BR,CAkB4B,CAAA;;;cAf9GC,IAAIO,mCAAmChB,CAAAA,CAAEc;iBACpCd,CAAAA,CAAEY;cACPZ,CAAAA,CAAEa;;;;;;UAMDI,iDAAiDd;eACjDK;;;;;;uBAMaU,2CAA2Cf,qCAAqCF,iBAAiBkB;;;;KAE9FF,uCAAuCT;;;;;;;kCAOpCJ,sBAAsBI,KAAKO,QAAQI;uBAC9CJ,QAAQI"}

package/dist/output_parsers/structured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.ts","names":["z","BaseOutputParser","FormatInstructionsOptions","InteropZodType","InferInteropZodOutput","JsonMarkdownStructuredOutputParserInput","JsonMarkdownFormatInstructionsOptions","StructuredOutputParser","T","S","___load_serializable_js0","SerializedNotImplemented","ZodString","ZodTypeAny","ZodObject","Promise","JsonMarkdownStructuredOutputParser","AsymmetricStructuredOutputParserFields","AsymmetricStructuredOutputParser","Y","inputSchema"],"sources":["../../src/output_parsers/structured.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseOutputParser, FormatInstructionsOptions } from \"./base.js\";\nimport { type InteropZodType, type InferInteropZodOutput } from \"../utils/types/zod.js\";\nexport type JsonMarkdownStructuredOutputParserInput = {\n    interpolationDepth?: number;\n};\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n    interpolationDepth?: number;\n}\nexport declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutputParser<InferInteropZodOutput<T>> {\n    schema: T;\n    static lc_name(): string;\n    lc_namespace: string[];\n    toJSON(): import(\"../load/serializable.js\").SerializedNotImplemented;\n    constructor(schema: T);\n    /**\n     * Creates a new StructuredOutputParser from a Zod schema.\n     * @param schema The Zod schema which the output should match\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromZodSchema<T extends InteropZodType>(schema: T): StructuredOutputParser<T>;\n    /**\n     * Creates a new StructuredOutputParser from a set of names and\n     * descriptions.\n     * @param schemas An object where each key is a name and each value is a description\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): StructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n    /**\n     * Returns a markdown code snippet with a JSON object formatted according\n     * to the schema.\n     * @param options Optional. The options for formatting the instructions\n     * @returns A markdown code snippet with a JSON object formatted according to the schema.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Parses the given text according to the schema.\n     * @param text The text to parse\n     * @returns The parsed output.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<T>>;\n}\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport declare class JsonMarkdownStructuredOutputParser<T extends InteropZodType> extends StructuredOutputParser<T> {\n    static lc_name(): string;\n    getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;\n    private _schemaToInstruction;\n    static fromZodSchema<T extends InteropZodType>(schema: T): JsonMarkdownStructuredOutputParser<T>;\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n}\nexport interface AsymmetricStructuredOutputParserFields<T extends InteropZodType> {\n    inputSchema: T;\n}\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport declare abstract class AsymmetricStructuredOutputParser<T extends InteropZodType, Y = unknown> extends BaseOutputParser<Y> {\n    private structuredInputParser;\n    constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);\n    /**\n     * Processes the parsed input into the desired output format. Must be\n     * implemented by subclasses.\n     * @param input The parsed input\n     * @returns The processed output.\n     */\n    abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n    parse(text: string): Promise<Y>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;KAGYK,uCAAAA;;;AAAAA,UAGKC,qCAAAA,SAA8CJ,yBAHZ,CAAA;EAGlCI,kBAAAA,CAAAA,EAAAA,MAAAA;AAGjB;AAAsDH,cAAjCI,sBAAiCJ,CAAAA,UAAAA,cAAAA,CAAAA,SAAwBF,gBAAxBE,CAAyCC,qBAAzCD,CAA+DK,CAA/DL,CAAAA,CAAAA,CAAAA;EAA+DK,MAAAA,EACzGA,CADyGA;EAAtBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACnFI,YAAAA,EAAAA,MAAAA,EAAAA;;EAIYA,WAAAA,CAAAA,MAAAA,EAAAA,CAAAA;EAMWL;;;;;EAUZS,OAAAA,aAAAA,CAAAA,UAVYT,cAUZS,CAAAA,CAAAA,MAAAA,EAVoCJ,CAUpCI,CAAAA,EAVwCL,sBAUxCK,CAV+DJ,CAU/DI,CAAAA;EACLC;;;;;;EAtB4DZ,OAAAA,wBAAAA,CAAAA,UAAAA;IAAgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EA6CzEe,CAAAA,CAAAA,CAAAA,OAAAA,EAzBLP,CAyBKO,CAAAA,EAzBDT,sBAyBmC,CAzBZP,CAAAA,CAAEc,SAyBUL,CAAAA;IAAWN,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAxB7CH,CAAAA,CAAEY,SAwB2CT;EAA+CK,CAAAA,EAAAA,OAAAA,EAvBjGR,CAAAA,CAAEa,UAuB+FL,EAAAA;IAE7EF,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAEDH,CAAAA,EAAAA;IAAwBK,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAuCA,CAAAA,CAAAA,CAAAA;EAAnCQ;;;;;;EAJ2BT,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB;AAehH;AAOA;;;EAEkBa,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9BOL,OA8BPK,CA9BehB,qBA8BfgB,CA9BqCZ,CA8BrCY,CAAAA,CAAAA;;;;;;AAO6CL,cA/B1CC,kCA+B0CD,CAAAA,UA/BGZ,cA+BHY,CAAAA,SA/B2BR,sBA+B3BQ,CA/BkDP,CA+BlDO,CAAAA,CAAAA;EAC9BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAARJ,qBAAAA,CAAAA,OAAAA,CAAAA,EA9BWT,qCA8BXS,CAAAA,EAAAA,MAAAA;EAVqFd,QAAAA,oBAAAA;EAAgB,OAAA,aAAA,CAAA,UAlB3FE,cAkB2F,CAAA,CAAA,MAAA,EAlBnEK,CAkBmE,CAAA,EAlB/DQ,kCAkB+D,CAlB5BR,CAkB4B,CAAA;;;cAf9GC,IAAIO,mCAAmChB,CAAAA,CAAEc;iBACpCd,CAAAA,CAAEY;cACPZ,CAAAA,CAAEa;;;;;;UAMDI,iDAAiDd;eACjDK;;;;;;uBAMaU,2CAA2Cf,qCAAqCF,iBAAiBkB;;;;KAE9FF,uCAAuCT;;;;;;;kCAOpCJ,sBAAsBI,KAAKO,QAAQI;uBAC9CJ,QAAQI"}

package/dist/output_parsers/transform.d.cts

@@ -30,7 +30,6 @@ type BaseCumulativeTransformOutputParserInput = {
 declare abstract class BaseCumulativeTransformOutputParser<T = unknown> extends BaseTransformOutputParser<T> {
   protected diff: boolean;
   constructor(fields?: BaseCumulativeTransformOutputParserInput);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   protected abstract _diff(prev: any | undefined, next: any): any;
   abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;
   _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;

package/dist/output_parsers/transform.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.cts","names":["BaseOutputParser","BaseMessage","BaseCallbackConfig","Generation","ChatGeneration","BaseTransformOutputParser","T","AsyncGenerator","BaseCumulativeTransformOutputParserInput","BaseCumulativeTransformOutputParser","Promise"],"sources":["../../src/output_parsers/transform.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"./base.js\";\nimport { type BaseMessage } from \"../messages/base.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport { type Generation, type ChatGeneration } from \"../outputs.js\";\n/**\n * Class to parse the output of an LLM call that also allows streaming inputs.\n */\nexport declare abstract class BaseTransformOutputParser<T = unknown> extends BaseOutputParser<T> {\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;\n    /**\n     * Transforms an asynchronous generator of input into an asynchronous\n     * generator of parsed output.\n     * @param inputGenerator An asynchronous generator of input.\n     * @param options A configuration object.\n     * @returns An asynchronous generator of parsed output.\n     */\n    transform(inputGenerator: AsyncGenerator<string | BaseMessage>, options: BaseCallbackConfig): AsyncGenerator<T>;\n}\nexport type BaseCumulativeTransformOutputParserInput = {\n    diff?: boolean;\n};\n/**\n * A base class for output parsers that can handle streaming input. It\n * extends the `BaseTransformOutputParser` class and provides a method for\n * converting parsed outputs into a diff format.\n */\nexport declare abstract class BaseCumulativeTransformOutputParser<T = unknown> extends BaseTransformOutputParser<T> {\n    protected diff: boolean;\n    constructor(fields?: BaseCumulativeTransformOutputParserInput);\n    protected abstract _diff(prev: any | undefined, next: any): any;\n    abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=transform.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAA8FM,uBAAhED,yBAAgEC,CAAAA,IAAAA,OAAAA,CAAAA,SAAjBN,gBAAiBM,CAAAA,CAAAA,CAAAA,CAAAA;EACvCL,UAAAA,CAAAA,cAAAA,EAAxBM,cAAwBN,CAAAA,MAAAA,GAAAA,WAAAA,CAAAA,CAAAA,EAAeM,cAAfN,CAA8BK,CAA9BL,CAAAA;EAAxBM;;;;;;;EAQmEA,SAAAA,CAAAA,cAAAA,EAApEA,cAAoEA,CAAAA,MAAAA,GAA5CN,WAA4CM,CAAAA,EAAAA,OAAAA,EAArBL,kBAAqBK,CAAAA,EAAAA,cAAAA,CAAeD,CAAfC,CAAAA;;AATL,KAWjFC,wCAAAA,GAXiF;EAWjFA,IAAAA,CAAAA,EAAAA,OAAAA;AAQZ,CAAA;;;;;;AAI+EE,uBAJjDD,mCAIiDC,CAAAA,IAAAA,OAAAA,CAAAA,SAJQL,yBAIRK,CAJkCJ,CAIlCI,CAAAA,CAAAA;EACxBT,UAAAA,IAAAA,EAAAA,OAAAA;EAAxBM,WAAAA,CAAAA,MAAAA,CAAAA,EAHNC,wCAGMD;EAAsDD,mBAAAA,KAAAA,CAAAA,IAAAA,EAAAA,GAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,GAAAA,CAAAA,EAAAA,GAAAA;EAAfC,SAAAA,kBAAAA,CAAAA,WAAAA,EADzBJ,UACyBI,EAAAA,GADVH,cACUG,EAAAA,CAAAA,EADSG,OACTH,CADiBD,CACjBC,GAAAA,SAAAA,CAAAA;EALiBF,UAAAA,CAAAA,cAAAA,EAKxDE,cALwDF,CAAAA,MAAAA,GAKhCJ,WALgCI,CAAAA,CAAAA,EAKjBE,cALiBF,CAKFC,CALED,CAAAA;EAAyB,qBAAA,CAAA,CAAA,EAAA,MAAA"}

package/dist/output_parsers/transform.d.ts

@@ -30,7 +30,6 @@ type BaseCumulativeTransformOutputParserInput = {
 declare abstract class BaseCumulativeTransformOutputParser<T = unknown> extends BaseTransformOutputParser<T> {
   protected diff: boolean;
   constructor(fields?: BaseCumulativeTransformOutputParserInput);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   protected abstract _diff(prev: any | undefined, next: any): any;
   abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;
   _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;

package/dist/output_parsers/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","names":["BaseOutputParser","BaseMessage","BaseCallbackConfig","Generation","ChatGeneration","BaseTransformOutputParser","T","AsyncGenerator","BaseCumulativeTransformOutputParserInput","BaseCumulativeTransformOutputParser","Promise"],"sources":["../../src/output_parsers/transform.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"./base.js\";\nimport { type BaseMessage } from \"../messages/base.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport { type Generation, type ChatGeneration } from \"../outputs.js\";\n/**\n * Class to parse the output of an LLM call that also allows streaming inputs.\n */\nexport declare abstract class BaseTransformOutputParser<T = unknown> extends BaseOutputParser<T> {\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;\n    /**\n     * Transforms an asynchronous generator of input into an asynchronous\n     * generator of parsed output.\n     * @param inputGenerator An asynchronous generator of input.\n     * @param options A configuration object.\n     * @returns An asynchronous generator of parsed output.\n     */\n    transform(inputGenerator: AsyncGenerator<string | BaseMessage>, options: BaseCallbackConfig): AsyncGenerator<T>;\n}\nexport type BaseCumulativeTransformOutputParserInput = {\n    diff?: boolean;\n};\n/**\n * A base class for output parsers that can handle streaming input. It\n * extends the `BaseTransformOutputParser` class and provides a method for\n * converting parsed outputs into a diff format.\n */\nexport declare abstract class BaseCumulativeTransformOutputParser<T = unknown> extends BaseTransformOutputParser<T> {\n    protected diff: boolean;\n    constructor(fields?: BaseCumulativeTransformOutputParserInput);\n    protected abstract _diff(prev: any | undefined, next: any): any;\n    abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=transform.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAA8FM,uBAAhED,yBAAgEC,CAAAA,IAAAA,OAAAA,CAAAA,SAAjBN,gBAAiBM,CAAAA,CAAAA,CAAAA,CAAAA;EACvCL,UAAAA,CAAAA,cAAAA,EAAxBM,cAAwBN,CAAAA,MAAAA,GAAAA,WAAAA,CAAAA,CAAAA,EAAeM,cAAfN,CAA8BK,CAA9BL,CAAAA;EAAxBM;;;;;;;EAQmEA,SAAAA,CAAAA,cAAAA,EAApEA,cAAoEA,CAAAA,MAAAA,GAA5CN,WAA4CM,CAAAA,EAAAA,OAAAA,EAArBL,kBAAqBK,CAAAA,EAAAA,cAAAA,CAAeD,CAAfC,CAAAA;;AATL,KAWjFC,wCAAAA,GAXiF;EAWjFA,IAAAA,CAAAA,EAAAA,OAAAA;AAQZ,CAAA;;;;;;AAI+EE,uBAJjDD,mCAIiDC,CAAAA,IAAAA,OAAAA,CAAAA,SAJQL,yBAIRK,CAJkCJ,CAIlCI,CAAAA,CAAAA;EACxBT,UAAAA,IAAAA,EAAAA,OAAAA;EAAxBM,WAAAA,CAAAA,MAAAA,CAAAA,EAHNC,wCAGMD;EAAsDD,mBAAAA,KAAAA,CAAAA,IAAAA,EAAAA,GAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,GAAAA,CAAAA,EAAAA,GAAAA;EAAfC,SAAAA,kBAAAA,CAAAA,WAAAA,EADzBJ,UACyBI,EAAAA,GADVH,cACUG,EAAAA,CAAAA,EADSG,OACTH,CADiBD,CACjBC,GAAAA,SAAAA,CAAAA;EALiBF,UAAAA,CAAAA,cAAAA,EAKxDE,cALwDF,CAAAA,MAAAA,GAKhCJ,WALgCI,CAAAA,CAAAA,EAKjBE,cALiBF,CAKFC,CALED,CAAAA;EAAyB,qBAAA,CAAA,CAAA,EAAA,MAAA"}

package/dist/output_parsers/xml.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.cts","names":["BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","Operation","ChatGeneration","Generation","XML_FORMAT_INSTRUCTIONS","XMLOutputParserFields","Content","Array","XMLResult","XMLOutputParser","Promise","parseXMLMarkdown"],"sources":["../../src/output_parsers/xml.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nexport declare const XML_FORMAT_INSTRUCTIONS = \"The output should be formatted as a XML file.\\n1. Output should conform to the tags below. \\n2. If tags are not given, make them on your own.\\n3. Remember to always open and close all the tags.\\n\\nAs an example, for the tags [\\\"foo\\\", \\\"bar\\\", \\\"baz\\\"]:\\n1. String \\\"<foo>\\n   <bar>\\n      <baz></baz>\\n   </bar>\\n</foo>\\\" is a well-formatted instance of the schema. \\n2. String \\\"<foo>\\n   <bar>\\n   </foo>\\\" is a badly-formatted instance.\\n3. String \\\"<foo>\\n   <tag>\\n   </tag>\\n</foo>\\\" is a badly-formatted instance.\\n\\nHere are the output tags:\\n```\\n{tags}\\n```\";\nexport interface XMLOutputParserFields extends BaseCumulativeTransformOutputParserInput {\n    /**\n     * Optional list of tags that the output should conform to.\n     * Only used in formatting of the prompt.\n     */\n    tags?: string[];\n}\nexport type Content = string | undefined | Array<{\n    [key: string]: Content;\n}>;\nexport type XMLResult = {\n    [key: string]: Content;\n};\nexport declare class XMLOutputParser extends BaseCumulativeTransformOutputParser<XMLResult> {\n    tags?: string[];\n    constructor(fields?: XMLOutputParserFields);\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<XMLResult | undefined>;\n    parse(text: string): Promise<XMLResult>;\n    getFormatInstructions(): string;\n}\nexport declare function parseXMLMarkdown(s: string): XMLResult;\n//# sourceMappingURL=xml.d.ts.map"],"mappings":";;;;;cAGqBK,uBAAAA;UACJC,qBAAAA,SAA8BL;EAD1BI;AACrB;AAOA;AAGA;EAGqBK,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;AAEIJ,KARbC,OAAAA,GAQaD,MAAAA,GAAAA,SAAAA,GARkBE,KAQlBF,CAAAA;EAIsCJ,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAX5CK,OAW4CL;CAC3BC,CAAAA;AAAmBC,KAV3CK,SAAAA,GAU2CL;EAAuBK,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAT3DF,OAS2DE;CAARE;AACrCF,cARZC,eAAAA,SAAwBV,mCAQZS,CARgDA,SAQhDA,CAAAA,CAAAA;EAARE,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EARoBX,WAAAA,CAAAA,MAAAA,CAAAA,EAEpBM,qBAFoBN;EAAmC,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAWxDY,YAAAA,EAAAA,MAAgB,EAAA;;6DALuBV;kCAC3BC,mBAAmBC,eAAeO,QAAQF;uBACrDE,QAAQF;;;iBAGTG,gBAAAA,aAA6BH"}

package/dist/output_parsers/xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","names":["BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","Operation","ChatGeneration","Generation","XML_FORMAT_INSTRUCTIONS","XMLOutputParserFields","Content","Array","XMLResult","XMLOutputParser","Promise","parseXMLMarkdown"],"sources":["../../src/output_parsers/xml.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nexport declare const XML_FORMAT_INSTRUCTIONS = \"The output should be formatted as a XML file.\\n1. Output should conform to the tags below. \\n2. If tags are not given, make them on your own.\\n3. Remember to always open and close all the tags.\\n\\nAs an example, for the tags [\\\"foo\\\", \\\"bar\\\", \\\"baz\\\"]:\\n1. String \\\"<foo>\\n   <bar>\\n      <baz></baz>\\n   </bar>\\n</foo>\\\" is a well-formatted instance of the schema. \\n2. String \\\"<foo>\\n   <bar>\\n   </foo>\\\" is a badly-formatted instance.\\n3. String \\\"<foo>\\n   <tag>\\n   </tag>\\n</foo>\\\" is a badly-formatted instance.\\n\\nHere are the output tags:\\n```\\n{tags}\\n```\";\nexport interface XMLOutputParserFields extends BaseCumulativeTransformOutputParserInput {\n    /**\n     * Optional list of tags that the output should conform to.\n     * Only used in formatting of the prompt.\n     */\n    tags?: string[];\n}\nexport type Content = string | undefined | Array<{\n    [key: string]: Content;\n}>;\nexport type XMLResult = {\n    [key: string]: Content;\n};\nexport declare class XMLOutputParser extends BaseCumulativeTransformOutputParser<XMLResult> {\n    tags?: string[];\n    constructor(fields?: XMLOutputParserFields);\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<XMLResult | undefined>;\n    parse(text: string): Promise<XMLResult>;\n    getFormatInstructions(): string;\n}\nexport declare function parseXMLMarkdown(s: string): XMLResult;\n//# sourceMappingURL=xml.d.ts.map"],"mappings":";;;;;cAGqBK,uBAAAA;UACJC,qBAAAA,SAA8BL;EAD1BI;AACrB;AAOA;AAGA;EAGqBK,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;AAEIJ,KARbC,OAAAA,GAQaD,MAAAA,GAAAA,SAAAA,GARkBE,KAQlBF,CAAAA;EAIsCJ,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAX5CK,OAW4CL;CAC3BC,CAAAA;AAAmBC,KAV3CK,SAAAA,GAU2CL;EAAuBK,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAT3DF,OAS2DE;CAARE;AACrCF,cARZC,eAAAA,SAAwBV,mCAQZS,CARgDA,SAQhDA,CAAAA,CAAAA;EAARE,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EARoBX,WAAAA,CAAAA,MAAAA,CAAAA,EAEpBM,qBAFoBN;EAAmC,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAWxDY,YAAAA,EAAAA,MAAgB,EAAA;;6DALuBV;kCAC3BC,mBAAmBC,eAAeO,QAAQF;uBACrDE,QAAQF;;;iBAGTG,gBAAAA,aAA6BH"}