@langchain/classic 1.0.52 → 1.0.53

package/dist/chains/openai_moderation.d.ts

@@ -6,7 +6,7 @@ import { AsyncCaller, AsyncCallerParams } from "@langchain/core/utils/async_call
 /**
  * Interface for the input parameters of the OpenAIModerationChain class.
  */
-interface OpenAIModerationChainInput extends ChainInputs, AsyncCallerParams {
+export interface OpenAIModerationChainInput extends ChainInputs, AsyncCallerParams {
   apiKey?: string;
   /** @deprecated Use "apiKey" instead. */
   openAIApiKey?: string;
@@ -47,7 +47,7 @@ interface OpenAIModerationChainInput extends ChainInputs, AsyncCallerParams {
  * }
  * ```
  */
-declare class OpenAIModerationChain extends BaseChain implements OpenAIModerationChainInput {
+export declare class OpenAIModerationChain extends BaseChain implements OpenAIModerationChainInput {
   static lc_name(): string;
   get lc_secrets(): {
     [key: string]: string;
@@ -68,5 +68,4 @@ declare class OpenAIModerationChain extends BaseChain implements OpenAIModeratio
   get outputKeys(): string[];
 }
 //#endregion
-export { OpenAIModerationChain, OpenAIModerationChainInput };
 //# sourceMappingURL=openai_moderation.d.ts.map

package/dist/chains/openai_moderation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_moderation.d.ts","names":[],"sources":["../../src/chains/openai_moderation.ts"],"mappings":";;;;;;;;UAYiB,mCACP,aAAa;EACrB;;EAEA;EACA;EACA;EACA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoCL,8BACH,qBACG;SAEJ;MAIH;KAAiB;;EAMrB;EAEA;EAEA;EAEA;EAEA,cAAc;EAEd,QAAQ;EAER;EAEA,QAAQ;EAER,YAAY,SAAS;EAyBrB,UAAU,cAAc,SAAS,aAAa;EAYxC,MAAM,QAAQ,cAAc,QAAQ;EAyB1C;MAII;MAIA"}
+{"version":3,"file":"openai_moderation.d.ts","names":[],"sources":["../../src/chains/openai_moderation.ts"],"mappings":";;;;;;;;iBAYiB,mCACP,aAAa;EACrB;;EAEA;EACA;EACA;EACA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCL,8BACH,qBACG;SAEJ;MAIH;KAAiB;;EAMrB;EAEA;EAEA;EAEA;EAEA,cAAc;EAEd,QAAQ;EAER;EAEA,QAAQ;EAER,YAAY,SAAS;EAyBrB,UAAU,cAAc,SAAS,aAAa;EAYxC,MAAM,QAAQ,cAAc,QAAQ;EAyB1C;MAII;MAIA"}

package/dist/chains/query_constructor/index.d.cts

@@ -12,7 +12,7 @@ import { Comparator, Operator, StructuredQuery } from "@langchain/core/structure
  * is typically used to provide metadata about attributes in other classes
  * or data structures within the LangChain framework.
  */
-declare class AttributeInfo {
+export declare class AttributeInfo {
   name: string;
   type: string;
   description: string;
@@ -32,7 +32,7 @@ declare const queryInputSchema: z.ZodObject<{
  * A class that extends AsymmetricStructuredOutputParser to parse
  * structured query output.
  */
-declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
+export declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
   lc_namespace: string[];
   queryTransformer: QueryTransformer;
   constructor(fields: {
@@ -55,11 +55,11 @@ declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputPars
    */
   static fromComponents(allowedComparators?: Comparator[], allowedOperators?: Operator[]): StructuredQueryOutputParser;
 }
-declare function formatAttributeInfo(info: AttributeInfo[]): string;
+export declare function formatAttributeInfo(info: AttributeInfo[]): string;
 /**
  * A type that represents options for the query constructor chain.
  */
-type QueryConstructorRunnableOptions = {
+export type QueryConstructorRunnableOptions = {
   llm: BaseLanguageModelInterface;
   documentContents: string;
   attributeInfo: AttributeInfo[];
@@ -68,8 +68,8 @@ type QueryConstructorRunnableOptions = {
   allowedOperators?: Operator[];
 };
 /** @deprecated */
-type QueryConstructorChainOptions = QueryConstructorRunnableOptions;
-declare function loadQueryConstructorRunnable(opts: QueryConstructorRunnableOptions): Runnable<any, StructuredQuery, RunnableConfig<Record<string, any>>>;
+export type QueryConstructorChainOptions = QueryConstructorRunnableOptions;
+export declare function loadQueryConstructorRunnable(opts: QueryConstructorRunnableOptions): Runnable<any, StructuredQuery, RunnableConfig<Record<string, any>>>;
 //#endregion
-export { AttributeInfo, DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, QueryConstructorChainOptions, QueryConstructorRunnableOptions, QueryTransformer, StructuredQueryOutputParser, type TraverseType, formatAttributeInfo, loadQueryConstructorRunnable };
+export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, QueryTransformer, type TraverseType };
 //# sourceMappingURL=index.d.cts.map

package/dist/chains/query_constructor/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/chains/query_constructor/index.ts"],"mappings":";;;;;;;;;;;;;;cAkCa;EAEF;EACA;EACA;EAHT,YACS,cACA,cACA;;cAaL,kBAAgB,EAAA;;;;;;;;;;;;;;cAcT,oCAAoC,wCACxC,kBACP;EAEA;EAEA,kBAAkB;EAElB,YAAY;IACV,oBAAoB;IACpB,kBAAkB;;;;;;;;EAiBd,kBACJ,OACA,UACC,6BAA6B,oBAAoB,QAAQ;;;;;;;;SAoBrD,eACL,qBAAoB,cACpB,mBAAkB,aAAe;;iBASrB,oBAAoB,MAAM;;;;KA8D9B;EACV,KAAK;EACL;EACA,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,mBAAmB;;;KAIT,+BAA+B;iBAE3B,6BACd,MAAM,kCAEL,cAAc,iBAAiB,eAAe"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/chains/query_constructor/index.ts"],"mappings":";;;;;;;;;;;;;;qBAkCa;EAEF;EACA;EACA;EAHT,YACS,cACA,cACA;;cAaL,kBAAgB,EAAA;;;;;;;;;;;;;;qBAcT,oCAAoC,wCACxC,kBACP;EAEA;EAEA,kBAAkB;EAElB,YAAY;IACV,oBAAoB;IACpB,kBAAkB;;;;;;;;EAiBd,kBACJ,OACA,UACC,6BAA6B,oBAAoB,QAAQ;;;;;;;;SAoBrD,eACL,qBAAoB,cACpB,mBAAkB,aAAe;;wBASrB,oBAAoB,MAAM;;;;YA8D9B;EACV,KAAK;EACL;EACA,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,mBAAmB;;;YAIT,+BAA+B;wBAE3B,6BACd,MAAM,kCAEL,cAAc,iBAAiB,eAAe"}

package/dist/chains/query_constructor/index.d.ts

@@ -12,7 +12,7 @@ import { Comparator, Operator, StructuredQuery } from "@langchain/core/structure
  * is typically used to provide metadata about attributes in other classes
  * or data structures within the LangChain framework.
  */
-declare class AttributeInfo {
+export declare class AttributeInfo {
   name: string;
   type: string;
   description: string;
@@ -32,7 +32,7 @@ declare const queryInputSchema: z.ZodObject<{
  * A class that extends AsymmetricStructuredOutputParser to parse
  * structured query output.
  */
-declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
+export declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
   lc_namespace: string[];
   queryTransformer: QueryTransformer;
   constructor(fields: {
@@ -55,11 +55,11 @@ declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputPars
    */
   static fromComponents(allowedComparators?: Comparator[], allowedOperators?: Operator[]): StructuredQueryOutputParser;
 }
-declare function formatAttributeInfo(info: AttributeInfo[]): string;
+export declare function formatAttributeInfo(info: AttributeInfo[]): string;
 /**
  * A type that represents options for the query constructor chain.
  */
-type QueryConstructorRunnableOptions = {
+export type QueryConstructorRunnableOptions = {
   llm: BaseLanguageModelInterface;
   documentContents: string;
   attributeInfo: AttributeInfo[];
@@ -68,8 +68,8 @@ type QueryConstructorRunnableOptions = {
   allowedOperators?: Operator[];
 };
 /** @deprecated */
-type QueryConstructorChainOptions = QueryConstructorRunnableOptions;
-declare function loadQueryConstructorRunnable(opts: QueryConstructorRunnableOptions): Runnable<any, StructuredQuery, RunnableConfig<Record<string, any>>>;
+export type QueryConstructorChainOptions = QueryConstructorRunnableOptions;
+export declare function loadQueryConstructorRunnable(opts: QueryConstructorRunnableOptions): Runnable<any, StructuredQuery, RunnableConfig<Record<string, any>>>;
 //#endregion
-export { AttributeInfo, DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, QueryConstructorChainOptions, QueryConstructorRunnableOptions, QueryTransformer, StructuredQueryOutputParser, type TraverseType, formatAttributeInfo, loadQueryConstructorRunnable };
+export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, QueryTransformer, type TraverseType };
 //# sourceMappingURL=index.d.ts.map

package/dist/chains/query_constructor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/chains/query_constructor/index.ts"],"mappings":";;;;;;;;;;;;;;cAkCa;EAEF;EACA;EACA;EAHT,YACS,cACA,cACA;;cAaL,kBAAgB,EAAA;;;;;;;;;;;;;;cAcT,oCAAoC,wCACxC,kBACP;EAEA;EAEA,kBAAkB;EAElB,YAAY;IACV,oBAAoB;IACpB,kBAAkB;;;;;;;;EAiBd,kBACJ,OACA,UACC,6BAA6B,oBAAoB,QAAQ;;;;;;;;SAoBrD,eACL,qBAAoB,cACpB,mBAAkB,aAAe;;iBASrB,oBAAoB,MAAM;;;;KA8D9B;EACV,KAAK;EACL;EACA,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,mBAAmB;;;KAIT,+BAA+B;iBAE3B,6BACd,MAAM,kCAEL,cAAc,iBAAiB,eAAe"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/chains/query_constructor/index.ts"],"mappings":";;;;;;;;;;;;;;qBAkCa;EAEF;EACA;EACA;EAHT,YACS,cACA,cACA;;cAaL,kBAAgB,EAAA;;;;;;;;;;;;;;qBAcT,oCAAoC,wCACxC,kBACP;EAEA;EAEA,kBAAkB;EAElB,YAAY;IACV,oBAAoB;IACpB,kBAAkB;;;;;;;;EAiBd,kBACJ,OACA,UACC,6BAA6B,oBAAoB,QAAQ;;;;;;;;SAoBrD,eACL,qBAAoB,cACpB,mBAAkB,aAAe;;wBASrB,oBAAoB,MAAM;;;;YA8D9B;EACV,KAAK;EACL;EACA,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,mBAAmB;;;YAIT,+BAA+B;wBAE3B,6BACd,MAAM,kCAEL,cAAc,iBAAiB,eAAe"}

package/dist/chains/query_constructor/parser.d.cts

@@ -4,13 +4,13 @@ import { Comparator, Comparison, Operation, Operator } from "@langchain/core/str
  * A type representing the possible types that can be traversed in an
  * expression.
  */
-type TraverseType = boolean | Operation | Comparison | string | number | {
+export type TraverseType = boolean | Operation | Comparison | string | number | {
   [key: string]: TraverseType;
 } | TraverseType[];
 /**
  * A class for transforming and parsing query expressions.
  */
-declare class QueryTransformer {
+export declare class QueryTransformer {
   allowedComparators: Comparator[];
   allowedOperators: Operator[];
   constructor(allowedComparators?: Comparator[], allowedOperators?: Operator[]);
@@ -37,5 +37,4 @@ declare class QueryTransformer {
   parse(expression: string): Promise<Operation | Comparison>;
 }
 //#endregion
-export { QueryTransformer, TraverseType };
 //# sourceMappingURL=parser.d.cts.map

package/dist/chains/query_constructor/parser.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.cts","names":[],"sources":["../../../src/chains/query_constructor/parser.ts"],"mappings":";;;;;;KAmBY,yBAER,YACA;GAGG,cAAc;IACjB;;;;cAKS;EAEF,oBAAoB;EACpB,kBAAkB;EAF3B,YACS,qBAAoB,cACpB,mBAAkB;;;;;;;UASnB;;;;;;;UAgCA;;;;;;;EAgEF,MAAM,qBAAqB,QAAQ,YAAY"}
+{"version":3,"file":"parser.d.cts","names":[],"sources":["../../../src/chains/query_constructor/parser.ts"],"mappings":";;;;;;YAmBY,yBAER,YACA;GAGG,cAAc;IACjB;;;;qBAKS;EAEF,oBAAoB;EACpB,kBAAkB;EAF3B,YACS,qBAAoB,cACpB,mBAAkB;;;;;;;UASnB;;;;;;;UAgCA;;;;;;;EAgEF,MAAM,qBAAqB,QAAQ,YAAY"}

package/dist/chains/query_constructor/parser.d.ts

@@ -4,13 +4,13 @@ import { Comparator, Comparison, Operation, Operator } from "@langchain/core/str
  * A type representing the possible types that can be traversed in an
  * expression.
  */
-type TraverseType = boolean | Operation | Comparison | string | number | {
+export type TraverseType = boolean | Operation | Comparison | string | number | {
   [key: string]: TraverseType;
 } | TraverseType[];
 /**
  * A class for transforming and parsing query expressions.
  */
-declare class QueryTransformer {
+export declare class QueryTransformer {
   allowedComparators: Comparator[];
   allowedOperators: Operator[];
   constructor(allowedComparators?: Comparator[], allowedOperators?: Operator[]);
@@ -37,5 +37,4 @@ declare class QueryTransformer {
   parse(expression: string): Promise<Operation | Comparison>;
 }
 //#endregion
-export { QueryTransformer, TraverseType };
 //# sourceMappingURL=parser.d.ts.map

package/dist/chains/query_constructor/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/chains/query_constructor/parser.ts"],"mappings":";;;;;;KAmBY,yBAER,YACA;GAGG,cAAc;IACjB;;;;cAKS;EAEF,oBAAoB;EACpB,kBAAkB;EAF3B,YACS,qBAAoB,cACpB,mBAAkB;;;;;;;UASnB;;;;;;;UAgCA;;;;;;;EAgEF,MAAM,qBAAqB,QAAQ,YAAY"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/chains/query_constructor/parser.ts"],"mappings":";;;;;;YAmBY,yBAER,YACA;GAGG,cAAc;IACjB;;;;qBAKS;EAEF,oBAAoB;EACpB,kBAAkB;EAF3B,YACS,qBAAoB,cACpB,mBAAkB;;;;;;;UASnB;;;;;;;UAgCA;;;;;;;EAgEF,MAAM,qBAAqB,QAAQ,YAAY"}

package/dist/chains/query_constructor/prompt.d.cts

@@ -1,20 +1,19 @@
 import { PromptTemplate } from "@langchain/core/prompts";
 //#region src/chains/query_constructor/prompt.d.ts
-declare const DEFAULT_EXAMPLES: {
+export declare const DEFAULT_EXAMPLES: {
   i: string;
   data_source: string;
   user_query: string;
   structured_request: string;
 }[];
-declare const EXAMPLE_PROMPT: PromptTemplate<{
+export declare const EXAMPLE_PROMPT: PromptTemplate<{
   data_source: any;
   i: any;
   structured_request: any;
   user_query: any;
 }, any>;
-declare const DEFAULT_SCHEMA = "<< Structured Request Schema >>\nWhen responding use a markdown code snippet with a JSON object formatted in the following schema:\n\n```json\n{{{{\n    \"query\": string \\ text string to compare to document contents\n    \"filter\": string \\ logical condition statement for filtering documents\n}}}}\n```\n\nThe query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.\n\nA logical condition statement is composed of one or more comparison and logical operation statements.\n\nA comparison statement takes the form: `comp(attr, val)`:\n- `comp` ({allowed_comparators}): comparator\n- `attr` (string):  name of attribute to apply the comparison to\n- `val` (string): is the comparison value\n\nA logical operation statement takes the form `op(statement1, statement2, ...)`:\n- `op` ({allowed_operators}): logical operator\n- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to\n\nMake sure that you only use the comparators and logical operators listed above and no others.\nMake sure that filters only refer to attributes that exist in the data source.\nMake sure that filters only use the attributed names with its function names if there are functions applied on them.\nMake sure that filters only use format `YYYY-MM-DD` when handling timestamp data typed values.\nMake sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.\nMake sure that filters are only used as needed. If there are no filters that should be applied return \"NO_FILTER\" for the filter value.";
-declare const DEFAULT_PREFIX = "Your goal is to structure the user's query to match the request schema provided below.\n\n{schema}";
-declare const DEFAULT_SUFFIX = "<< Example {i}. >>\nData Source:\n```json\n{{{{\n    \"content\": \"{content}\",\n    \"attributes\": {attributes}\n}}}}\n```\n\nUser Query:\n{{query}}\n\nStructured Request:\n";
+export declare const DEFAULT_SCHEMA = "<< Structured Request Schema >>\nWhen responding use a markdown code snippet with a JSON object formatted in the following schema:\n\n```json\n{{{{\n    \"query\": string \\ text string to compare to document contents\n    \"filter\": string \\ logical condition statement for filtering documents\n}}}}\n```\n\nThe query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.\n\nA logical condition statement is composed of one or more comparison and logical operation statements.\n\nA comparison statement takes the form: `comp(attr, val)`:\n- `comp` ({allowed_comparators}): comparator\n- `attr` (string):  name of attribute to apply the comparison to\n- `val` (string): is the comparison value\n\nA logical operation statement takes the form `op(statement1, statement2, ...)`:\n- `op` ({allowed_operators}): logical operator\n- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to\n\nMake sure that you only use the comparators and logical operators listed above and no others.\nMake sure that filters only refer to attributes that exist in the data source.\nMake sure that filters only use the attributed names with its function names if there are functions applied on them.\nMake sure that filters only use format `YYYY-MM-DD` when handling timestamp data typed values.\nMake sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.\nMake sure that filters are only used as needed. If there are no filters that should be applied return \"NO_FILTER\" for the filter value.";
+export declare const DEFAULT_PREFIX = "Your goal is to structure the user's query to match the request schema provided below.\n\n{schema}";
+export declare const DEFAULT_SUFFIX = "<< Example {i}. >>\nData Source:\n```json\n{{{{\n    \"content\": \"{content}\",\n    \"attributes\": {attributes}\n}}}}\n```\n\nUser Query:\n{{query}}\n\nStructured Request:\n";
 //#endregion
-export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT };
 //# sourceMappingURL=prompt.d.cts.map

package/dist/chains/query_constructor/prompt.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.cts","names":[],"sources":["../../../src/chains/query_constructor/prompt.ts"],"mappings":";;cA2Ca;;;;;;cA4BA,gBAAc;;;;;;cAKd;cAuCA;cAMA"}
+{"version":3,"file":"prompt.d.cts","names":[],"sources":["../../../src/chains/query_constructor/prompt.ts"],"mappings":";;qBA2Ca;;;;;;qBA4BA,gBAAc;;;;;;qBAKd;qBAuCA;qBAMA"}

package/dist/chains/query_constructor/prompt.d.ts

@@ -1,20 +1,19 @@
 import { PromptTemplate } from "@langchain/core/prompts";
 //#region src/chains/query_constructor/prompt.d.ts
-declare const DEFAULT_EXAMPLES: {
+export declare const DEFAULT_EXAMPLES: {
   i: string;
   data_source: string;
   user_query: string;
   structured_request: string;
 }[];
-declare const EXAMPLE_PROMPT: PromptTemplate<{
+export declare const EXAMPLE_PROMPT: PromptTemplate<{
   data_source: any;
   i: any;
   structured_request: any;
   user_query: any;
 }, any>;
-declare const DEFAULT_SCHEMA = "<< Structured Request Schema >>\nWhen responding use a markdown code snippet with a JSON object formatted in the following schema:\n\n```json\n{{{{\n    \"query\": string \\ text string to compare to document contents\n    \"filter\": string \\ logical condition statement for filtering documents\n}}}}\n```\n\nThe query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.\n\nA logical condition statement is composed of one or more comparison and logical operation statements.\n\nA comparison statement takes the form: `comp(attr, val)`:\n- `comp` ({allowed_comparators}): comparator\n- `attr` (string):  name of attribute to apply the comparison to\n- `val` (string): is the comparison value\n\nA logical operation statement takes the form `op(statement1, statement2, ...)`:\n- `op` ({allowed_operators}): logical operator\n- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to\n\nMake sure that you only use the comparators and logical operators listed above and no others.\nMake sure that filters only refer to attributes that exist in the data source.\nMake sure that filters only use the attributed names with its function names if there are functions applied on them.\nMake sure that filters only use format `YYYY-MM-DD` when handling timestamp data typed values.\nMake sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.\nMake sure that filters are only used as needed. If there are no filters that should be applied return \"NO_FILTER\" for the filter value.";
-declare const DEFAULT_PREFIX = "Your goal is to structure the user's query to match the request schema provided below.\n\n{schema}";
-declare const DEFAULT_SUFFIX = "<< Example {i}. >>\nData Source:\n```json\n{{{{\n    \"content\": \"{content}\",\n    \"attributes\": {attributes}\n}}}}\n```\n\nUser Query:\n{{query}}\n\nStructured Request:\n";
+export declare const DEFAULT_SCHEMA = "<< Structured Request Schema >>\nWhen responding use a markdown code snippet with a JSON object formatted in the following schema:\n\n```json\n{{{{\n    \"query\": string \\ text string to compare to document contents\n    \"filter\": string \\ logical condition statement for filtering documents\n}}}}\n```\n\nThe query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.\n\nA logical condition statement is composed of one or more comparison and logical operation statements.\n\nA comparison statement takes the form: `comp(attr, val)`:\n- `comp` ({allowed_comparators}): comparator\n- `attr` (string):  name of attribute to apply the comparison to\n- `val` (string): is the comparison value\n\nA logical operation statement takes the form `op(statement1, statement2, ...)`:\n- `op` ({allowed_operators}): logical operator\n- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to\n\nMake sure that you only use the comparators and logical operators listed above and no others.\nMake sure that filters only refer to attributes that exist in the data source.\nMake sure that filters only use the attributed names with its function names if there are functions applied on them.\nMake sure that filters only use format `YYYY-MM-DD` when handling timestamp data typed values.\nMake sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.\nMake sure that filters are only used as needed. If there are no filters that should be applied return \"NO_FILTER\" for the filter value.";
+export declare const DEFAULT_PREFIX = "Your goal is to structure the user's query to match the request schema provided below.\n\n{schema}";
+export declare const DEFAULT_SUFFIX = "<< Example {i}. >>\nData Source:\n```json\n{{{{\n    \"content\": \"{content}\",\n    \"attributes\": {attributes}\n}}}}\n```\n\nUser Query:\n{{query}}\n\nStructured Request:\n";
 //#endregion
-export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT };
 //# sourceMappingURL=prompt.d.ts.map

package/dist/chains/query_constructor/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","names":[],"sources":["../../../src/chains/query_constructor/prompt.ts"],"mappings":";;cA2Ca;;;;;;cA4BA,gBAAc;;;;;;cAKd;cAuCA;cAMA"}
+{"version":3,"file":"prompt.d.ts","names":[],"sources":["../../../src/chains/query_constructor/prompt.ts"],"mappings":";;qBA2Ca;;;;;;qBA4BA,gBAAc;;;;;;qBAKd;qBAuCA;qBAMA"}

package/dist/chains/question_answering/load.d.cts

@@ -6,18 +6,18 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
  * Represents the parameters for creating a QAChain. It can be of three
  * types: "stuff", "map_reduce", or "refine".
  */
-type QAChainParams = ({
+export type QAChainParams = ({
   type?: "stuff";
 } & StuffQAChainParams) | ({
   type?: "map_reduce";
 } & MapReduceQAChainParams) | ({
   type?: "refine";
 } & RefineQAChainParams);
-declare const loadQAChain: (llm: BaseLanguageModelInterface, params?: QAChainParams) => MapReduceDocumentsChain | RefineDocumentsChain | StuffDocumentsChain;
+export declare const loadQAChain: (llm: BaseLanguageModelInterface, params?: QAChainParams) => MapReduceDocumentsChain | RefineDocumentsChain | StuffDocumentsChain;
 /**
  * Represents the parameters for creating a StuffQAChain.
  */
-interface StuffQAChainParams {
+export interface StuffQAChainParams {
   prompt?: BasePromptTemplate;
   verbose?: boolean;
 }
@@ -28,11 +28,11 @@ interface StuffQAChainParams {
  * @param params Parameters for creating a StuffQAChain.
  * @returns A StuffQAChain instance.
  */
-declare function loadQAStuffChain(llm: BaseLanguageModelInterface, params?: StuffQAChainParams): StuffDocumentsChain;
+export declare function loadQAStuffChain(llm: BaseLanguageModelInterface, params?: StuffQAChainParams): StuffDocumentsChain;
 /**
  * Represents the parameters for creating a MapReduceQAChain.
  */
-interface MapReduceQAChainParams {
+export interface MapReduceQAChainParams {
   returnIntermediateSteps?: MapReduceDocumentsChainInput["returnIntermediateSteps"];
   combineMapPrompt?: BasePromptTemplate;
   combinePrompt?: BasePromptTemplate;
@@ -46,11 +46,11 @@ interface MapReduceQAChainParams {
  * @param params Parameters for creating a MapReduceQAChain.
  * @returns A MapReduceQAChain instance.
  */
-declare function loadQAMapReduceChain(llm: BaseLanguageModelInterface, params?: MapReduceQAChainParams): MapReduceDocumentsChain;
+export declare function loadQAMapReduceChain(llm: BaseLanguageModelInterface, params?: MapReduceQAChainParams): MapReduceDocumentsChain;
 /**
  * Represents the parameters for creating a RefineQAChain.
  */
-interface RefineQAChainParams {
+export interface RefineQAChainParams {
   questionPrompt?: BasePromptTemplate;
   refinePrompt?: BasePromptTemplate;
   refineLLM?: BaseLanguageModelInterface;
@@ -63,7 +63,6 @@ interface RefineQAChainParams {
  * @param params Parameters for creating a RefineQAChain.
  * @returns A RefineQAChain instance.
  */
-declare function loadQARefineChain(llm: BaseLanguageModelInterface, params?: RefineQAChainParams): RefineDocumentsChain;
+export declare function loadQARefineChain(llm: BaseLanguageModelInterface, params?: RefineQAChainParams): RefineDocumentsChain;
 //#endregion
-export { MapReduceQAChainParams, QAChainParams, RefineQAChainParams, StuffQAChainParams, loadQAChain, loadQAMapReduceChain, loadQARefineChain, loadQAStuffChain };
 //# sourceMappingURL=load.d.cts.map

package/dist/chains/question_answering/load.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.cts","names":[],"sources":["../../../src/chains/question_answering/load.ts"],"mappings":";;;;;;;;KAuBY;EAEN;IACE;EAEF;IACE;EAEF;IACE;cAEK,cAAW,KACjB,4BAA0B,SACvB,kBAAa,0BAAA,uBAAA;;;;UAkBN;EACf,SAAS;EACT;;;;;;;;;iBAUc,iBACd,KAAK,4BACL,SAAQ,qBAAuB;;;;UAWhB;EACf,0BAA0B;EAC1B,mBAAmB;EACnB,gBAAgB;EAChB,aAAa;EACb;;;;;;;;;iBAUc,qBACd,KAAK,4BACL,SAAQ,yBAA2B;;;;UAgCpB;EACf,iBAAiB;EACjB,eAAe;EACf,YAAY;EACZ;;;;;;;;;iBAUc,kBACd,KAAK,4BACL,SAAQ,sBAAwB"}
+{"version":3,"file":"load.d.cts","names":[],"sources":["../../../src/chains/question_answering/load.ts"],"mappings":";;;;;;;;YAuBY;EAEN;IACE;EAEF;IACE;EAEF;IACE;qBAEK,cAAW,KACjB,4BAA0B,SACvB,kBAAa,0BAAA,uBAAA;;;;iBAkBN;EACf,SAAS;EACT;;;;;;;;;wBAUc,iBACd,KAAK,4BACL,SAAQ,qBAAuB;;;;iBAWhB;EACf,0BAA0B;EAC1B,mBAAmB;EACnB,gBAAgB;EAChB,aAAa;EACb;;;;;;;;;wBAUc,qBACd,KAAK,4BACL,SAAQ,yBAA2B;;;;iBAgCpB;EACf,iBAAiB;EACjB,eAAe;EACf,YAAY;EACZ;;;;;;;;;wBAUc,kBACd,KAAK,4BACL,SAAQ,sBAAwB"}

package/dist/chains/question_answering/load.d.ts

@@ -6,18 +6,18 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
  * Represents the parameters for creating a QAChain. It can be of three
  * types: "stuff", "map_reduce", or "refine".
  */
-type QAChainParams = ({
+export type QAChainParams = ({
   type?: "stuff";
 } & StuffQAChainParams) | ({
   type?: "map_reduce";
 } & MapReduceQAChainParams) | ({
   type?: "refine";
 } & RefineQAChainParams);
-declare const loadQAChain: (llm: BaseLanguageModelInterface, params?: QAChainParams) => MapReduceDocumentsChain | RefineDocumentsChain | StuffDocumentsChain;
+export declare const loadQAChain: (llm: BaseLanguageModelInterface, params?: QAChainParams) => MapReduceDocumentsChain | RefineDocumentsChain | StuffDocumentsChain;
 /**
  * Represents the parameters for creating a StuffQAChain.
  */
-interface StuffQAChainParams {
+export interface StuffQAChainParams {
   prompt?: BasePromptTemplate;
   verbose?: boolean;
 }
@@ -28,11 +28,11 @@ interface StuffQAChainParams {
  * @param params Parameters for creating a StuffQAChain.
  * @returns A StuffQAChain instance.
  */
-declare function loadQAStuffChain(llm: BaseLanguageModelInterface, params?: StuffQAChainParams): StuffDocumentsChain;
+export declare function loadQAStuffChain(llm: BaseLanguageModelInterface, params?: StuffQAChainParams): StuffDocumentsChain;
 /**
  * Represents the parameters for creating a MapReduceQAChain.
  */
-interface MapReduceQAChainParams {
+export interface MapReduceQAChainParams {
   returnIntermediateSteps?: MapReduceDocumentsChainInput["returnIntermediateSteps"];
   combineMapPrompt?: BasePromptTemplate;
   combinePrompt?: BasePromptTemplate;
@@ -46,11 +46,11 @@ interface MapReduceQAChainParams {
  * @param params Parameters for creating a MapReduceQAChain.
  * @returns A MapReduceQAChain instance.
  */
-declare function loadQAMapReduceChain(llm: BaseLanguageModelInterface, params?: MapReduceQAChainParams): MapReduceDocumentsChain;
+export declare function loadQAMapReduceChain(llm: BaseLanguageModelInterface, params?: MapReduceQAChainParams): MapReduceDocumentsChain;
 /**
  * Represents the parameters for creating a RefineQAChain.
  */
-interface RefineQAChainParams {
+export interface RefineQAChainParams {
   questionPrompt?: BasePromptTemplate;
   refinePrompt?: BasePromptTemplate;
   refineLLM?: BaseLanguageModelInterface;
@@ -63,7 +63,6 @@ interface RefineQAChainParams {
  * @param params Parameters for creating a RefineQAChain.
  * @returns A RefineQAChain instance.
  */
-declare function loadQARefineChain(llm: BaseLanguageModelInterface, params?: RefineQAChainParams): RefineDocumentsChain;
+export declare function loadQARefineChain(llm: BaseLanguageModelInterface, params?: RefineQAChainParams): RefineDocumentsChain;
 //#endregion
-export { MapReduceQAChainParams, QAChainParams, RefineQAChainParams, StuffQAChainParams, loadQAChain, loadQAMapReduceChain, loadQARefineChain, loadQAStuffChain };
 //# sourceMappingURL=load.d.ts.map

package/dist/chains/question_answering/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","names":[],"sources":["../../../src/chains/question_answering/load.ts"],"mappings":";;;;;;;;KAuBY;EAEN;IACE;EAEF;IACE;EAEF;IACE;cAEK,cAAW,KACjB,4BAA0B,SACvB,kBAAa,0BAAA,uBAAA;;;;UAkBN;EACf,SAAS;EACT;;;;;;;;;iBAUc,iBACd,KAAK,4BACL,SAAQ,qBAAuB;;;;UAWhB;EACf,0BAA0B;EAC1B,mBAAmB;EACnB,gBAAgB;EAChB,aAAa;EACb;;;;;;;;;iBAUc,qBACd,KAAK,4BACL,SAAQ,yBAA2B;;;;UAgCpB;EACf,iBAAiB;EACjB,eAAe;EACf,YAAY;EACZ;;;;;;;;;iBAUc,kBACd,KAAK,4BACL,SAAQ,sBAAwB"}
+{"version":3,"file":"load.d.ts","names":[],"sources":["../../../src/chains/question_answering/load.ts"],"mappings":";;;;;;;;YAuBY;EAEN;IACE;EAEF;IACE;EAEF;IACE;qBAEK,cAAW,KACjB,4BAA0B,SACvB,kBAAa,0BAAA,uBAAA;;;;iBAkBN;EACf,SAAS;EACT;;;;;;;;;wBAUc,iBACd,KAAK,4BACL,SAAQ,qBAAuB;;;;iBAWhB;EACf,0BAA0B;EAC1B,mBAAmB;EACnB,gBAAgB;EAChB,aAAa;EACb;;;;;;;;;wBAUc,qBACd,KAAK,4BACL,SAAQ,yBAA2B;;;;iBAgCpB;EACf,iBAAiB;EACjB,eAAe;EACf,YAAY;EACZ;;;;;;;;;wBAUc,kBACd,KAAK,4BACL,SAAQ,sBAAwB"}

package/dist/chains/retrieval.d.cts

@@ -6,7 +6,7 @@ import { Document, DocumentInterface } from "@langchain/core/documents";
 /**
  * Parameters for the createRetrievalChain method.
  */
-type CreateRetrievalChainParams<RunOutput> = {
+export type CreateRetrievalChainParams<RunOutput> = {
   /**
    * Retriever-like object that returns list of documents. Should
    * either be a subclass of BaseRetriever or a Runnable that returns
@@ -53,7 +53,7 @@ type CreateRetrievalChainParams<RunOutput> = {
  * const response = await chain.invoke({ input: "..." });
  * ```
  */
-declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }: CreateRetrievalChainParams<RunOutput>): Promise<Runnable<{
+export declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }: CreateRetrievalChainParams<RunOutput>): Promise<Runnable<{
   input: string;
   chat_history?: BaseMessage[] | string;
 } & {
@@ -65,5 +65,4 @@ declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }
   [key: string]: unknown;
 }>>;
 //#endregion
-export { CreateRetrievalChainParams, createRetrievalChain };
 //# sourceMappingURL=retrieval.d.cts.map

package/dist/chains/retrieval.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"retrieval.d.cts","names":[],"sources":["../../src/chains/retrieval.ts"],"mappings":";;;;;;;;KAaY,2BAA2B;;;;;;;;;;;EAWrC,WACI,yBAEA,kBAAkB,qBAAqB;;;;;;;;EAS3C,kBAAkB,kBAAkB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCrC,qBAAqB,aACzC,WACA,oBACC,2BAA2B,aAAa,QACzC;EACI;EAAe,eAAe;;GAC7B;;EAED,SAAS;EAAY,QAAQ;;GAAiB"}
+{"version":3,"file":"retrieval.d.cts","names":[],"sources":["../../src/chains/retrieval.ts"],"mappings":";;;;;;;;YAaY,2BAA2B;;;;;;;;;;;EAWrC,WACI,yBAEA,kBAAkB,qBAAqB;;;;;;;;EAS3C,kBAAkB,kBAAkB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCrC,qBAAqB,aACzC,WACA,oBACC,2BAA2B,aAAa,QACzC;EACI;EAAe,eAAe;;GAC7B;;EAED,SAAS;EAAY,QAAQ;;GAAiB"}

package/dist/chains/retrieval.d.ts

@@ -6,7 +6,7 @@ import { BaseRetrieverInterface } from "@langchain/core/retrievers";
 /**
  * Parameters for the createRetrievalChain method.
  */
-type CreateRetrievalChainParams<RunOutput> = {
+export type CreateRetrievalChainParams<RunOutput> = {
   /**
    * Retriever-like object that returns list of documents. Should
    * either be a subclass of BaseRetriever or a Runnable that returns
@@ -53,7 +53,7 @@ type CreateRetrievalChainParams<RunOutput> = {
  * const response = await chain.invoke({ input: "..." });
  * ```
  */
-declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }: CreateRetrievalChainParams<RunOutput>): Promise<Runnable<{
+export declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }: CreateRetrievalChainParams<RunOutput>): Promise<Runnable<{
   input: string;
   chat_history?: BaseMessage[] | string;
 } & {
@@ -65,5 +65,4 @@ declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain }
   [key: string]: unknown;
 }>>;
 //#endregion
-export { CreateRetrievalChainParams, createRetrievalChain };
 //# sourceMappingURL=retrieval.d.ts.map

package/dist/chains/retrieval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retrieval.d.ts","names":[],"sources":["../../src/chains/retrieval.ts"],"mappings":";;;;;;;;KAaY,2BAA2B;;;;;;;;;;;EAWrC,WACI,yBAEA,kBAAkB,qBAAqB;;;;;;;;EAS3C,kBAAkB,kBAAkB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCrC,qBAAqB,aACzC,WACA,oBACC,2BAA2B,aAAa,QACzC;EACI;EAAe,eAAe;;GAC7B;;EAED,SAAS;EAAY,QAAQ;;GAAiB"}
+{"version":3,"file":"retrieval.d.ts","names":[],"sources":["../../src/chains/retrieval.ts"],"mappings":";;;;;;;;YAaY,2BAA2B;;;;;;;;;;;EAWrC,WACI,yBAEA,kBAAkB,qBAAqB;;;;;;;;EAS3C,kBAAkB,kBAAkB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCrC,qBAAqB,aACzC,WACA,oBACC,2BAA2B,aAAa,QACzC;EACI;EAAe,eAAe;;GAC7B;;EAED,SAAS;EAAY,QAAQ;;GAAiB"}

package/dist/chains/retrieval_qa.d.cts

@@ -6,11 +6,11 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { BaseRetrieverInterface } from "@langchain/core/retrievers";
 //#region src/chains/retrieval_qa.d.ts
-type LoadValues = Record<string, any>;
+export type LoadValues = Record<string, any>;
 /**
  * Interface for the input parameters of the RetrievalQAChain class.
  */
-interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
+export interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
   retriever: BaseRetrieverInterface;
   combineDocumentsChain: BaseChain;
   inputKey?: string;
@@ -48,7 +48,7 @@ interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
  * });
  * ```
  */
-declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
+export declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
   static lc_name(): string;
   inputKey: string;
   get inputKeys(): string[];
@@ -73,5 +73,4 @@ declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInpu
   static fromLLM(llm: BaseLanguageModelInterface, retriever: BaseRetrieverInterface, options?: Partial<Omit<RetrievalQAChainInput, "retriever" | "combineDocumentsChain" | "index">> & StuffQAChainParams): RetrievalQAChain;
 }
 //#endregion
-export { LoadValues, RetrievalQAChain, RetrievalQAChainInput };
 //# sourceMappingURL=retrieval_qa.d.cts.map

package/dist/chains/retrieval_qa.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"retrieval_qa.d.cts","names":[],"sources":["../../src/chains/retrieval_qa.ts"],"mappings":";;;;;;;;KAYY,aAAa;;;;UAKR,8BAA8B,KAAK;EAClD,WAAW;EACX,uBAAuB;EACvB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCW,yBACH,qBACG;SAEJ;EAIP;MAEI;MAIA;EAMJ,WAAW;EAEX,uBAAuB;EAEvB;EAEA,YAAY,QAAQ;;EAUd,MACJ,QAAQ,aACR,aAAa,6BACZ,QAAQ;EAuBX;SAIa,YACX,OAAO,2BACP,SAAS,aACR,QAAQ;EAIX,aAAa;;;;;;;;;SAYN,QACL,KAAK,4BACL,WAAW,wBACX,UAAU,QACR,KACE,2EAIF,qBACD"}
+{"version":3,"file":"retrieval_qa.d.cts","names":[],"sources":["../../src/chains/retrieval_qa.ts"],"mappings":";;;;;;;;YAYY,aAAa;;;;iBAKR,8BAA8B,KAAK;EAClD,WAAW;EACX,uBAAuB;EACvB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCW,yBACH,qBACG;SAEJ;EAIP;MAEI;MAIA;EAMJ,WAAW;EAEX,uBAAuB;EAEvB;EAEA,YAAY,QAAQ;;EAUd,MACJ,QAAQ,aACR,aAAa,6BACZ,QAAQ;EAuBX;SAIa,YACX,OAAO,2BACP,SAAS,aACR,QAAQ;EAIX,aAAa;;;;;;;;;SAYN,QACL,KAAK,4BACL,WAAW,wBACX,UAAU,QACR,KACE,2EAIF,qBACD"}

package/dist/chains/retrieval_qa.d.ts

@@ -6,11 +6,11 @@ import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BaseRetrieverInterface } from "@langchain/core/retrievers";
 //#region src/chains/retrieval_qa.d.ts
-type LoadValues = Record<string, any>;
+export type LoadValues = Record<string, any>;
 /**
  * Interface for the input parameters of the RetrievalQAChain class.
  */
-interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
+export interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
   retriever: BaseRetrieverInterface;
   combineDocumentsChain: BaseChain;
   inputKey?: string;
@@ -48,7 +48,7 @@ interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
  * });
  * ```
  */
-declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
+export declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
   static lc_name(): string;
   inputKey: string;
   get inputKeys(): string[];
@@ -73,5 +73,4 @@ declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInpu
   static fromLLM(llm: BaseLanguageModelInterface, retriever: BaseRetrieverInterface, options?: Partial<Omit<RetrievalQAChainInput, "retriever" | "combineDocumentsChain" | "index">> & StuffQAChainParams): RetrievalQAChain;
 }
 //#endregion
-export { LoadValues, RetrievalQAChain, RetrievalQAChainInput };
 //# sourceMappingURL=retrieval_qa.d.ts.map

package/dist/chains/retrieval_qa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retrieval_qa.d.ts","names":[],"sources":["../../src/chains/retrieval_qa.ts"],"mappings":";;;;;;;;KAYY,aAAa;;;;UAKR,8BAA8B,KAAK;EAClD,WAAW;EACX,uBAAuB;EACvB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCW,yBACH,qBACG;SAEJ;EAIP;MAEI;MAIA;EAMJ,WAAW;EAEX,uBAAuB;EAEvB;EAEA,YAAY,QAAQ;;EAUd,MACJ,QAAQ,aACR,aAAa,6BACZ,QAAQ;EAuBX;SAIa,YACX,OAAO,2BACP,SAAS,aACR,QAAQ;EAIX,aAAa;;;;;;;;;SAYN,QACL,KAAK,4BACL,WAAW,wBACX,UAAU,QACR,KACE,2EAIF,qBACD"}
+{"version":3,"file":"retrieval_qa.d.ts","names":[],"sources":["../../src/chains/retrieval_qa.ts"],"mappings":";;;;;;;;YAYY,aAAa;;;;iBAKR,8BAA8B,KAAK;EAClD,WAAW;EACX,uBAAuB;EACvB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCW,yBACH,qBACG;SAEJ;EAIP;MAEI;MAIA;EAMJ,WAAW;EAEX,uBAAuB;EAEvB;EAEA,YAAY,QAAQ;;EAUd,MACJ,QAAQ,aACR,aAAa,6BACZ,QAAQ;EAuBX;SAIa,YACX,OAAO,2BACP,SAAS,aACR,QAAQ;EAIX,aAAa;;;;;;;;;SAYN,QACL,KAAK,4BACL,WAAW,wBACX,UAAU,QACR,KACE,2EAIF,qBACD"}

package/dist/chains/router/llm_router.d.cts

@@ -10,7 +10,7 @@ import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
  * A type that represents the output schema of a router chain. It defines
  * the structure of the output data returned by the router chain.
  */
-type RouterOutputSchema = {
+export type RouterOutputSchema = {
   destination: string;
   next_inputs: {
     [key: string]: string;
@@ -20,7 +20,7 @@ type RouterOutputSchema = {
  * An interface that extends the default ChainInputs interface and adds an
  * additional "llmChain" property.
  */
-interface LLMRouterChainInput extends ChainInputs {
+export interface LLMRouterChainInput extends ChainInputs {
   llmChain: LLMChain<RouterOutputSchema>;
 }
 /**
@@ -29,7 +29,7 @@ interface LLMRouterChainInput extends ChainInputs {
  * interface. It provides additional functionality specific to LLMs and
  * routing based on LLM predictions.
  */
-declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput {
+export declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput {
   llmChain: LLMChain<RouterOutputSchema>;
   constructor(fields: LLMRouterChainInput);
   get inputKeys(): string[];
@@ -48,5 +48,4 @@ declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput
   static fromLLM(llm: BaseLanguageModelInterface, prompt: BasePromptTemplate, options?: Omit<LLMRouterChainInput, "llmChain">): LLMRouterChain;
 }
 //#endregion
-export { LLMRouterChain, LLMRouterChainInput, RouterOutputSchema };
 //# sourceMappingURL=llm_router.d.cts.map

package/dist/chains/router/llm_router.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"llm_router.d.cts","names":[],"sources":["../../../src/chains/router/llm_router.ts"],"mappings":";;;;;;;;;;;;KAYY;EACV;EACA;KAAgB;;;;;;;UAOD,4BAA4B;EAC3C,UAAU,SAAS;;;;;;;;cASR,uBAAuB,uBAAuB;EACzD,UAAU,SAAS;EAEnB,YAAY,QAAQ;MAKhB;EAIE,MACJ,QAAQ,aACR,aAAa,yCACZ,QAAQ;EAIX;;;;;;;;;;;SAcO,QACL,KAAK,4BACL,QAAQ,oBACR,UAAU,KAAK,mCAAgC"}
+{"version":3,"file":"llm_router.d.cts","names":[],"sources":["../../../src/chains/router/llm_router.ts"],"mappings":";;;;;;;;;;;;YAYY;EACV;EACA;KAAgB;;;;;;;iBAOD,4BAA4B;EAC3C,UAAU,SAAS;;;;;;;;qBASR,uBAAuB,uBAAuB;EACzD,UAAU,SAAS;EAEnB,YAAY,QAAQ;MAKhB;EAIE,MACJ,QAAQ,aACR,aAAa,yCACZ,QAAQ;EAIX;;;;;;;;;;;SAcO,QACL,KAAK,4BACL,QAAQ,oBACR,UAAU,KAAK,mCAAgC"}

package/dist/chains/router/llm_router.d.ts

@@ -10,7 +10,7 @@ import { ChainValues } from "@langchain/core/utils/types";
  * A type that represents the output schema of a router chain. It defines
  * the structure of the output data returned by the router chain.
  */
-type RouterOutputSchema = {
+export type RouterOutputSchema = {
   destination: string;
   next_inputs: {
     [key: string]: string;
@@ -20,7 +20,7 @@ type RouterOutputSchema = {
  * An interface that extends the default ChainInputs interface and adds an
  * additional "llmChain" property.
  */
-interface LLMRouterChainInput extends ChainInputs {
+export interface LLMRouterChainInput extends ChainInputs {
   llmChain: LLMChain<RouterOutputSchema>;
 }
 /**
@@ -29,7 +29,7 @@ interface LLMRouterChainInput extends ChainInputs {
  * interface. It provides additional functionality specific to LLMs and
  * routing based on LLM predictions.
  */
-declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput {
+export declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput {
   llmChain: LLMChain<RouterOutputSchema>;
   constructor(fields: LLMRouterChainInput);
   get inputKeys(): string[];
@@ -48,5 +48,4 @@ declare class LLMRouterChain extends RouterChain implements LLMRouterChainInput
   static fromLLM(llm: BaseLanguageModelInterface, prompt: BasePromptTemplate, options?: Omit<LLMRouterChainInput, "llmChain">): LLMRouterChain;
 }
 //#endregion
-export { LLMRouterChain, LLMRouterChainInput, RouterOutputSchema };
 //# sourceMappingURL=llm_router.d.ts.map

package/dist/chains/router/llm_router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llm_router.d.ts","names":[],"sources":["../../../src/chains/router/llm_router.ts"],"mappings":";;;;;;;;;;;;KAYY;EACV;EACA;KAAgB;;;;;;;UAOD,4BAA4B;EAC3C,UAAU,SAAS;;;;;;;;cASR,uBAAuB,uBAAuB;EACzD,UAAU,SAAS;EAEnB,YAAY,QAAQ;MAKhB;EAIE,MACJ,QAAQ,aACR,aAAa,yCACZ,QAAQ;EAIX;;;;;;;;;;;SAcO,QACL,KAAK,4BACL,QAAQ,oBACR,UAAU,KAAK,mCAAgC"}
+{"version":3,"file":"llm_router.d.ts","names":[],"sources":["../../../src/chains/router/llm_router.ts"],"mappings":";;;;;;;;;;;;YAYY;EACV;EACA;KAAgB;;;;;;;iBAOD,4BAA4B;EAC3C,UAAU,SAAS;;;;;;;;qBASR,uBAAuB,uBAAuB;EACzD,UAAU,SAAS;EAEnB,YAAY,QAAQ;MAKhB;EAIE,MACJ,QAAQ,aACR,aAAa,yCACZ,QAAQ;EAIX;;;;;;;;;;;SAcO,QACL,KAAK,4BACL,QAAQ,oBACR,UAAU,KAAK,mCAAgC"}

package/dist/chains/router/multi_prompt.d.cts

@@ -31,7 +31,7 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
  * });
  * ```
  */
-declare class MultiPromptChain extends MultiRouteChain {
+export declare class MultiPromptChain extends MultiRouteChain {
   /**
    * @deprecated Use `fromLLMAndPrompts` instead
    */
@@ -62,5 +62,4 @@ declare class MultiPromptChain extends MultiRouteChain {
   _chainType(): string;
 }
 //#endregion
-export { MultiPromptChain };
 //# sourceMappingURL=multi_prompt.d.cts.map