@langchain/core 1.1.24 → 1.1.25

package/dist/errors/index.cjs

@@ -1,43 +1,168 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_namespace = require('../utils/namespace.cjs');
 
 //#region src/errors/index.ts
-var errors_exports = {};
-require_rolldown_runtime.__export(errors_exports, {
+var errors_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	ContextOverflowError: () => ContextOverflowError,
+	LangChainError: () => LangChainError,
 	ModelAbortError: () => ModelAbortError,
-	addLangChainErrorFields: () => addLangChainErrorFields
+	addLangChainErrorFields: () => addLangChainErrorFields,
+	ns: () => ns
 });
+/** @deprecated Subclass LangChainError instead */
 function addLangChainErrorFields(error, lc_error_code) {
 	error.lc_error_code = lc_error_code;
 	error.message = `${error.message}\n\nTroubleshooting URL: https://docs.langchain.com/oss/javascript/langchain/errors/${lc_error_code}/\n`;
 	return error;
 }
+/** The error namespace for all LangChain errors */
+const ns = require_namespace.ns.sub("error");
 /**
-* Error thrown when a model invocation is aborted via an AbortSignal.
-* Contains any partial output that was generated before the abort.
+* Base error class for all LangChain errors.
+*
+* All LangChain error classes should extend this class (directly or
+* indirectly). Use `LangChainError.isInstance(obj)` to check if an
+* object is any LangChain error.
+*
+* @example
+* ```typescript
+* try {
+*   await model.invoke("hello");
+* } catch (error) {
+*   if (LangChainError.isInstance(error)) {
+*     console.log("Got a LangChain error:", error.message);
+*   }
+* }
+* ```
 */
-var ModelAbortError = class ModelAbortError extends Error {
+var LangChainError = class extends ns.brand(Error) {
+	name = "LangChainError";
+	constructor(message) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error class representing an aborted model operation in LangChain.
+*
+* This error is thrown when a model operation (such as invocation, streaming, or batching)
+* is cancelled before it completes, commonly due to a user-initiated abort signal
+* (e.g., via an AbortController) or an upstream cancellation event.
+*
+* The ModelAbortError provides access to any partial output the model may have produced
+* before the operation was interrupted, which can be useful for resuming work, debugging,
+* or presenting incomplete results to users.
+*
+* @remarks
+* - The `partialOutput` field includes message content that was generated prior to the abort,
+*   such as a partial AIMessageChunk.
+* - This error extends the {@link LangChainError} base class with the marker `"model-abort"`.
+*
+* @example
+* ```typescript
+* try {
+*   await model.invoke(input, { signal: abortController.signal });
+* } catch (err) {
+*   if (ModelAbortError.isInstance(err)) {
+*     // Handle user cancellation, check err.partialOutput if needed
+*   } else {
+*     throw err;
+*   }
+* }
+* ```
+*/
+var ModelAbortError = class extends ns.brand(LangChainError, "model-abort") {
 	name = "ModelAbortError";
-	lc_error_code = "MODEL_ABORTED";
 	/**
-	* The partial message output that was accumulated before the abort.
-	* This allows callers to access whatever content was generated
-	* before the operation was cancelled.
+	* The partial message output that was produced before the operation was aborted.
+	* This is typically an AIMessageChunk, or could be undefined if no output was available.
 	*/
 	partialOutput;
+	/**
+	* Constructs a new ModelAbortError instance.
+	*
+	* @param message - A human-readable message describing the abort event.
+	* @param partialOutput - Any partial model output generated before the abort (optional).
+	*/
 	constructor(message, partialOutput) {
 		super(message);
 		this.partialOutput = partialOutput;
-		if (Error.captureStackTrace) Error.captureStackTrace(this, ModelAbortError);
+	}
+};
+/**
+* Error class representing a context window overflow in a language model operation.
+*
+* This error is thrown when the combined input to a language model (such as prompt tokens,
+* historical messages, and/or instructions) exceeds the maximum context window or token limit
+* that the model can process in a single request. Most models have defined upper limits for the number of
+* tokens or characters allowed in a context, and exceeding this limit will prevent
+* the operation from proceeding.
+*
+* The {@link ContextOverflowError} extends the {@link LangChainError} base class with
+* the marker `"context-overflow"`.
+*
+* @remarks
+* - Use this error to programmatically identify cases where a user request, prompt, or input
+*   sequence is too long to be handled by the target model.
+* - Model providers and framework integrations should throw this error if they detect
+*   a request cannot be processed due to its size.
+*
+* @example
+* ```typescript
+* try {
+*   await model.invoke(veryLongInput);
+* } catch (err) {
+*   if (ContextOverflowError.isInstance(err)) {
+*     // Handle overflow, e.g., prompt user to shorten input or truncate text
+*     console.warn("Model context overflow:", err.message);
+*   } else {
+*     throw err;
+*   }
+* }
+* ```
+*/
+var ContextOverflowError = class ContextOverflowError extends ns.brand(LangChainError, "context-overflow") {
+	name = "ContextOverflowError";
+	/**
+	* The underlying error that caused this {@link ContextOverflowError}, if any.
+	*
+	* This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.
+	* It allows error handlers to access or inspect the original error that led to the context overflow.
+	*/
+	cause;
+	constructor(message) {
+		super(message ?? "Input exceeded the model's context window.");
 	}
 	/**
-	* Type guard to check if an error is a ModelAbortError
+	* Creates a new {@link ContextOverflowError} instance from an existing error.
+	*
+	* This static utility copies the message from the provided error and
+	* attaches the original error as the {@link ContextOverflowError.cause} property,
+	* enabling error handlers to inspect or propagate the original failure.
+	*
+	* @param obj - The original error object causing the context overflow.
+	* @returns A new {@link ContextOverflowError} instance with the original error set as its cause.
+	*
+	* @example
+	* ```typescript
+	* try {
+	*   await model.invoke(input);
+	* } catch (err) {
+	*   throw ContextOverflowError.fromError(err);
+	* }
+	* ```
 	*/
-	static isInstance(error) {
-		return typeof error === "object" && error !== null && "name" in error && error.name === "ModelAbortError" && "lc_error_code" in error && error.lc_error_code === "MODEL_ABORTED";
+	static fromError(obj) {
+		const error = new ContextOverflowError(obj.message);
+		error.cause = obj;
+		return error;
 	}
 };
 
 //#endregion
+exports.ContextOverflowError = ContextOverflowError;
+exports.LangChainError = LangChainError;
 exports.ModelAbortError = ModelAbortError;
 exports.addLangChainErrorFields = addLangChainErrorFields;
 Object.defineProperty(exports, 'errors_exports', {
@@ -46,4 +171,5 @@ Object.defineProperty(exports, 'errors_exports', {
     return errors_exports;
   }
 });
+exports.ns = ns;
 //# sourceMappingURL=index.cjs.map

package/dist/errors/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["error: any","lc_error_code: LangChainErrorCodes","message: string","partialOutput?: AIMessageChunk","error: unknown"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { AIMessageChunk } from \"../messages/ai.js\";\n\nexport type LangChainErrorCodes =\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\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/**\n * Error thrown when a model invocation is aborted via an AbortSignal.\n * Contains any partial output that was generated before the abort.\n */\nexport class ModelAbortError extends Error {\n  readonly name = \"ModelAbortError\";\n\n  readonly lc_error_code = \"MODEL_ABORTED\";\n\n  /**\n   * The partial message output that was accumulated before the abort.\n   * This allows callers to access whatever content was generated\n   * before the operation was cancelled.\n   */\n  readonly partialOutput?: AIMessageChunk;\n\n  constructor(message: string, partialOutput?: AIMessageChunk) {\n    super(message);\n    this.partialOutput = partialOutput;\n    // Maintains proper stack trace for where our error was thrown (only available on V8)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ModelAbortError);\n    }\n  }\n\n  /**\n   * Type guard to check if an error is a ModelAbortError\n   */\n  static isInstance(error: unknown): error is ModelAbortError {\n    return (\n      typeof error === \"object\" &&\n      error !== null &&\n      \"name\" in error &&\n      error.name === \"ModelAbortError\" &&\n      \"lc_error_code\" in error &&\n      error.lc_error_code === \"MODEL_ABORTED\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;AAcA,SAAgB,wBACdA,OACAC,eACA;CACC,MAAc,gBAAgB;CAC/B,MAAM,UAAU,GAAG,MAAM,QAAQ,oFAAoF,EAAE,cAAc,GAAG,CAAC;AACzI,QAAO;AACR;;;;;AAMD,IAAa,kBAAb,MAAa,wBAAwB,MAAM;CACzC,AAAS,OAAO;CAEhB,AAAS,gBAAgB;;;;;;CAOzB,AAAS;CAET,YAAYC,SAAiBC,eAAgC;EAC3D,MAAM,QAAQ;EACd,KAAK,gBAAgB;AAErB,MAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,gBAAgB;CAEjD;;;;CAKD,OAAO,WAAWC,OAA0C;AAC1D,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,qBACf,mBAAmB,SACnB,MAAM,kBAAkB;CAE3B;AACF"}
+{"version":3,"file":"index.cjs","names":["baseNs"],"sources":["../../src/errors/index.ts"],"sourcesContent":["/* eslint-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/**\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  }\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  }\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;AACA,CAAC,MAAc,gBAAgB;AAC/B,OAAM,UAAU,GAAG,MAAM,QAAQ,sFAAsF,cAAc;AACrI,QAAO;;;AAIT,MAAa,KAAKA,qBAAO,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;AAoBrC,IAAa,iBAAb,cAAoC,GAAG,MAAM,MAAM,CAAC;CAClD,AAAS,OAAe;CAExB,YAAY,SAAkB;AAC5B,QAAM,QAAQ;AACd,MAAI,MAAM,kBACR,OAAM,kBAAkB,MAAM,KAAK,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCrD,IAAa,kBAAb,cAAqC,GAAG,MAAM,gBAAgB,cAAc,CAAC;CAC3E,AAAS,OAAO;;;;;CAMhB,AAAS;;;;;;;CAQT,YAAY,SAAiB,eAAgC;AAC3D,QAAM,QAAQ;AACd,OAAK,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCzB,IAAa,uBAAb,MAAa,6BAA6B,GAAG,MAC3C,gBACA,mBACD,CAAC;CACA,AAAS,OAAO;;;;;;;CAQhB;CAEA,YAAY,SAAkB;AAC5B,QAAM,WAAW,6CAA6C;;;;;;;;;;;;;;;;;;;;;CAsBhE,OAAO,UAAU,KAAkC;EACjD,MAAM,QAAQ,IAAI,qBAAqB,IAAI,QAAQ;AACnD,QAAM,QAAQ;AACd,SAAO"}

package/dist/errors/index.d.cts

@@ -1,27 +1,150 @@
 import { AIMessageChunk } from "../messages/ai.cjs";
+import { Namespace } from "../utils/namespace.cjs";
 
 //#region src/errors/index.d.ts
-type LangChainErrorCodes = "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
+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;
+/** The error namespace for all LangChain errors */
+declare const ns: Namespace;
+declare const LangChainError_base: ErrorConstructor & {
+  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
+};
 /**
- * Error thrown when a model invocation is aborted via an AbortSignal.
- * Contains any partial output that was generated before the abort.
+ * Base error class for all LangChain errors.
+ *
+ * All LangChain error classes should extend this class (directly or
+ * indirectly). Use `LangChainError.isInstance(obj)` to check if an
+ * object is any LangChain error.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke("hello");
+ * } catch (error) {
+ *   if (LangChainError.isInstance(error)) {
+ *     console.log("Got a LangChain error:", error.message);
+ *   }
+ * }
+ * ```
  */
-declare class ModelAbortError extends Error {
+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>;
+};
+/**
+ * Error class representing an aborted model operation in LangChain.
+ *
+ * This error is thrown when a model operation (such as invocation, streaming, or batching)
+ * is cancelled before it completes, commonly due to a user-initiated abort signal
+ * (e.g., via an AbortController) or an upstream cancellation event.
+ *
+ * The ModelAbortError provides access to any partial output the model may have produced
+ * before the operation was interrupted, which can be useful for resuming work, debugging,
+ * or presenting incomplete results to users.
+ *
+ * @remarks
+ * - The `partialOutput` field includes message content that was generated prior to the abort,
+ *   such as a partial AIMessageChunk.
+ * - This error extends the {@link LangChainError} base class with the marker `"model-abort"`.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke(input, { signal: abortController.signal });
+ * } catch (err) {
+ *   if (ModelAbortError.isInstance(err)) {
+ *     // Handle user cancellation, check err.partialOutput if needed
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+declare class ModelAbortError extends ModelAbortError_base {
   readonly name = "ModelAbortError";
-  readonly lc_error_code = "MODEL_ABORTED";
   /**
-   * The partial message output that was accumulated before the abort.
-   * This allows callers to access whatever content was generated
-   * before the operation was cancelled.
+   * The partial message output that was produced before the operation was aborted.
+   * This is typically an AIMessageChunk, or could be undefined if no output was available.
    */
   readonly partialOutput?: AIMessageChunk;
+  /**
+   * Constructs a new ModelAbortError instance.
+   *
+   * @param message - A human-readable message describing the abort event.
+   * @param partialOutput - Any partial model output generated before the abort (optional).
+   */
   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>;
+};
+/**
+ * Error class representing a context window overflow in a language model operation.
+ *
+ * This error is thrown when the combined input to a language model (such as prompt tokens,
+ * historical messages, and/or instructions) exceeds the maximum context window or token limit
+ * that the model can process in a single request. Most models have defined upper limits for the number of
+ * tokens or characters allowed in a context, and exceeding this limit will prevent
+ * the operation from proceeding.
+ *
+ * The {@link ContextOverflowError} extends the {@link LangChainError} base class with
+ * the marker `"context-overflow"`.
+ *
+ * @remarks
+ * - Use this error to programmatically identify cases where a user request, prompt, or input
+ *   sequence is too long to be handled by the target model.
+ * - Model providers and framework integrations should throw this error if they detect
+ *   a request cannot be processed due to its size.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke(veryLongInput);
+ * } catch (err) {
+ *   if (ContextOverflowError.isInstance(err)) {
+ *     // Handle overflow, e.g., prompt user to shorten input or truncate text
+ *     console.warn("Model context overflow:", err.message);
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+declare class ContextOverflowError extends ContextOverflowError_base {
+  readonly name = "ContextOverflowError";
+  /**
+   * The underlying error that caused this {@link ContextOverflowError}, if any.
+   *
+   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.
+   * It allows error handlers to access or inspect the original error that led to the context overflow.
+   */
+  cause?: Error;
+  constructor(message?: string);
   /**
-   * Type guard to check if an error is a ModelAbortError
+   * Creates a new {@link ContextOverflowError} instance from an existing error.
+   *
+   * This static utility copies the message from the provided error and
+   * attaches the original error as the {@link ContextOverflowError.cause} property,
+   * enabling error handlers to inspect or propagate the original failure.
+   *
+   * @param obj - The original error object causing the context overflow.
+   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await model.invoke(input);
+   * } catch (err) {
+   *   throw ContextOverflowError.fromError(err);
+   * }
+   * ```
    */
-  static isInstance(error: unknown): error is ModelAbortError;
+  static fromError(obj: Error): ContextOverflowError;
 }
 //#endregion
-export { LangChainErrorCodes, ModelAbortError, addLangChainErrorFields };
+export { ContextOverflowError, LangChainError, LangChainErrorCodes, ModelAbortError, addLangChainErrorFields, ns };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["AIMessageChunk","LangChainErrorCodes","addLangChainErrorFields","ModelAbortError","Error"],"sources":["../../src/errors/index.d.ts"],"sourcesContent":["import type { AIMessageChunk } from \"../messages/ai.js\";\nexport type LangChainErrorCodes = \"INVALID_PROMPT_INPUT\" | \"INVALID_TOOL_RESULTS\" | \"MESSAGE_COERCION_FAILURE\" | \"MODEL_AUTHENTICATION\" | \"MODEL_NOT_FOUND\" | \"MODEL_RATE_LIMIT\" | \"OUTPUT_PARSING_FAILURE\" | \"MODEL_ABORTED\";\nexport declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;\n/**\n * Error thrown when a model invocation is aborted via an AbortSignal.\n * Contains any partial output that was generated before the abort.\n */\nexport declare class ModelAbortError extends Error {\n    readonly name = \"ModelAbortError\";\n    readonly lc_error_code = \"MODEL_ABORTED\";\n    /**\n     * The partial message output that was accumulated before the abort.\n     * This allows callers to access whatever content was generated\n     * before the operation was cancelled.\n     */\n    readonly partialOutput?: AIMessageChunk;\n    constructor(message: string, partialOutput?: AIMessageChunk);\n    /**\n     * Type guard to check if an error is a ModelAbortError\n     */\n    static isInstance(error: unknown): error is ModelAbortError;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;KACYC,mBAAAA;iBACYC,uBAAAA,4BAAmDD;AAD3E;AACA;AAKA;;AASiDD,cAT5BG,eAAAA,SAAwBC,KAAAA,CASIJ;EAIDG,SAAAA,IAAAA,GAAAA,iBAAAA;EAbHC,SAAAA,aAAAA,GAAAA,eAAAA;EAAK;;;;;2BAQrBJ;+CACoBA;;;;8CAIDG"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/errors/index.ts"],"mappings":";;;;KAKY,mBAAA;;iBAYI,uBAAA,CACd,KAAA,OACA,aAAA,EAAe,mBAAA;AAdjB;AAAA,cAsBa,EAAA,EAAwB,SAAA;AAAA,cAAC,mBAAA;;;AAVtC;;;;;;;;;AAUA;;;;;AAAsC;;;;AAVtC,cA8Ba,cAAA,SAAuB,mBAAA;EAAA,SACzB,IAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMb,oBAAA;;;;;;;;;;;;;AATD;;;;;;;;;;AASC;;;;;;;;;cA+BY,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA;;;;;WAMA,aAAA,GAAgB,cAAA;;;;;;AAP3B;EAeE,WAAA,CAAY,OAAA,UAAiB,aAAA,GAAgB,cAAA;AAAA;AAAA,cAI9C,yBAAA;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;cAkCY,oBAAA,SAA6B,yBAAA;EAAA,SAI/B,IAAA;EAJuB;;;;;;EAYhC,KAAA,GAAQ,KAAA;EAER,WAAA,CAAY,OAAA;EAd4B;;;;;;;;;;;;;;;;;;;EAAA,OAqCjC,SAAA,CAAU,GAAA,EAAK,KAAA,GAAQ,oBAAA;AAAA"}

package/dist/errors/index.d.ts

@@ -1,27 +1,150 @@
 import { AIMessageChunk } from "../messages/ai.js";
+import { Namespace } from "../utils/namespace.js";
 
 //#region src/errors/index.d.ts
-type LangChainErrorCodes = "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE" | "MODEL_ABORTED";
+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;
+/** The error namespace for all LangChain errors */
+declare const ns: Namespace;
+declare const LangChainError_base: ErrorConstructor & {
+  isInstance: <T extends abstract new (...args: any[]) => any>(this: T, obj: unknown) => obj is InstanceType<T>;
+};
 /**
- * Error thrown when a model invocation is aborted via an AbortSignal.
- * Contains any partial output that was generated before the abort.
+ * Base error class for all LangChain errors.
+ *
+ * All LangChain error classes should extend this class (directly or
+ * indirectly). Use `LangChainError.isInstance(obj)` to check if an
+ * object is any LangChain error.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke("hello");
+ * } catch (error) {
+ *   if (LangChainError.isInstance(error)) {
+ *     console.log("Got a LangChain error:", error.message);
+ *   }
+ * }
+ * ```
  */
-declare class ModelAbortError extends Error {
+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>;
+};
+/**
+ * Error class representing an aborted model operation in LangChain.
+ *
+ * This error is thrown when a model operation (such as invocation, streaming, or batching)
+ * is cancelled before it completes, commonly due to a user-initiated abort signal
+ * (e.g., via an AbortController) or an upstream cancellation event.
+ *
+ * The ModelAbortError provides access to any partial output the model may have produced
+ * before the operation was interrupted, which can be useful for resuming work, debugging,
+ * or presenting incomplete results to users.
+ *
+ * @remarks
+ * - The `partialOutput` field includes message content that was generated prior to the abort,
+ *   such as a partial AIMessageChunk.
+ * - This error extends the {@link LangChainError} base class with the marker `"model-abort"`.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke(input, { signal: abortController.signal });
+ * } catch (err) {
+ *   if (ModelAbortError.isInstance(err)) {
+ *     // Handle user cancellation, check err.partialOutput if needed
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+declare class ModelAbortError extends ModelAbortError_base {
   readonly name = "ModelAbortError";
-  readonly lc_error_code = "MODEL_ABORTED";
   /**
-   * The partial message output that was accumulated before the abort.
-   * This allows callers to access whatever content was generated
-   * before the operation was cancelled.
+   * The partial message output that was produced before the operation was aborted.
+   * This is typically an AIMessageChunk, or could be undefined if no output was available.
    */
   readonly partialOutput?: AIMessageChunk;
+  /**
+   * Constructs a new ModelAbortError instance.
+   *
+   * @param message - A human-readable message describing the abort event.
+   * @param partialOutput - Any partial model output generated before the abort (optional).
+   */
   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>;
+};
+/**
+ * Error class representing a context window overflow in a language model operation.
+ *
+ * This error is thrown when the combined input to a language model (such as prompt tokens,
+ * historical messages, and/or instructions) exceeds the maximum context window or token limit
+ * that the model can process in a single request. Most models have defined upper limits for the number of
+ * tokens or characters allowed in a context, and exceeding this limit will prevent
+ * the operation from proceeding.
+ *
+ * The {@link ContextOverflowError} extends the {@link LangChainError} base class with
+ * the marker `"context-overflow"`.
+ *
+ * @remarks
+ * - Use this error to programmatically identify cases where a user request, prompt, or input
+ *   sequence is too long to be handled by the target model.
+ * - Model providers and framework integrations should throw this error if they detect
+ *   a request cannot be processed due to its size.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await model.invoke(veryLongInput);
+ * } catch (err) {
+ *   if (ContextOverflowError.isInstance(err)) {
+ *     // Handle overflow, e.g., prompt user to shorten input or truncate text
+ *     console.warn("Model context overflow:", err.message);
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+declare class ContextOverflowError extends ContextOverflowError_base {
+  readonly name = "ContextOverflowError";
+  /**
+   * The underlying error that caused this {@link ContextOverflowError}, if any.
+   *
+   * This property is optionally set when wrapping a lower-level error using {@link ContextOverflowError.fromError}.
+   * It allows error handlers to access or inspect the original error that led to the context overflow.
+   */
+  cause?: Error;
+  constructor(message?: string);
   /**
-   * Type guard to check if an error is a ModelAbortError
+   * Creates a new {@link ContextOverflowError} instance from an existing error.
+   *
+   * This static utility copies the message from the provided error and
+   * attaches the original error as the {@link ContextOverflowError.cause} property,
+   * enabling error handlers to inspect or propagate the original failure.
+   *
+   * @param obj - The original error object causing the context overflow.
+   * @returns A new {@link ContextOverflowError} instance with the original error set as its cause.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await model.invoke(input);
+   * } catch (err) {
+   *   throw ContextOverflowError.fromError(err);
+   * }
+   * ```
    */
-  static isInstance(error: unknown): error is ModelAbortError;
+  static fromError(obj: Error): ContextOverflowError;
 }
 //#endregion
-export { LangChainErrorCodes, ModelAbortError, addLangChainErrorFields };
+export { ContextOverflowError, LangChainError, LangChainErrorCodes, ModelAbortError, addLangChainErrorFields, ns };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["AIMessageChunk","LangChainErrorCodes","addLangChainErrorFields","ModelAbortError","Error"],"sources":["../../src/errors/index.d.ts"],"sourcesContent":["import type { AIMessageChunk } from \"../messages/ai.js\";\nexport type LangChainErrorCodes = \"INVALID_PROMPT_INPUT\" | \"INVALID_TOOL_RESULTS\" | \"MESSAGE_COERCION_FAILURE\" | \"MODEL_AUTHENTICATION\" | \"MODEL_NOT_FOUND\" | \"MODEL_RATE_LIMIT\" | \"OUTPUT_PARSING_FAILURE\" | \"MODEL_ABORTED\";\nexport declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;\n/**\n * Error thrown when a model invocation is aborted via an AbortSignal.\n * Contains any partial output that was generated before the abort.\n */\nexport declare class ModelAbortError extends Error {\n    readonly name = \"ModelAbortError\";\n    readonly lc_error_code = \"MODEL_ABORTED\";\n    /**\n     * The partial message output that was accumulated before the abort.\n     * This allows callers to access whatever content was generated\n     * before the operation was cancelled.\n     */\n    readonly partialOutput?: AIMessageChunk;\n    constructor(message: string, partialOutput?: AIMessageChunk);\n    /**\n     * Type guard to check if an error is a ModelAbortError\n     */\n    static isInstance(error: unknown): error is ModelAbortError;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;KACYC,mBAAAA;iBACYC,uBAAAA,4BAAmDD;AAD3E;AACA;AAKA;;AASiDD,cAT5BG,eAAAA,SAAwBC,KAAAA,CASIJ;EAIDG,SAAAA,IAAAA,GAAAA,iBAAAA;EAbHC,SAAAA,aAAAA,GAAAA,eAAAA;EAAK;;;;;2BAQrBJ;+CACoBA;;;;8CAIDG"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/errors/index.ts"],"mappings":";;;;KAKY,mBAAA;;iBAYI,uBAAA,CACd,KAAA,OACA,aAAA,EAAe,mBAAA;AAdjB;AAAA,cAsBa,EAAA,EAAwB,SAAA;AAAA,cAAC,mBAAA;;;AAVtC;;;;;;;;;AAUA;;;;;AAAsC;;;;AAVtC,cA8Ba,cAAA,SAAuB,mBAAA;EAAA,SACzB,IAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMb,oBAAA;;;;;;;;;;;;;AATD;;;;;;;;;;AASC;;;;;;;;;cA+BY,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA;;;;;WAMA,aAAA,GAAgB,cAAA;;;;;;AAP3B;EAeE,WAAA,CAAY,OAAA,UAAiB,aAAA,GAAgB,cAAA;AAAA;AAAA,cAI9C,yBAAA;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;cAkCY,oBAAA,SAA6B,yBAAA;EAAA,SAI/B,IAAA;EAJuB;;;;;;EAYhC,KAAA,GAAQ,KAAA;EAER,WAAA,CAAY,OAAA;EAd4B;;;;;;;;;;;;;;;;;;;EAAA,OAqCjC,SAAA,CAAU,GAAA,EAAK,KAAA,GAAQ,oBAAA;AAAA"}