@langchain/core 1.2.14 → 1.2.16

package/dist/documents/transformers.d.cts

@@ -12,7 +12,7 @@ import { Runnable } from "../runnables/base.cjs";
  * One example of this is a text splitter that splits a large document into
  * many smaller documents.
  */
-declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {
+export declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {
   lc_namespace: string[];
   /**
    * Transform a list of documents.
@@ -33,10 +33,9 @@ declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterfac
  * Class for document transformers that return exactly one transformed document
  * for each input document.
  */
-declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {
+export declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {
   transformDocuments(documents: DocumentInterface[]): Promise<DocumentInterface[]>;
   abstract _transformDocument(document: DocumentInterface): Promise<DocumentInterface>;
 }
 //#endregion
-export { BaseDocumentTransformer, MappingDocumentTransformer };
 //# sourceMappingURL=transformers.d.cts.map

package/dist/documents/transformers.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.cts","names":[],"sources":["../../src/documents/transformers.ts"],"mappings":";;;;;;;;;;;;;;uBAcsB,wBACpB,iBAAiB,sBAAsB,qBACvC,kBAAkB,sBAAsB,6BAChC,SAAS,UAAU;EAC3B;;;;;;WAOS,mBAAmB,WAAW,WAAW,QAAQ;;;;;;;;EAS1D,OAAO,OAAO,UAAU,WAAW,qBAAqB,QAAQ;;;;;;uBAS5C,mCAAmC;EACjD,mBACJ,WAAW,sBACV,QAAQ;WASF,mBACP,UAAU,oBACT,QAAQ"}
+{"version":3,"file":"transformers.d.cts","names":[],"sources":["../../src/documents/transformers.ts"],"mappings":";;;;;;;;;;;;;;8BAcsB,wBACpB,iBAAiB,sBAAsB,qBACvC,kBAAkB,sBAAsB,6BAChC,SAAS,UAAU;EAC3B;;;;;;WAOS,mBAAmB,WAAW,WAAW,QAAQ;;;;;;;;EAS1D,OAAO,OAAO,UAAU,WAAW,qBAAqB,QAAQ;;;;;;8BAS5C,mCAAmC;EACjD,mBACJ,WAAW,sBACV,QAAQ;WASF,mBACP,UAAU,oBACT,QAAQ"}

package/dist/documents/transformers.d.ts

@@ -12,7 +12,7 @@ import { Runnable } from "../runnables/base.js";
  * One example of this is a text splitter that splits a large document into
  * many smaller documents.
  */
-declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {
+export declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {
   lc_namespace: string[];
   /**
    * Transform a list of documents.
@@ -33,10 +33,9 @@ declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterfac
  * Class for document transformers that return exactly one transformed document
  * for each input document.
  */
-declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {
+export declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {
   transformDocuments(documents: DocumentInterface[]): Promise<DocumentInterface[]>;
   abstract _transformDocument(document: DocumentInterface): Promise<DocumentInterface>;
 }
 //#endregion
-export { BaseDocumentTransformer, MappingDocumentTransformer };
 //# sourceMappingURL=transformers.d.ts.map

package/dist/documents/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/documents/transformers.ts"],"mappings":";;;;;;;;;;;;;;uBAcsB,wBACpB,iBAAiB,sBAAsB,qBACvC,kBAAkB,sBAAsB,6BAChC,SAAS,UAAU;EAC3B;;;;;;WAOS,mBAAmB,WAAW,WAAW,QAAQ;;;;;;;;EAS1D,OAAO,OAAO,UAAU,WAAW,qBAAqB,QAAQ;;;;;;uBAS5C,mCAAmC;EACjD,mBACJ,WAAW,sBACV,QAAQ;WASF,mBACP,UAAU,oBACT,QAAQ"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/documents/transformers.ts"],"mappings":";;;;;;;;;;;;;;8BAcsB,wBACpB,iBAAiB,sBAAsB,qBACvC,kBAAkB,sBAAsB,6BAChC,SAAS,UAAU;EAC3B;;;;;;WAOS,mBAAmB,WAAW,WAAW,QAAQ;;;;;;;;EAS1D,OAAO,OAAO,UAAU,WAAW,qBAAqB,QAAQ;;;;;;8BAS5C,mCAAmC;EACjD,mBACJ,WAAW,sBACV,QAAQ;WASF,mBACP,UAAU,oBACT,QAAQ"}

package/dist/embeddings.d.cts

@@ -4,8 +4,8 @@ import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.cjs";
  * The parameters required to initialize an instance of the Embeddings
  * class.
  */
-type EmbeddingsParams = AsyncCallerParams;
-interface EmbeddingsInterface<TOutput = number[]> {
+export type EmbeddingsParams = AsyncCallerParams;
+export interface EmbeddingsInterface<TOutput = number[]> {
   /**
    * An abstract method that takes an array of documents as input and
    * returns a promise that resolves to an array of vectors for each
@@ -26,7 +26,7 @@ interface EmbeddingsInterface<TOutput = number[]> {
  * An abstract class that provides methods for embedding documents and
  * queries using LangChain.
  */
-declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {
+export declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {
   /**
    * The async caller should be used by subclasses to make any async calls,
    * which will thus benefit from the concurrency and retry logic.
@@ -50,5 +50,4 @@ declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInter
   abstract embedQuery(document: string): Promise<TOutput>;
 }
 //#endregion
-export { Embeddings, EmbeddingsInterface, EmbeddingsParams };
 //# sourceMappingURL=embeddings.d.cts.map

package/dist/embeddings.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings.d.cts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;KAMY,mBAAmB;UAEd,oBAAoB;;;;;;;;EAQnC,eAAe,sBAAsB,QAAQ;;;;;;;EAQ7C,WAAW,mBAAmB,QAAQ;;;;;;uBAOlB,WACpB,+BACW,oBAAoB;;;;;EAK/B,QAAQ;EAER,YAAY,QAAQ;;;;;;;;WAWX,eAAe,sBAAsB,QAAQ;;;;;;;WAQ7C,WAAW,mBAAmB,QAAQ"}
+{"version":3,"file":"embeddings.d.cts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;YAMY,mBAAmB;iBAEd,oBAAoB;;;;;;;;EAQnC,eAAe,sBAAsB,QAAQ;;;;;;;EAQ7C,WAAW,mBAAmB,QAAQ;;;;;;8BAOlB,WACpB,+BACW,oBAAoB;;;;;EAK/B,QAAQ;EAER,YAAY,QAAQ;;;;;;;;WAWX,eAAe,sBAAsB,QAAQ;;;;;;;WAQ7C,WAAW,mBAAmB,QAAQ"}

package/dist/embeddings.d.ts

@@ -4,8 +4,8 @@ import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.js";
  * The parameters required to initialize an instance of the Embeddings
  * class.
  */
-type EmbeddingsParams = AsyncCallerParams;
-interface EmbeddingsInterface<TOutput = number[]> {
+export type EmbeddingsParams = AsyncCallerParams;
+export interface EmbeddingsInterface<TOutput = number[]> {
   /**
    * An abstract method that takes an array of documents as input and
    * returns a promise that resolves to an array of vectors for each
@@ -26,7 +26,7 @@ interface EmbeddingsInterface<TOutput = number[]> {
  * An abstract class that provides methods for embedding documents and
  * queries using LangChain.
  */
-declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {
+export declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {
   /**
    * The async caller should be used by subclasses to make any async calls,
    * which will thus benefit from the concurrency and retry logic.
@@ -50,5 +50,4 @@ declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInter
   abstract embedQuery(document: string): Promise<TOutput>;
 }
 //#endregion
-export { Embeddings, EmbeddingsInterface, EmbeddingsParams };
 //# sourceMappingURL=embeddings.d.ts.map

package/dist/embeddings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings.d.ts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;KAMY,mBAAmB;UAEd,oBAAoB;;;;;;;;EAQnC,eAAe,sBAAsB,QAAQ;;;;;;;EAQ7C,WAAW,mBAAmB,QAAQ;;;;;;uBAOlB,WACpB,+BACW,oBAAoB;;;;;EAK/B,QAAQ;EAER,YAAY,QAAQ;;;;;;;;WAWX,eAAe,sBAAsB,QAAQ;;;;;;;WAQ7C,WAAW,mBAAmB,QAAQ"}
+{"version":3,"file":"embeddings.d.ts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;YAMY,mBAAmB;iBAEd,oBAAoB;;;;;;;;EAQnC,eAAe,sBAAsB,QAAQ;;;;;;;EAQ7C,WAAW,mBAAmB,QAAQ;;;;;;8BAOlB,WACpB,+BACW,oBAAoB;;;;;EAK/B,QAAQ;EAER,YAAY,QAAQ;;;;;;;;WAWX,eAAe,sBAAsB,QAAQ;;;;;;;WAQ7C,WAAW,mBAAmB,QAAQ"}

package/dist/errors/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["baseNs"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport type { AIMessageChunk } from \"../messages/ai.js\";\nimport { ns as baseNs } from \"../utils/namespace.js\";\n\nexport type LangChainErrorCodes =\n  | \"CONTEXT_OVERFLOW\"\n  | \"INVALID_PROMPT_INPUT\"\n  | \"INVALID_TOOL_RESULTS\"\n  | \"MESSAGE_COERCION_FAILURE\"\n  | \"MODEL_AUTHENTICATION\"\n  | \"MODEL_NOT_FOUND\"\n  | \"MODEL_RATE_LIMIT\"\n  | \"OUTPUT_PARSING_FAILURE\"\n  | \"MODEL_ABORTED\";\n\n/** @deprecated Subclass LangChainError instead */\nexport function addLangChainErrorFields(\n  error: any,\n  lc_error_code: LangChainErrorCodes\n) {\n  (error as any).lc_error_code = lc_error_code;\n  error.message = `${error.message}\\n\\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langchain/errors/${lc_error_code}/\\n`;\n  return error;\n}\n\n/** The error namespace for all LangChain errors */\nexport const ns = baseNs.sub(\"error\");\n\n/** Registered globally so duplicate copies of core in one dependency tree agree. */\nconst retryableSymbol = Symbol.for(\"langchain.errors.retryable\");\n\n/**\n * Mark an error as safe or unsafe to retry.\n *\n * Sets a non-enumerable symbol on the error itself, leaving its class and\n * shape untouched, so it is safe to apply to a provider SDK's own error.\n *\n * @param error - The error to mark. Non-objects are returned untouched.\n * @param retryable - `true` if retrying may succeed.\n * @returns The same error instance, for chaining.\n */\nexport function stampRetryable<T>(error: T, retryable: boolean): T {\n  if (typeof error !== \"object\" || error === null) {\n    return error;\n  }\n  try {\n    Object.defineProperty(error, retryableSymbol, {\n      value: retryable,\n      configurable: true,\n    });\n  } catch {\n    // Frozen or sealed error object; leave it unmarked rather than throwing.\n  }\n  return error;\n}\n\n/**\n * Read an error's retryability mark.\n *\n * @returns `true`/`false` when marked, `undefined` when unclassified —\n *   supply your own default, e.g. `getRetryable(error) ?? true`.\n */\nexport function getRetryable(error: unknown): boolean | undefined {\n  if (typeof error !== \"object\" || error === null) {\n    return undefined;\n  }\n  return Object.getOwnPropertyDescriptor(error, retryableSymbol)?.value as\n    | boolean\n    | undefined;\n}\n\n/**\n * Base error class for all LangChain errors.\n *\n * All LangChain error classes should extend this class (directly or\n * indirectly). Use `LangChainError.isInstance(obj)` to check if an\n * object is any LangChain error.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(\"hello\");\n * } catch (error) {\n *   if (LangChainError.isInstance(error)) {\n *     console.log(\"Got a LangChain error:\", error.message);\n *   }\n * }\n * ```\n */\nexport class LangChainError extends ns.brand(Error) {\n  readonly name: string = \"LangChainError\";\n\n  constructor(message?: string) {\n    super(message);\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error class representing an aborted model operation in LangChain.\n *\n * This error is thrown when a model operation (such as invocation, streaming, or batching)\n * is cancelled before it completes, commonly due to a user-initiated abort signal\n * (e.g., via an AbortController) or an upstream cancellation event.\n *\n * The ModelAbortError provides access to any partial output the model may have produced\n * before the operation was interrupted, which can be useful for resuming work, debugging,\n * or presenting incomplete results to users.\n *\n * @remarks\n * - The `partialOutput` field includes message content that was generated prior to the abort,\n *   such as a partial AIMessageChunk.\n * - This error extends the {@link LangChainError} base class with the marker `\"model-abort\"`.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(input, { signal: abortController.signal });\n * } catch (err) {\n *   if (ModelAbortError.isInstance(err)) {\n *     // Handle user cancellation, check err.partialOutput if needed\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ModelAbortError extends ns.brand(LangChainError, \"model-abort\") {\n  readonly name = \"ModelAbortError\";\n\n  /**\n   * The partial message output that was produced before the operation was aborted.\n   * This is typically an AIMessageChunk, or could be undefined if no output was available.\n   */\n  readonly partialOutput?: AIMessageChunk;\n\n  /**\n   * Constructs a new ModelAbortError instance.\n   *\n   * @param message - A human-readable message describing the abort event.\n   * @param partialOutput - Any partial model output generated before the abort (optional).\n   */\n  constructor(message: string, partialOutput?: AIMessageChunk) {\n    super(message);\n    this.partialOutput = partialOutput;\n    // Retrying would mean ignoring the caller's explicit abort signal.\n    stampRetryable(this, false);\n  }\n}\n\n/**\n * Error class representing a context window overflow in a language model operation.\n *\n * This error is thrown when the combined input to a language model (such as prompt tokens,\n * historical messages, and/or instructions) exceeds the maximum context window or token limit\n * that the model can process in a single request. Most models have defined upper limits for the number of\n * tokens or characters allowed in a context, and exceeding this limit will prevent\n * the operation from proceeding.\n *\n * The {@link ContextOverflowError} extends the {@link LangChainError} base class with\n * the marker `\"context-overflow\"`.\n *\n * @remarks\n * - Use this error to programmatically identify cases where a user request, prompt, or input\n *   sequence is too long to be handled by the target model.\n * - Model providers and framework integrations should throw this error if they detect\n *   a request cannot be processed due to its size.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(veryLongInput);\n * } catch (err) {\n *   if (ContextOverflowError.isInstance(err)) {\n *     // Handle overflow, e.g., prompt user to shorten input or truncate text\n *     console.warn(\"Model context overflow:\", err.message);\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ContextOverflowError extends ns.brand(\n  LangChainError,\n  \"context-overflow\"\n) {\n  readonly name = \"ContextOverflowError\";\n\n  /**\n   * The underlying error that caused this {@link ContextOverflowError}, if any.\n   *\n   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.\n   * It allows error handlers to access or inspect the original error that led to the context overflow.\n   */\n  cause?: Error;\n\n  constructor(message?: string) {\n    super(message ?? \"Input exceeded the model's context window.\");\n    // The same oversized input fails identically; it needs trimming, not another attempt.\n    stampRetryable(this, false);\n  }\n\n  /**\n   * Creates a new {@link ContextOverflowError} instance from an existing error.\n   *\n   * This static utility copies the message from the provided error and\n   * attaches the original error as the {@link ContextOverflowError.cause} property,\n   * enabling error handlers to inspect or propagate the original failure.\n   *\n   * @param obj - The original error object causing the context overflow.\n   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   await model.invoke(input);\n   * } catch (err) {\n   *   throw ContextOverflowError.fromError(err);\n   * }\n   * ```\n   */\n  static fromError(obj: Error): ContextOverflowError {\n    const error = new ContextOverflowError(obj.message);\n    error.cause = obj;\n    return error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,wBACd,OACA,eACA;CACA,MAAe,gBAAgB;CAC/B,MAAM,UAAU,GAAG,MAAM,QAAQ,sFAAsF,cAAc;CACrI,OAAO;AACT;;AAGA,MAAa,KAAKA,kBAAAA,GAAO,IAAI,OAAO;;AAGpC,MAAM,kBAAkB,OAAO,IAAI,4BAA4B;;;;;;;;;;;AAY/D,SAAgB,eAAkB,OAAU,WAAuB;CACjE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAET,IAAI;EACF,OAAO,eAAe,OAAO,iBAAiB;GAC5C,OAAO;GACP,cAAc;EAChB,CAAC;CACH,QAAQ,CAER;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAa,OAAqC;CAChE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC;CAEF,OAAO,OAAO,yBAAyB,OAAO,eAAe,CAAC,EAAE;AAGlE;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,iBAAb,cAAoC,GAAG,MAAM,KAAK,CAAC,CAAC;CAClD,OAAwB;CAExB,YAAY,SAAkB;EAC5B,MAAM,OAAO;EACb,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,WAAW;CAElD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAb,cAAqC,GAAG,MAAM,gBAAgB,aAAa,CAAC,CAAC;CAC3E,OAAgB;;;;;CAMhB;;;;;;;CAQA,YAAY,SAAiB,eAAgC;EAC3D,MAAM,OAAO;EACb,KAAK,gBAAgB;EAErB,eAAe,MAAM,KAAK;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,uBAAb,MAAa,6BAA6B,GAAG,MAC3C,gBACA,kBACF,CAAC,CAAC;CACA,OAAgB;;;;;;;CAQhB;CAEA,YAAY,SAAkB;EAC5B,MAAM,WAAW,4CAA4C;EAE7D,eAAe,MAAM,KAAK;CAC5B;;;;;;;;;;;;;;;;;;;;CAqBA,OAAO,UAAU,KAAkC;EACjD,MAAM,QAAQ,IAAI,qBAAqB,IAAI,OAAO;EAClD,MAAM,QAAQ;EACd,OAAO;CACT;AACF"}
+{"version":3,"file":"index.cjs","names":["baseNs"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport type { AIMessageChunk } from \"../messages/ai.js\";\nimport { ns as baseNs } from \"../utils/namespace.js\";\n\nexport type { BrandedClass } from \"../utils/namespace.js\";\n\nexport type LangChainErrorCodes =\n  | \"CONTEXT_OVERFLOW\"\n  | \"INVALID_PROMPT_INPUT\"\n  | \"INVALID_TOOL_RESULTS\"\n  | \"MESSAGE_COERCION_FAILURE\"\n  | \"MODEL_AUTHENTICATION\"\n  | \"MODEL_NOT_FOUND\"\n  | \"MODEL_RATE_LIMIT\"\n  | \"OUTPUT_PARSING_FAILURE\"\n  | \"MODEL_ABORTED\";\n\n/** @deprecated Subclass LangChainError instead */\nexport function addLangChainErrorFields(\n  error: any,\n  lc_error_code: LangChainErrorCodes\n) {\n  (error as any).lc_error_code = lc_error_code;\n  error.message = `${error.message}\\n\\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langchain/errors/${lc_error_code}/\\n`;\n  return error;\n}\n\n/** The error namespace for all LangChain errors */\nexport const ns = baseNs.sub(\"error\");\n\n/** Registered globally so duplicate copies of core in one dependency tree agree. */\nconst retryableSymbol = Symbol.for(\"langchain.errors.retryable\");\n\n/**\n * Mark an error as safe or unsafe to retry.\n *\n * Sets a non-enumerable symbol on the error itself, leaving its class and\n * shape untouched, so it is safe to apply to a provider SDK's own error.\n *\n * @param error - The error to mark. Non-objects are returned untouched.\n * @param retryable - `true` if retrying may succeed.\n * @returns The same error instance, for chaining.\n */\nexport function stampRetryable<T>(error: T, retryable: boolean): T {\n  if (typeof error !== \"object\" || error === null) {\n    return error;\n  }\n  try {\n    Object.defineProperty(error, retryableSymbol, {\n      value: retryable,\n      configurable: true,\n    });\n  } catch {\n    // Frozen or sealed error object; leave it unmarked rather than throwing.\n  }\n  return error;\n}\n\n/**\n * Read an error's retryability mark.\n *\n * @returns `true`/`false` when marked, `undefined` when unclassified —\n *   supply your own default, e.g. `getRetryable(error) ?? true`.\n */\nexport function getRetryable(error: unknown): boolean | undefined {\n  if (typeof error !== \"object\" || error === null) {\n    return undefined;\n  }\n  return Object.getOwnPropertyDescriptor(error, retryableSymbol)?.value as\n    | boolean\n    | undefined;\n}\n\n/**\n * Base error class for all LangChain errors.\n *\n * All LangChain error classes should extend this class (directly or\n * indirectly). Use `LangChainError.isInstance(obj)` to check if an\n * object is any LangChain error.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(\"hello\");\n * } catch (error) {\n *   if (LangChainError.isInstance(error)) {\n *     console.log(\"Got a LangChain error:\", error.message);\n *   }\n * }\n * ```\n */\nexport class LangChainError extends ns.brand(Error) {\n  readonly name: string = \"LangChainError\";\n\n  constructor(message?: string) {\n    super(message);\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error class representing an aborted model operation in LangChain.\n *\n * This error is thrown when a model operation (such as invocation, streaming, or batching)\n * is cancelled before it completes, commonly due to a user-initiated abort signal\n * (e.g., via an AbortController) or an upstream cancellation event.\n *\n * The ModelAbortError provides access to any partial output the model may have produced\n * before the operation was interrupted, which can be useful for resuming work, debugging,\n * or presenting incomplete results to users.\n *\n * @remarks\n * - The `partialOutput` field includes message content that was generated prior to the abort,\n *   such as a partial AIMessageChunk.\n * - This error extends the {@link LangChainError} base class with the marker `\"model-abort\"`.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(input, { signal: abortController.signal });\n * } catch (err) {\n *   if (ModelAbortError.isInstance(err)) {\n *     // Handle user cancellation, check err.partialOutput if needed\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ModelAbortError extends ns.brand(LangChainError, \"model-abort\") {\n  readonly name = \"ModelAbortError\";\n\n  /**\n   * The partial message output that was produced before the operation was aborted.\n   * This is typically an AIMessageChunk, or could be undefined if no output was available.\n   */\n  readonly partialOutput?: AIMessageChunk;\n\n  /**\n   * Constructs a new ModelAbortError instance.\n   *\n   * @param message - A human-readable message describing the abort event.\n   * @param partialOutput - Any partial model output generated before the abort (optional).\n   */\n  constructor(message: string, partialOutput?: AIMessageChunk) {\n    super(message);\n    this.partialOutput = partialOutput;\n    // Retrying would mean ignoring the caller's explicit abort signal.\n    stampRetryable(this, false);\n  }\n}\n\n/**\n * Error class representing a context window overflow in a language model operation.\n *\n * This error is thrown when the combined input to a language model (such as prompt tokens,\n * historical messages, and/or instructions) exceeds the maximum context window or token limit\n * that the model can process in a single request. Most models have defined upper limits for the number of\n * tokens or characters allowed in a context, and exceeding this limit will prevent\n * the operation from proceeding.\n *\n * The {@link ContextOverflowError} extends the {@link LangChainError} base class with\n * the marker `\"context-overflow\"`.\n *\n * @remarks\n * - Use this error to programmatically identify cases where a user request, prompt, or input\n *   sequence is too long to be handled by the target model.\n * - Model providers and framework integrations should throw this error if they detect\n *   a request cannot be processed due to its size.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(veryLongInput);\n * } catch (err) {\n *   if (ContextOverflowError.isInstance(err)) {\n *     // Handle overflow, e.g., prompt user to shorten input or truncate text\n *     console.warn(\"Model context overflow:\", err.message);\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ContextOverflowError extends ns.brand(\n  LangChainError,\n  \"context-overflow\"\n) {\n  readonly name = \"ContextOverflowError\";\n\n  /**\n   * The underlying error that caused this {@link ContextOverflowError}, if any.\n   *\n   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.\n   * It allows error handlers to access or inspect the original error that led to the context overflow.\n   */\n  cause?: Error;\n\n  constructor(message?: string) {\n    super(message ?? \"Input exceeded the model's context window.\");\n    // The same oversized input fails identically; it needs trimming, not another attempt.\n    stampRetryable(this, false);\n  }\n\n  /**\n   * Creates a new {@link ContextOverflowError} instance from an existing error.\n   *\n   * This static utility copies the message from the provided error and\n   * attaches the original error as the {@link ContextOverflowError.cause} property,\n   * enabling error handlers to inspect or propagate the original failure.\n   *\n   * @param obj - The original error object causing the context overflow.\n   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   await model.invoke(input);\n   * } catch (err) {\n   *   throw ContextOverflowError.fromError(err);\n   * }\n   * ```\n   */\n  static fromError(obj: Error): ContextOverflowError {\n    const error = new ContextOverflowError(obj.message);\n    error.cause = obj;\n    return error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAmBA,SAAgB,wBACd,OACA,eACA;CACA,MAAe,gBAAgB;CAC/B,MAAM,UAAU,GAAG,MAAM,QAAQ,sFAAsF,cAAc;CACrI,OAAO;AACT;;AAGA,MAAa,KAAKA,kBAAAA,GAAO,IAAI,OAAO;;AAGpC,MAAM,kBAAkB,OAAO,IAAI,4BAA4B;;;;;;;;;;;AAY/D,SAAgB,eAAkB,OAAU,WAAuB;CACjE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAET,IAAI;EACF,OAAO,eAAe,OAAO,iBAAiB;GAC5C,OAAO;GACP,cAAc;EAChB,CAAC;CACH,QAAQ,CAER;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAa,OAAqC;CAChE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC;CAEF,OAAO,OAAO,yBAAyB,OAAO,eAAe,CAAC,EAAE;AAGlE;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,iBAAb,cAAoC,GAAG,MAAM,KAAK,CAAC,CAAC;CAClD,OAAwB;CAExB,YAAY,SAAkB;EAC5B,MAAM,OAAO;EACb,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,WAAW;CAElD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAb,cAAqC,GAAG,MAAM,gBAAgB,aAAa,CAAC,CAAC;CAC3E,OAAgB;;;;;CAMhB;;;;;;;CAQA,YAAY,SAAiB,eAAgC;EAC3D,MAAM,OAAO;EACb,KAAK,gBAAgB;EAErB,eAAe,MAAM,KAAK;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,uBAAb,MAAa,6BAA6B,GAAG,MAC3C,gBACA,kBACF,CAAC,CAAC;CACA,OAAgB;;;;;;;CAQhB;CAEA,YAAY,SAAkB;EAC5B,MAAM,WAAW,4CAA4C;EAE7D,eAAe,MAAM,KAAK;CAC5B;;;;;;;;;;;;;;;;;;;;CAqBA,OAAO,UAAU,KAAkC;EACjD,MAAM,QAAQ,IAAI,qBAAqB,IAAI,OAAO;EAClD,MAAM,QAAQ;EACd,OAAO;CACT;AACF"}

package/dist/errors/index.d.cts

@@ -1,11 +1,11 @@
 import { AIMessageChunk } from "../messages/ai.cjs";
-import { Namespace } from "../utils/namespace.cjs";
+import { BrandedClass, Namespace } from "../utils/namespace.cjs";
 //#region src/errors/index.d.ts
-type LangChainErrorCodes = "CONTEXT_OVERFLOW" | "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
+export type LangChainErrorCodes = "CONTEXT_OVERFLOW" | "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
 /** @deprecated Subclass LangChainError instead */
-declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;
+export declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;
 /** The error namespace for all LangChain errors */
-declare const ns: Namespace;
+export declare const ns: Namespace;
 /**
  * Mark an error as safe or unsafe to retry.
  *
@@ -16,17 +16,15 @@ declare const ns: Namespace;
  * @param retryable - `true` if retrying may succeed.
  * @returns The same error instance, for chaining.
  */
-declare function stampRetryable<T>(error: T, retryable: boolean): T;
+export declare function stampRetryable<T>(error: T, retryable: boolean): T;
 /**
  * Read an error's retryability mark.
  *
  * @returns `true`/`false` when marked, `undefined` when unclassified —
  *   supply your own default, e.g. `getRetryable(error) ?? true`.
  */
-declare function getRetryable(error: unknown): boolean | undefined;
-declare const LangChainError_base: ErrorConstructor & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+export declare function getRetryable(error: unknown): boolean | undefined;
+declare const LangChainError_base: BrandedClass<ErrorConstructor>;
 /**
  * Base error class for all LangChain errors.
  *
@@ -45,13 +43,11 @@ declare const LangChainError_base: ErrorConstructor & {
  * }
  * ```
  */
-declare class LangChainError extends LangChainError_base {
+export declare class LangChainError extends LangChainError_base {
   readonly name: string;
   constructor(message?: string);
 }
-declare const ModelAbortError_base: typeof LangChainError & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+declare const ModelAbortError_base: BrandedClass<typeof LangChainError>;
 /**
  * Error class representing an aborted model operation in LangChain.
  *
@@ -81,7 +77,7 @@ declare const ModelAbortError_base: typeof LangChainError & {
  * }
  * ```
  */
-declare class ModelAbortError extends ModelAbortError_base {
+export declare class ModelAbortError extends ModelAbortError_base {
   readonly name = "ModelAbortError";
   /**
    * The partial message output that was produced before the operation was aborted.
@@ -96,9 +92,7 @@ declare class ModelAbortError extends ModelAbortError_base {
    */
   constructor(message: string, partialOutput?: AIMessageChunk);
 }
-declare const ContextOverflowError_base: typeof LangChainError & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+declare const ContextOverflowError_base: BrandedClass<typeof LangChainError>;
 /**
  * Error class representing a context window overflow in a language model operation.
  *
@@ -131,7 +125,7 @@ declare const ContextOverflowError_base: typeof LangChainError & {
  * }
  * ```
  */
-declare class ContextOverflowError extends ContextOverflowError_base {
+export declare class ContextOverflowError extends ContextOverflowError_base {
   readonly name = "ContextOverflowError";
   /**
    * The underlying error that caused this {@link ContextOverflowError}, if any.
@@ -163,5 +157,5 @@ declare class ContextOverflowError extends ContextOverflowError_base {
   static fromError(obj: Error): ContextOverflowError;
 }
 //#endregion
-export { ContextOverflowError, LangChainError, LangChainErrorCodes, ModelAbortError, addLangChainErrorFields, getRetryable, ns, stampRetryable };
+export type { BrandedClass };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/errors/index.ts"],"mappings":";;;KAKY;;iBAYI,wBACd,YACA,eAAe;;cAQJ,IAAA;;;;;;;;;;;iBAeG,eAAe,GAAG,OAAO,GAAG,qBAAqB;;;;;;;iBAqBjD,aAAa;;;;;;;;;;;;;;;;;;;;;;cA2BhB,uBAAuB;WACzB;EAET,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCD,wBAAwB;WAC1B;;;;;WAMA,gBAAgB;;;;;;;EAQzB,YAAY,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwClC,6BAA6B;WAI/B;;;;;;;EAQT,QAAQ;EAER,YAAY;;;;;;;;;;;;;;;;;;;;SAyBL,UAAU,KAAK,QAAQ"}
+{"version":3,"file":"index.d.cts","names":["_$___utils_namespace_js0.Namespace","_$__index_js0.BrandedClass"],"sources":["../../src/errors/index.ts"],"mappings":";;;YAOY;;wBAYI,wBACd,YACA,eAAe;;qBAQJ,IAAAA;;;;;;;;;;;wBAeG,eAAe,GAAG,OAAO,GAAG,qBAAqB;;;;;;;wBAqBjD,aAAa;;;;;;;;;;;;;;;;;;;;qBA2BhB,uBAAuB;WACzB;EAET,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCD,wBAAwB;WAC1B;;;;;WAMA,gBAAgB;;;;;;;EAQzB,YAAY,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwClC,6BAA6B;WAI/B;;;;;;;EAQT,QAAQ;EAER,YAAY;;;;;;;;;;;;;;;;;;;;SAyBL,UAAU,KAAK,QAAQ"}

package/dist/errors/index.d.ts

@@ -1,11 +1,11 @@
 import { AIMessageChunk } from "../messages/ai.js";
-import { Namespace } from "../utils/namespace.js";
+import { BrandedClass, Namespace } from "../utils/namespace.js";
 //#region src/errors/index.d.ts
-type LangChainErrorCodes = "CONTEXT_OVERFLOW" | "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
+export type LangChainErrorCodes = "CONTEXT_OVERFLOW" | "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
 /** @deprecated Subclass LangChainError instead */
-declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;
+export declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;
 /** The error namespace for all LangChain errors */
-declare const ns: Namespace;
+export declare const ns: Namespace;
 /**
  * Mark an error as safe or unsafe to retry.
  *
@@ -16,17 +16,15 @@ declare const ns: Namespace;
  * @param retryable - `true` if retrying may succeed.
  * @returns The same error instance, for chaining.
  */
-declare function stampRetryable<T>(error: T, retryable: boolean): T;
+export declare function stampRetryable<T>(error: T, retryable: boolean): T;
 /**
  * Read an error's retryability mark.
  *
  * @returns `true`/`false` when marked, `undefined` when unclassified —
  *   supply your own default, e.g. `getRetryable(error) ?? true`.
  */
-declare function getRetryable(error: unknown): boolean | undefined;
-declare const LangChainError_base: ErrorConstructor & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+export declare function getRetryable(error: unknown): boolean | undefined;
+declare const LangChainError_base: BrandedClass<ErrorConstructor>;
 /**
  * Base error class for all LangChain errors.
  *
@@ -45,13 +43,11 @@ declare const LangChainError_base: ErrorConstructor & {
  * }
  * ```
  */
-declare class LangChainError extends LangChainError_base {
+export declare class LangChainError extends LangChainError_base {
   readonly name: string;
   constructor(message?: string);
 }
-declare const ModelAbortError_base: typeof LangChainError & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+declare const ModelAbortError_base: BrandedClass<typeof LangChainError>;
 /**
  * Error class representing an aborted model operation in LangChain.
  *
@@ -81,7 +77,7 @@ declare const ModelAbortError_base: typeof LangChainError & {
  * }
  * ```
  */
-declare class ModelAbortError extends ModelAbortError_base {
+export declare class ModelAbortError extends ModelAbortError_base {
   readonly name = "ModelAbortError";
   /**
    * The partial message output that was produced before the operation was aborted.
@@ -96,9 +92,7 @@ declare class ModelAbortError extends ModelAbortError_base {
    */
   constructor(message: string, partialOutput?: AIMessageChunk);
 }
-declare const ContextOverflowError_base: typeof LangChainError & {
-  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
-};
+declare const ContextOverflowError_base: BrandedClass<typeof LangChainError>;
 /**
  * Error class representing a context window overflow in a language model operation.
  *
@@ -131,7 +125,7 @@ declare const ContextOverflowError_base: typeof LangChainError & {
  * }
  * ```
  */
-declare class ContextOverflowError extends ContextOverflowError_base {
+export declare class ContextOverflowError extends ContextOverflowError_base {
   readonly name = "ContextOverflowError";
   /**
    * The underlying error that caused this {@link ContextOverflowError}, if any.
@@ -163,5 +157,5 @@ declare class ContextOverflowError extends ContextOverflowError_base {
   static fromError(obj: Error): ContextOverflowError;
 }
 //#endregion
-export { ContextOverflowError, LangChainError, LangChainErrorCodes, ModelAbortError, addLangChainErrorFields, getRetryable, ns, stampRetryable };
+export type { BrandedClass };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/errors/index.ts"],"mappings":";;;KAKY;;iBAYI,wBACd,YACA,eAAe;;cAQJ,IAAA;;;;;;;;;;;iBAeG,eAAe,GAAG,OAAO,GAAG,qBAAqB;;;;;;;iBAqBjD,aAAa;;;;;;;;;;;;;;;;;;;;;;cA2BhB,uBAAuB;WACzB;EAET,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCD,wBAAwB;WAC1B;;;;;WAMA,gBAAgB;;;;;;;EAQzB,YAAY,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwClC,6BAA6B;WAI/B;;;;;;;EAQT,QAAQ;EAER,YAAY;;;;;;;;;;;;;;;;;;;;SAyBL,UAAU,KAAK,QAAQ"}
+{"version":3,"file":"index.d.ts","names":["_$___utils_namespace_js0.Namespace","_$__index_js0.BrandedClass"],"sources":["../../src/errors/index.ts"],"mappings":";;;YAOY;;wBAYI,wBACd,YACA,eAAe;;qBAQJ,IAAAA;;;;;;;;;;;wBAeG,eAAe,GAAG,OAAO,GAAG,qBAAqB;;;;;;;wBAqBjD,aAAa;;;;;;;;;;;;;;;;;;;;qBA2BhB,uBAAuB;WACzB;EAET,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCD,wBAAwB;WAC1B;;;;;WAMA,gBAAgB;;;;;;;EAQzB,YAAY,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwClC,6BAA6B;WAI/B;;;;;;;EAQT,QAAQ;EAER,YAAY;;;;;;;;;;;;;;;;;;;;SAyBL,UAAU,KAAK,QAAQ"}

package/dist/errors/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["baseNs"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport type { AIMessageChunk } from \"../messages/ai.js\";\nimport { ns as baseNs } from \"../utils/namespace.js\";\n\nexport type LangChainErrorCodes =\n  | \"CONTEXT_OVERFLOW\"\n  | \"INVALID_PROMPT_INPUT\"\n  | \"INVALID_TOOL_RESULTS\"\n  | \"MESSAGE_COERCION_FAILURE\"\n  | \"MODEL_AUTHENTICATION\"\n  | \"MODEL_NOT_FOUND\"\n  | \"MODEL_RATE_LIMIT\"\n  | \"OUTPUT_PARSING_FAILURE\"\n  | \"MODEL_ABORTED\";\n\n/** @deprecated Subclass LangChainError instead */\nexport function addLangChainErrorFields(\n  error: any,\n  lc_error_code: LangChainErrorCodes\n) {\n  (error as any).lc_error_code = lc_error_code;\n  error.message = `${error.message}\\n\\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langchain/errors/${lc_error_code}/\\n`;\n  return error;\n}\n\n/** The error namespace for all LangChain errors */\nexport const ns = baseNs.sub(\"error\");\n\n/** Registered globally so duplicate copies of core in one dependency tree agree. */\nconst retryableSymbol = Symbol.for(\"langchain.errors.retryable\");\n\n/**\n * Mark an error as safe or unsafe to retry.\n *\n * Sets a non-enumerable symbol on the error itself, leaving its class and\n * shape untouched, so it is safe to apply to a provider SDK's own error.\n *\n * @param error - The error to mark. Non-objects are returned untouched.\n * @param retryable - `true` if retrying may succeed.\n * @returns The same error instance, for chaining.\n */\nexport function stampRetryable<T>(error: T, retryable: boolean): T {\n  if (typeof error !== \"object\" || error === null) {\n    return error;\n  }\n  try {\n    Object.defineProperty(error, retryableSymbol, {\n      value: retryable,\n      configurable: true,\n    });\n  } catch {\n    // Frozen or sealed error object; leave it unmarked rather than throwing.\n  }\n  return error;\n}\n\n/**\n * Read an error's retryability mark.\n *\n * @returns `true`/`false` when marked, `undefined` when unclassified —\n *   supply your own default, e.g. `getRetryable(error) ?? true`.\n */\nexport function getRetryable(error: unknown): boolean | undefined {\n  if (typeof error !== \"object\" || error === null) {\n    return undefined;\n  }\n  return Object.getOwnPropertyDescriptor(error, retryableSymbol)?.value as\n    | boolean\n    | undefined;\n}\n\n/**\n * Base error class for all LangChain errors.\n *\n * All LangChain error classes should extend this class (directly or\n * indirectly). Use `LangChainError.isInstance(obj)` to check if an\n * object is any LangChain error.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(\"hello\");\n * } catch (error) {\n *   if (LangChainError.isInstance(error)) {\n *     console.log(\"Got a LangChain error:\", error.message);\n *   }\n * }\n * ```\n */\nexport class LangChainError extends ns.brand(Error) {\n  readonly name: string = \"LangChainError\";\n\n  constructor(message?: string) {\n    super(message);\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error class representing an aborted model operation in LangChain.\n *\n * This error is thrown when a model operation (such as invocation, streaming, or batching)\n * is cancelled before it completes, commonly due to a user-initiated abort signal\n * (e.g., via an AbortController) or an upstream cancellation event.\n *\n * The ModelAbortError provides access to any partial output the model may have produced\n * before the operation was interrupted, which can be useful for resuming work, debugging,\n * or presenting incomplete results to users.\n *\n * @remarks\n * - The `partialOutput` field includes message content that was generated prior to the abort,\n *   such as a partial AIMessageChunk.\n * - This error extends the {@link LangChainError} base class with the marker `\"model-abort\"`.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(input, { signal: abortController.signal });\n * } catch (err) {\n *   if (ModelAbortError.isInstance(err)) {\n *     // Handle user cancellation, check err.partialOutput if needed\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ModelAbortError extends ns.brand(LangChainError, \"model-abort\") {\n  readonly name = \"ModelAbortError\";\n\n  /**\n   * The partial message output that was produced before the operation was aborted.\n   * This is typically an AIMessageChunk, or could be undefined if no output was available.\n   */\n  readonly partialOutput?: AIMessageChunk;\n\n  /**\n   * Constructs a new ModelAbortError instance.\n   *\n   * @param message - A human-readable message describing the abort event.\n   * @param partialOutput - Any partial model output generated before the abort (optional).\n   */\n  constructor(message: string, partialOutput?: AIMessageChunk) {\n    super(message);\n    this.partialOutput = partialOutput;\n    // Retrying would mean ignoring the caller's explicit abort signal.\n    stampRetryable(this, false);\n  }\n}\n\n/**\n * Error class representing a context window overflow in a language model operation.\n *\n * This error is thrown when the combined input to a language model (such as prompt tokens,\n * historical messages, and/or instructions) exceeds the maximum context window or token limit\n * that the model can process in a single request. Most models have defined upper limits for the number of\n * tokens or characters allowed in a context, and exceeding this limit will prevent\n * the operation from proceeding.\n *\n * The {@link ContextOverflowError} extends the {@link LangChainError} base class with\n * the marker `\"context-overflow\"`.\n *\n * @remarks\n * - Use this error to programmatically identify cases where a user request, prompt, or input\n *   sequence is too long to be handled by the target model.\n * - Model providers and framework integrations should throw this error if they detect\n *   a request cannot be processed due to its size.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(veryLongInput);\n * } catch (err) {\n *   if (ContextOverflowError.isInstance(err)) {\n *     // Handle overflow, e.g., prompt user to shorten input or truncate text\n *     console.warn(\"Model context overflow:\", err.message);\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ContextOverflowError extends ns.brand(\n  LangChainError,\n  \"context-overflow\"\n) {\n  readonly name = \"ContextOverflowError\";\n\n  /**\n   * The underlying error that caused this {@link ContextOverflowError}, if any.\n   *\n   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.\n   * It allows error handlers to access or inspect the original error that led to the context overflow.\n   */\n  cause?: Error;\n\n  constructor(message?: string) {\n    super(message ?? \"Input exceeded the model's context window.\");\n    // The same oversized input fails identically; it needs trimming, not another attempt.\n    stampRetryable(this, false);\n  }\n\n  /**\n   * Creates a new {@link ContextOverflowError} instance from an existing error.\n   *\n   * This static utility copies the message from the provided error and\n   * attaches the original error as the {@link ContextOverflowError.cause} property,\n   * enabling error handlers to inspect or propagate the original failure.\n   *\n   * @param obj - The original error object causing the context overflow.\n   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   await model.invoke(input);\n   * } catch (err) {\n   *   throw ContextOverflowError.fromError(err);\n   * }\n   * ```\n   */\n  static fromError(obj: Error): ContextOverflowError {\n    const error = new ContextOverflowError(obj.message);\n    error.cause = obj;\n    return error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,wBACd,OACA,eACA;CACA,MAAe,gBAAgB;CAC/B,MAAM,UAAU,GAAG,MAAM,QAAQ,sFAAsF,cAAc;CACrI,OAAO;AACT;;AAGA,MAAa,KAAKA,KAAO,IAAI,OAAO;;AAGpC,MAAM,kBAAkB,OAAO,IAAI,4BAA4B;;;;;;;;;;;AAY/D,SAAgB,eAAkB,OAAU,WAAuB;CACjE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAET,IAAI;EACF,OAAO,eAAe,OAAO,iBAAiB;GAC5C,OAAO;GACP,cAAc;EAChB,CAAC;CACH,QAAQ,CAER;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAa,OAAqC;CAChE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC;CAEF,OAAO,OAAO,yBAAyB,OAAO,eAAe,CAAC,EAAE;AAGlE;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,iBAAb,cAAoC,GAAG,MAAM,KAAK,CAAC,CAAC;CAClD,OAAwB;CAExB,YAAY,SAAkB;EAC5B,MAAM,OAAO;EACb,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,WAAW;CAElD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAb,cAAqC,GAAG,MAAM,gBAAgB,aAAa,CAAC,CAAC;CAC3E,OAAgB;;;;;CAMhB;;;;;;;CAQA,YAAY,SAAiB,eAAgC;EAC3D,MAAM,OAAO;EACb,KAAK,gBAAgB;EAErB,eAAe,MAAM,KAAK;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,uBAAb,MAAa,6BAA6B,GAAG,MAC3C,gBACA,kBACF,CAAC,CAAC;CACA,OAAgB;;;;;;;CAQhB;CAEA,YAAY,SAAkB;EAC5B,MAAM,WAAW,4CAA4C;EAE7D,eAAe,MAAM,KAAK;CAC5B;;;;;;;;;;;;;;;;;;;;CAqBA,OAAO,UAAU,KAAkC;EACjD,MAAM,QAAQ,IAAI,qBAAqB,IAAI,OAAO;EAClD,MAAM,QAAQ;EACd,OAAO;CACT;AACF"}
+{"version":3,"file":"index.js","names":["baseNs"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport type { AIMessageChunk } from \"../messages/ai.js\";\nimport { ns as baseNs } from \"../utils/namespace.js\";\n\nexport type { BrandedClass } from \"../utils/namespace.js\";\n\nexport type LangChainErrorCodes =\n  | \"CONTEXT_OVERFLOW\"\n  | \"INVALID_PROMPT_INPUT\"\n  | \"INVALID_TOOL_RESULTS\"\n  | \"MESSAGE_COERCION_FAILURE\"\n  | \"MODEL_AUTHENTICATION\"\n  | \"MODEL_NOT_FOUND\"\n  | \"MODEL_RATE_LIMIT\"\n  | \"OUTPUT_PARSING_FAILURE\"\n  | \"MODEL_ABORTED\";\n\n/** @deprecated Subclass LangChainError instead */\nexport function addLangChainErrorFields(\n  error: any,\n  lc_error_code: LangChainErrorCodes\n) {\n  (error as any).lc_error_code = lc_error_code;\n  error.message = `${error.message}\\n\\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langchain/errors/${lc_error_code}/\\n`;\n  return error;\n}\n\n/** The error namespace for all LangChain errors */\nexport const ns = baseNs.sub(\"error\");\n\n/** Registered globally so duplicate copies of core in one dependency tree agree. */\nconst retryableSymbol = Symbol.for(\"langchain.errors.retryable\");\n\n/**\n * Mark an error as safe or unsafe to retry.\n *\n * Sets a non-enumerable symbol on the error itself, leaving its class and\n * shape untouched, so it is safe to apply to a provider SDK's own error.\n *\n * @param error - The error to mark. Non-objects are returned untouched.\n * @param retryable - `true` if retrying may succeed.\n * @returns The same error instance, for chaining.\n */\nexport function stampRetryable<T>(error: T, retryable: boolean): T {\n  if (typeof error !== \"object\" || error === null) {\n    return error;\n  }\n  try {\n    Object.defineProperty(error, retryableSymbol, {\n      value: retryable,\n      configurable: true,\n    });\n  } catch {\n    // Frozen or sealed error object; leave it unmarked rather than throwing.\n  }\n  return error;\n}\n\n/**\n * Read an error's retryability mark.\n *\n * @returns `true`/`false` when marked, `undefined` when unclassified —\n *   supply your own default, e.g. `getRetryable(error) ?? true`.\n */\nexport function getRetryable(error: unknown): boolean | undefined {\n  if (typeof error !== \"object\" || error === null) {\n    return undefined;\n  }\n  return Object.getOwnPropertyDescriptor(error, retryableSymbol)?.value as\n    | boolean\n    | undefined;\n}\n\n/**\n * Base error class for all LangChain errors.\n *\n * All LangChain error classes should extend this class (directly or\n * indirectly). Use `LangChainError.isInstance(obj)` to check if an\n * object is any LangChain error.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(\"hello\");\n * } catch (error) {\n *   if (LangChainError.isInstance(error)) {\n *     console.log(\"Got a LangChain error:\", error.message);\n *   }\n * }\n * ```\n */\nexport class LangChainError extends ns.brand(Error) {\n  readonly name: string = \"LangChainError\";\n\n  constructor(message?: string) {\n    super(message);\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error class representing an aborted model operation in LangChain.\n *\n * This error is thrown when a model operation (such as invocation, streaming, or batching)\n * is cancelled before it completes, commonly due to a user-initiated abort signal\n * (e.g., via an AbortController) or an upstream cancellation event.\n *\n * The ModelAbortError provides access to any partial output the model may have produced\n * before the operation was interrupted, which can be useful for resuming work, debugging,\n * or presenting incomplete results to users.\n *\n * @remarks\n * - The `partialOutput` field includes message content that was generated prior to the abort,\n *   such as a partial AIMessageChunk.\n * - This error extends the {@link LangChainError} base class with the marker `\"model-abort\"`.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(input, { signal: abortController.signal });\n * } catch (err) {\n *   if (ModelAbortError.isInstance(err)) {\n *     // Handle user cancellation, check err.partialOutput if needed\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ModelAbortError extends ns.brand(LangChainError, \"model-abort\") {\n  readonly name = \"ModelAbortError\";\n\n  /**\n   * The partial message output that was produced before the operation was aborted.\n   * This is typically an AIMessageChunk, or could be undefined if no output was available.\n   */\n  readonly partialOutput?: AIMessageChunk;\n\n  /**\n   * Constructs a new ModelAbortError instance.\n   *\n   * @param message - A human-readable message describing the abort event.\n   * @param partialOutput - Any partial model output generated before the abort (optional).\n   */\n  constructor(message: string, partialOutput?: AIMessageChunk) {\n    super(message);\n    this.partialOutput = partialOutput;\n    // Retrying would mean ignoring the caller's explicit abort signal.\n    stampRetryable(this, false);\n  }\n}\n\n/**\n * Error class representing a context window overflow in a language model operation.\n *\n * This error is thrown when the combined input to a language model (such as prompt tokens,\n * historical messages, and/or instructions) exceeds the maximum context window or token limit\n * that the model can process in a single request. Most models have defined upper limits for the number of\n * tokens or characters allowed in a context, and exceeding this limit will prevent\n * the operation from proceeding.\n *\n * The {@link ContextOverflowError} extends the {@link LangChainError} base class with\n * the marker `\"context-overflow\"`.\n *\n * @remarks\n * - Use this error to programmatically identify cases where a user request, prompt, or input\n *   sequence is too long to be handled by the target model.\n * - Model providers and framework integrations should throw this error if they detect\n *   a request cannot be processed due to its size.\n *\n * @example\n * ```typescript\n * try {\n *   await model.invoke(veryLongInput);\n * } catch (err) {\n *   if (ContextOverflowError.isInstance(err)) {\n *     // Handle overflow, e.g., prompt user to shorten input or truncate text\n *     console.warn(\"Model context overflow:\", err.message);\n *   } else {\n *     throw err;\n *   }\n * }\n * ```\n */\nexport class ContextOverflowError extends ns.brand(\n  LangChainError,\n  \"context-overflow\"\n) {\n  readonly name = \"ContextOverflowError\";\n\n  /**\n   * The underlying error that caused this {@link ContextOverflowError}, if any.\n   *\n   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.\n   * It allows error handlers to access or inspect the original error that led to the context overflow.\n   */\n  cause?: Error;\n\n  constructor(message?: string) {\n    super(message ?? \"Input exceeded the model's context window.\");\n    // The same oversized input fails identically; it needs trimming, not another attempt.\n    stampRetryable(this, false);\n  }\n\n  /**\n   * Creates a new {@link ContextOverflowError} instance from an existing error.\n   *\n   * This static utility copies the message from the provided error and\n   * attaches the original error as the {@link ContextOverflowError.cause} property,\n   * enabling error handlers to inspect or propagate the original failure.\n   *\n   * @param obj - The original error object causing the context overflow.\n   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   await model.invoke(input);\n   * } catch (err) {\n   *   throw ContextOverflowError.fromError(err);\n   * }\n   * ```\n   */\n  static fromError(obj: Error): ContextOverflowError {\n    const error = new ContextOverflowError(obj.message);\n    error.cause = obj;\n    return error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAmBA,SAAgB,wBACd,OACA,eACA;CACA,MAAe,gBAAgB;CAC/B,MAAM,UAAU,GAAG,MAAM,QAAQ,sFAAsF,cAAc;CACrI,OAAO;AACT;;AAGA,MAAa,KAAKA,KAAO,IAAI,OAAO;;AAGpC,MAAM,kBAAkB,OAAO,IAAI,4BAA4B;;;;;;;;;;;AAY/D,SAAgB,eAAkB,OAAU,WAAuB;CACjE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAET,IAAI;EACF,OAAO,eAAe,OAAO,iBAAiB;GAC5C,OAAO;GACP,cAAc;EAChB,CAAC;CACH,QAAQ,CAER;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAa,OAAqC;CAChE,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC;CAEF,OAAO,OAAO,yBAAyB,OAAO,eAAe,CAAC,EAAE;AAGlE;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,iBAAb,cAAoC,GAAG,MAAM,KAAK,CAAC,CAAC;CAClD,OAAwB;CAExB,YAAY,SAAkB;EAC5B,MAAM,OAAO;EACb,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,WAAW;CAElD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAb,cAAqC,GAAG,MAAM,gBAAgB,aAAa,CAAC,CAAC;CAC3E,OAAgB;;;;;CAMhB;;;;;;;CAQA,YAAY,SAAiB,eAAgC;EAC3D,MAAM,OAAO;EACb,KAAK,gBAAgB;EAErB,eAAe,MAAM,KAAK;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,uBAAb,MAAa,6BAA6B,GAAG,MAC3C,gBACA,kBACF,CAAC,CAAC;CACA,OAAgB;;;;;;;CAQhB;CAEA,YAAY,SAAkB;EAC5B,MAAM,WAAW,4CAA4C;EAE7D,eAAe,MAAM,KAAK;CAC5B;;;;;;;;;;;;;;;;;;;;CAqBA,OAAO,UAAU,KAAkC;EACjD,MAAM,QAAQ,IAAI,qBAAqB,IAAI,OAAO;EAClD,MAAM,QAAQ;EACd,OAAO;CACT;AACF"}

package/dist/example_selectors/base.d.cts

@@ -4,7 +4,7 @@ import { Example } from "../prompts/base.cjs";
 /**
  * Base class for example selectors.
  */
-declare abstract class BaseExampleSelector extends Serializable {
+export declare abstract class BaseExampleSelector extends Serializable {
   lc_namespace: string[];
   /**
    * Adds an example to the example selector.
@@ -20,5 +20,4 @@ declare abstract class BaseExampleSelector extends Serializable {
   abstract selectExamples(input_variables: Example): Promise<Example[]>;
 }
 //#endregion
-export { BaseExampleSelector };
 //# sourceMappingURL=base.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/example_selectors/base.ts"],"mappings":";;;;;;uBAMsB,4BAA4B;EAChD;;;;;;WAOS,WAAW,SAAS,UAAU;;;;;;WAO9B,eAAe,iBAAiB,UAAU,QAAQ"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/example_selectors/base.ts"],"mappings":";;;;;;8BAMsB,4BAA4B;EAChD;;;;;;WAOS,WAAW,SAAS,UAAU;;;;;;WAO9B,eAAe,iBAAiB,UAAU,QAAQ"}

package/dist/example_selectors/base.d.ts

@@ -4,7 +4,7 @@ import { Example } from "../prompts/base.js";
 /**
  * Base class for example selectors.
  */
-declare abstract class BaseExampleSelector extends Serializable {
+export declare abstract class BaseExampleSelector extends Serializable {
   lc_namespace: string[];
   /**
    * Adds an example to the example selector.
@@ -20,5 +20,4 @@ declare abstract class BaseExampleSelector extends Serializable {
   abstract selectExamples(input_variables: Example): Promise<Example[]>;
 }
 //#endregion
-export { BaseExampleSelector };
 //# sourceMappingURL=base.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/example_selectors/base.ts"],"mappings":";;;;;;uBAMsB,4BAA4B;EAChD;;;;;;WAOS,WAAW,SAAS,UAAU;;;;;;WAO9B,eAAe,iBAAiB,UAAU,QAAQ"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/example_selectors/base.ts"],"mappings":";;;;;;8BAMsB,4BAA4B;EAChD;;;;;;WAOS,WAAW,SAAS,UAAU;;;;;;WAO9B,eAAe,iBAAiB,UAAU,QAAQ"}

package/dist/example_selectors/conditional.d.cts

@@ -4,14 +4,14 @@ import { BasePromptTemplate } from "../prompts/base.cjs";
 import { BaseChatModel } from "../language_models/chat_models.cjs";
 import { BaseLLM } from "../language_models/llms.cjs";
 //#region src/example_selectors/conditional.d.ts
-type BaseGetPromptAsyncOptions = {
+export type BaseGetPromptAsyncOptions = {
   partialVariables?: PartialValues;
 };
 /**
  * Abstract class that defines the interface for selecting a prompt for a
  * given language model.
  */
-declare abstract class BasePromptSelector {
+export declare abstract class BasePromptSelector {
   /**
    * Abstract method that must be implemented by any class that extends
    * `BasePromptSelector`. It takes a language model as an argument and
@@ -34,7 +34,7 @@ declare abstract class BasePromptSelector {
  * based on a set of conditions. It has a default prompt that it returns
  * if none of the conditions are met.
  */
-declare class ConditionalPromptSelector extends BasePromptSelector {
+export declare class ConditionalPromptSelector extends BasePromptSelector {
   defaultPrompt: BasePromptTemplate;
   conditionals: Array<[condition: (llm: BaseLanguageModelInterface) => boolean, prompt: BasePromptTemplate]>;
   constructor(default_prompt: BasePromptTemplate, conditionals?: Array<[condition: (llm: BaseLanguageModelInterface) => boolean, prompt: BasePromptTemplate]>);
@@ -50,12 +50,11 @@ declare class ConditionalPromptSelector extends BasePromptSelector {
  * Type guard function that checks if a given language model is of type
  * `BaseLLM`.
  */
-declare function isLLM(llm: BaseLanguageModelInterface): llm is BaseLLM;
+export declare function isLLM(llm: BaseLanguageModelInterface): llm is BaseLLM;
 /**
  * Type guard function that checks if a given language model is of type
  * `BaseChatModel`.
  */
-declare function isChatModel(llm: BaseLanguageModelInterface): llm is BaseChatModel;
+export declare function isChatModel(llm: BaseLanguageModelInterface): llm is BaseChatModel;
 //#endregion
-export { BaseGetPromptAsyncOptions, BasePromptSelector, ConditionalPromptSelector, isChatModel, isLLM };
 //# sourceMappingURL=conditional.d.cts.map

package/dist/example_selectors/conditional.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"conditional.d.cts","names":[],"sources":["../../src/example_selectors/conditional.ts"],"mappings":";;;;;;KAMY;EACV,mBAAmB;;;;;;uBAOC;;;;;;;;WAQX,UAAU,KAAK,6BAA6B;;;;;;;;EAS/C,eACJ,KAAK,4BACL,UAAU,4BACT,QAAQ;;;;;;;cAWA,kCAAkC;EAC7C,eAAe;EAEf,cAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;EAIZ,YACE,gBAAgB,oBAChB,eAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;;;;;;;EAed,UAAU,KAAK,6BAA6B;;;;;;iBAc9B,MAAM,KAAK,6BAA6B,OAAO;;;;;iBAQ/C,YACd,KAAK,6BACJ,OAAO"}
+{"version":3,"file":"conditional.d.cts","names":[],"sources":["../../src/example_selectors/conditional.ts"],"mappings":";;;;;;YAMY;EACV,mBAAmB;;;;;;8BAOC;;;;;;;;WAQX,UAAU,KAAK,6BAA6B;;;;;;;;EAS/C,eACJ,KAAK,4BACL,UAAU,4BACT,QAAQ;;;;;;;qBAWA,kCAAkC;EAC7C,eAAe;EAEf,cAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;EAIZ,YACE,gBAAgB,oBAChB,eAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;;;;;;;EAed,UAAU,KAAK,6BAA6B;;;;;;wBAc9B,MAAM,KAAK,6BAA6B,OAAO;;;;;wBAQ/C,YACd,KAAK,6BACJ,OAAO"}

package/dist/example_selectors/conditional.d.ts

@@ -4,14 +4,14 @@ import { BasePromptTemplate } from "../prompts/base.js";
 import { BaseChatModel } from "../language_models/chat_models.js";
 import { BaseLLM } from "../language_models/llms.js";
 //#region src/example_selectors/conditional.d.ts
-type BaseGetPromptAsyncOptions = {
+export type BaseGetPromptAsyncOptions = {
   partialVariables?: PartialValues;
 };
 /**
  * Abstract class that defines the interface for selecting a prompt for a
  * given language model.
  */
-declare abstract class BasePromptSelector {
+export declare abstract class BasePromptSelector {
   /**
    * Abstract method that must be implemented by any class that extends
    * `BasePromptSelector`. It takes a language model as an argument and
@@ -34,7 +34,7 @@ declare abstract class BasePromptSelector {
  * based on a set of conditions. It has a default prompt that it returns
  * if none of the conditions are met.
  */
-declare class ConditionalPromptSelector extends BasePromptSelector {
+export declare class ConditionalPromptSelector extends BasePromptSelector {
   defaultPrompt: BasePromptTemplate;
   conditionals: Array<[condition: (llm: BaseLanguageModelInterface) => boolean, prompt: BasePromptTemplate]>;
   constructor(default_prompt: BasePromptTemplate, conditionals?: Array<[condition: (llm: BaseLanguageModelInterface) => boolean, prompt: BasePromptTemplate]>);
@@ -50,12 +50,11 @@ declare class ConditionalPromptSelector extends BasePromptSelector {
  * Type guard function that checks if a given language model is of type
  * `BaseLLM`.
  */
-declare function isLLM(llm: BaseLanguageModelInterface): llm is BaseLLM;
+export declare function isLLM(llm: BaseLanguageModelInterface): llm is BaseLLM;
 /**
  * Type guard function that checks if a given language model is of type
  * `BaseChatModel`.
  */
-declare function isChatModel(llm: BaseLanguageModelInterface): llm is BaseChatModel;
+export declare function isChatModel(llm: BaseLanguageModelInterface): llm is BaseChatModel;
 //#endregion
-export { BaseGetPromptAsyncOptions, BasePromptSelector, ConditionalPromptSelector, isChatModel, isLLM };
 //# sourceMappingURL=conditional.d.ts.map

package/dist/example_selectors/conditional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditional.d.ts","names":[],"sources":["../../src/example_selectors/conditional.ts"],"mappings":";;;;;;KAMY;EACV,mBAAmB;;;;;;uBAOC;;;;;;;;WAQX,UAAU,KAAK,6BAA6B;;;;;;;;EAS/C,eACJ,KAAK,4BACL,UAAU,4BACT,QAAQ;;;;;;;cAWA,kCAAkC;EAC7C,eAAe;EAEf,cAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;EAIZ,YACE,gBAAgB,oBAChB,eAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;;;;;;;EAed,UAAU,KAAK,6BAA6B;;;;;;iBAc9B,MAAM,KAAK,6BAA6B,OAAO;;;;;iBAQ/C,YACd,KAAK,6BACJ,OAAO"}
+{"version":3,"file":"conditional.d.ts","names":[],"sources":["../../src/example_selectors/conditional.ts"],"mappings":";;;;;;YAMY;EACV,mBAAmB;;;;;;8BAOC;;;;;;;;WAQX,UAAU,KAAK,6BAA6B;;;;;;;;EAS/C,eACJ,KAAK,4BACL,UAAU,4BACT,QAAQ;;;;;;;qBAWA,kCAAkC;EAC7C,eAAe;EAEf,cAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;EAIZ,YACE,gBAAgB,oBAChB,eAAc,OAEV,YAAY,KAAK,wCACjB,QAAQ;;;;;;;EAed,UAAU,KAAK,6BAA6B;;;;;;wBAc9B,MAAM,KAAK,6BAA6B,OAAO;;;;;wBAQ/C,YACd,KAAK,6BACJ,OAAO"}

package/dist/example_selectors/length_based.d.cts

@@ -6,7 +6,7 @@ import { PromptTemplate } from "../prompts/prompt.cjs";
  * Interface for the input parameters of the LengthBasedExampleSelector
  * class.
  */
-interface LengthBasedExampleSelectorInput {
+export interface LengthBasedExampleSelectorInput {
   examplePrompt: PromptTemplate;
   maxLength?: number;
   getTextLength?: (text: string) => number;
@@ -52,7 +52,7 @@ interface LengthBasedExampleSelectorInput {
  * );
  * ```
  */
-declare class LengthBasedExampleSelector extends BaseExampleSelector {
+export declare class LengthBasedExampleSelector extends BaseExampleSelector {
   protected examples: Example[];
   examplePrompt: PromptTemplate;
   getTextLength: (text: string) => number;
@@ -89,5 +89,4 @@ declare class LengthBasedExampleSelector extends BaseExampleSelector {
   static fromExamples(examples: Example[], args: LengthBasedExampleSelectorInput): Promise<LengthBasedExampleSelector>;
 }
 //#endregion
-export { LengthBasedExampleSelector, LengthBasedExampleSelectorInput };
 //# sourceMappingURL=length_based.d.cts.map

package/dist/example_selectors/length_based.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"length_based.d.cts","names":[],"sources":["../../src/example_selectors/length_based.ts"],"mappings":";;;;;;;;UAeiB;EACf,eAAe;EACf;EACA,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4CN,mCAAmC;YACpC,UAAU;EAEpB,eAAgB;EAEhB,gBAAgB;EAEhB;EAEA;EAEA,YAAY,MAAM;;;;;;EAYZ,WAAW,SAAS,UAAU;;;;;;;EAY9B,4BACJ,aACA,QAAQ,6BACP;;;;;;;EAkBG,eAAe,gBAAgB,UAAU,QAAQ;;;;;;;;SA2B1C,aACX,UAAU,WACV,MAAM,kCAA+B,QAAA"}
+{"version":3,"file":"length_based.d.cts","names":[],"sources":["../../src/example_selectors/length_based.ts"],"mappings":";;;;;;;;iBAeiB;EACf,eAAe;EACf;EACA,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4CN,mCAAmC;YACpC,UAAU;EAEpB,eAAgB;EAEhB,gBAAgB;EAEhB;EAEA;EAEA,YAAY,MAAM;;;;;;EAYZ,WAAW,SAAS,UAAU;;;;;;;EAY9B,4BACJ,aACA,QAAQ,6BACP;;;;;;;EAkBG,eAAe,gBAAgB,UAAU,QAAQ;;;;;;;;SA2B1C,aACX,UAAU,WACV,MAAM,kCAA+B,QAAA"}

package/dist/example_selectors/length_based.d.ts

@@ -6,7 +6,7 @@ import { PromptTemplate } from "../prompts/prompt.js";
  * Interface for the input parameters of the LengthBasedExampleSelector
  * class.
  */
-interface LengthBasedExampleSelectorInput {
+export interface LengthBasedExampleSelectorInput {
   examplePrompt: PromptTemplate;
   maxLength?: number;
   getTextLength?: (text: string) => number;
@@ -52,7 +52,7 @@ interface LengthBasedExampleSelectorInput {
  * );
  * ```
  */
-declare class LengthBasedExampleSelector extends BaseExampleSelector {
+export declare class LengthBasedExampleSelector extends BaseExampleSelector {
   protected examples: Example[];
   examplePrompt: PromptTemplate;
   getTextLength: (text: string) => number;
@@ -89,5 +89,4 @@ declare class LengthBasedExampleSelector extends BaseExampleSelector {
   static fromExamples(examples: Example[], args: LengthBasedExampleSelectorInput): Promise<LengthBasedExampleSelector>;
 }
 //#endregion
-export { LengthBasedExampleSelector, LengthBasedExampleSelectorInput };
 //# sourceMappingURL=length_based.d.ts.map

package/dist/example_selectors/length_based.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"length_based.d.ts","names":[],"sources":["../../src/example_selectors/length_based.ts"],"mappings":";;;;;;;;UAeiB;EACf,eAAe;EACf;EACA,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4CN,mCAAmC;YACpC,UAAU;EAEpB,eAAgB;EAEhB,gBAAgB;EAEhB;EAEA;EAEA,YAAY,MAAM;;;;;;EAYZ,WAAW,SAAS,UAAU;;;;;;;EAY9B,4BACJ,aACA,QAAQ,6BACP;;;;;;;EAkBG,eAAe,gBAAgB,UAAU,QAAQ;;;;;;;;SA2B1C,aACX,UAAU,WACV,MAAM,kCAA+B,QAAA"}
+{"version":3,"file":"length_based.d.ts","names":[],"sources":["../../src/example_selectors/length_based.ts"],"mappings":";;;;;;;;iBAeiB;EACf,eAAe;EACf;EACA,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4CN,mCAAmC;YACpC,UAAU;EAEpB,eAAgB;EAEhB,gBAAgB;EAEhB;EAEA;EAEA,YAAY,MAAM;;;;;;EAYZ,WAAW,SAAS,UAAU;;;;;;;EAY9B,4BACJ,aACA,QAAQ,6BACP;;;;;;;EAkBG,eAAe,gBAAgB,UAAU,QAAQ;;;;;;;;SA2B1C,aACX,UAAU,WACV,MAAM,kCAA+B,QAAA"}