@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/testing/fake_model_builder.cjs

@@ -0,0 +1,226 @@
+const require_base = require("../messages/base.cjs");
+const require_ai = require("../messages/ai.cjs");
+const require_base$1 = require("../runnables/base.cjs");
+require("../messages/index.cjs");
+const require_language_models_chat_models = require("../language_models/chat_models.cjs");
+//#region src/testing/fake_model_builder.ts
+function deriveContent(messages) {
+	return messages.map((m) => m.text).filter(Boolean).join("-");
+}
+let idCounter = 0;
+function nextToolCallId() {
+	idCounter += 1;
+	return `fake_tc_${idCounter}`;
+}
+/**
+* A fake chat model for testing, created via {@link fakeModel}.
+*
+* Queue responses with `.respond()` and `.respondWithTools()`, then
+* pass the instance directly wherever a chat model is expected.
+* Responses are consumed in first-in-first-out order — one per `invoke()` call.
+* When all queued responses are consumed, further invocations throw.
+*/
+var FakeBuiltModel = class FakeBuiltModel extends require_language_models_chat_models.BaseChatModel {
+	queue = [];
+	_alwaysThrowError;
+	_structuredResponseValue;
+	_tools = [];
+	_state = {
+		callIndex: 0,
+		calls: []
+	};
+	/**
+	* All invocations recorded by this model, in order.
+	* Each entry contains the `messages` array and `options` that were
+	* passed to `invoke()`.
+	*/
+	get calls() {
+		return this._state.calls;
+	}
+	/**
+	* The number of times this model has been invoked.
+	*/
+	get callCount() {
+		return this._state.calls.length;
+	}
+	constructor() {
+		super({});
+	}
+	_llmType() {
+		return "fake-model-builder";
+	}
+	_combineLLMOutput() {
+		return [];
+	}
+	/**
+	* Enqueue a response that the model will return on its next invocation.
+	* @param entry A {@link BaseMessage} to return, an `Error` to throw, or
+	*   a factory `(messages) => BaseMessage | Error` for dynamic responses.
+	* @returns `this`, for chaining.
+	*/
+	respond(entry) {
+		if (typeof entry === "function") this.queue.push({
+			kind: "factory",
+			factory: entry
+		});
+		else if (require_base.BaseMessage.isInstance(entry)) this.queue.push({
+			kind: "message",
+			message: entry
+		});
+		else this.queue.push({
+			kind: "error",
+			error: entry
+		});
+		return this;
+	}
+	/**
+	* Enqueue an {@link AIMessage} that carries the given tool calls.
+	* Content is derived from the input messages at invocation time.
+	* @param toolCalls Array of tool calls. Each entry needs `name` and
+	*   `args`; `id` is optional and auto-generated when omitted.
+	* @returns `this`, for chaining.
+	*/
+	respondWithTools(toolCalls) {
+		this.queue.push({
+			kind: "toolCalls",
+			toolCalls: toolCalls.map((tc) => ({
+				name: tc.name,
+				args: tc.args,
+				id: tc.id ?? nextToolCallId(),
+				type: "tool_call"
+			}))
+		});
+		return this;
+	}
+	/**
+	* Make every invocation throw the given error, regardless of the queue.
+	* @param error The error to throw.
+	* @returns `this`, for chaining.
+	*/
+	alwaysThrow(error) {
+		this._alwaysThrowError = error;
+		return this;
+	}
+	/**
+	* Set the value that {@link withStructuredOutput} will resolve to.
+	* @param value The structured object to return.
+	* @returns `this`, for chaining.
+	*/
+	structuredResponse(value) {
+		this._structuredResponseValue = value;
+		return this;
+	}
+	/**
+	* Bind tools to the model. Returns a new model that shares the same
+	* response queue and call history.
+	* @param tools The tools to bind, as {@link StructuredTool} instances or
+	*   plain {@link ToolSpec} objects.
+	* @returns A new RunnableBinding with the tools bound.
+	*/
+	bindTools(tools) {
+		const merged = [...this._tools, ...tools];
+		const next = new FakeBuiltModel();
+		next.queue = this.queue;
+		next._alwaysThrowError = this._alwaysThrowError;
+		next._structuredResponseValue = this._structuredResponseValue;
+		next._tools = merged;
+		next._state = this._state;
+		return next.withConfig({});
+	}
+	/**
+	* Returns a {@link Runnable} that produces the {@link structuredResponse}
+	* value. The schema argument is accepted for compatibility but ignored.
+	* @param _params Schema or params (ignored).
+	* @param _config Options (ignored).
+	* @returns A Runnable that resolves to the structured response value.
+	*/
+	withStructuredOutput(_params, _config) {
+		const { _structuredResponseValue } = this;
+		return require_base$1.RunnableLambda.from(async () => {
+			return _structuredResponseValue;
+		});
+	}
+	async _generate(messages, options, _runManager) {
+		this._state.calls.push({
+			messages: [...messages],
+			options
+		});
+		const currentCallIndex = this._state.callIndex;
+		this._state.callIndex += 1;
+		if (this._alwaysThrowError) throw this._alwaysThrowError;
+		const entry = this.queue[currentCallIndex];
+		if (!entry) throw new Error(`FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`);
+		if (entry.kind === "error") throw entry.error;
+		if (entry.kind === "factory") {
+			const result = entry.factory(messages);
+			if (!require_base.BaseMessage.isInstance(result)) throw result;
+			return { generations: [{
+				text: "",
+				message: result
+			}] };
+		}
+		if (entry.kind === "message") return { generations: [{
+			text: "",
+			message: entry.message
+		}] };
+		const content = deriveContent(messages);
+		return {
+			generations: [{
+				text: content,
+				message: new require_ai.AIMessage({
+					content,
+					id: currentCallIndex.toString(),
+					tool_calls: entry.toolCalls.length > 0 ? entry.toolCalls.map((tc) => ({
+						...tc,
+						type: "tool_call"
+					})) : void 0
+				})
+			}],
+			llmOutput: {}
+		};
+	}
+};
+/**
+* Creates a new {@link FakeBuiltModel} for testing.
+*
+* Returns a chainable builder — queue responses, then pass the model
+* anywhere a chat model is expected. Responses are consumed in FIFO
+* order, one per `invoke()` call.
+*
+* ## API summary
+*
+* | Method | Description |
+* | --- | --- |
+* | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |
+* | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |
+* | `.respond(error)` | Queue an `Error` to throw on the next invocation. |
+* | `.respond(factory)` | Queue a function `(messages) => BaseMessage \| Error` for dynamic responses. |
+* | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |
+* | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |
+* | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |
+* | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |
+* | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |
+* | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |
+* | `.callCount` | Number of times the model has been invoked. |
+*
+* @example
+* ```typescript
+* const model = fakeModel()
+*   .respondWithTools([{ name: "search", args: { query: "weather" } }])
+*   .respond(new AIMessage("Sunny and warm."));
+*
+* const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
+* // r1.tool_calls[0].name === "search"
+*
+* const r2 = await model.invoke([new HumanMessage("Thanks")]);
+* // r2.content === "Sunny and warm."
+* ```
+*/
+function fakeModel() {
+	return new FakeBuiltModel();
+}
+//#endregion
+exports.FakeBuiltModel = FakeBuiltModel;
+exports.fakeModel = fakeModel;
+
+//# sourceMappingURL=fake_model_builder.cjs.map

package/dist/testing/fake_model_builder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../messages/index.js\";\nimport type { ToolCall } from \"../messages/tool.js\";\nimport type { ChatResult } from \"../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../runnables/base.js\";\nimport { StructuredTool } from \"../tools/index.js\";\nimport type { InteropZodType } from \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\n   */\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\n   */\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\n   */\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\n   */\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":"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"}

package/dist/testing/fake_model_builder.d.cts

@@ -0,0 +1,137 @@
+import { BaseMessage } from "../messages/base.cjs";
+import { AIMessageChunk } from "../messages/ai.cjs";
+import { MessageStructure, MessageToolSet } from "../messages/message.cjs";
+import { ChatResult } from "../outputs.cjs";
+import { InteropZodType } from "../utils/types/zod.cjs";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.cjs";
+import { Runnable } from "../runnables/base.cjs";
+import { BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "../language_models/base.cjs";
+import { StructuredTool } from "../tools/index.cjs";
+import { BaseChatModel, BaseChatModelCallOptions } from "../language_models/chat_models.cjs";
+import { ToolSpec } from "../utils/testing/chat_models.cjs";
+
+//#region src/testing/fake_model_builder.d.ts
+type ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;
+interface FakeModelCall {
+  messages: BaseMessage[];
+  options: any;
+}
+/**
+ * A fake chat model for testing, created via {@link fakeModel}.
+ *
+ * Queue responses with `.respond()` and `.respondWithTools()`, then
+ * pass the instance directly wherever a chat model is expected.
+ * Responses are consumed in first-in-first-out order — one per `invoke()` call.
+ * When all queued responses are consumed, further invocations throw.
+ */
+declare class FakeBuiltModel extends BaseChatModel {
+  private queue;
+  private _alwaysThrowError;
+  private _structuredResponseValue;
+  private _tools;
+  private _state;
+  /**
+   * All invocations recorded by this model, in order.
+   * Each entry contains the `messages` array and `options` that were
+   * passed to `invoke()`.
+   */
+  get calls(): FakeModelCall[];
+  /**
+   * The number of times this model has been invoked.
+   */
+  get callCount(): number;
+  constructor();
+  _llmType(): string;
+  _combineLLMOutput(): never[];
+  /**
+   * Enqueue a response that the model will return on its next invocation.
+   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or
+   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.
+   * @returns `this`, for chaining.
+   */
+  respond(entry: BaseMessage | Error | ResponseFactory): this;
+  /**
+   * Enqueue an {@link AIMessage} that carries the given tool calls.
+   * Content is derived from the input messages at invocation time.
+   * @param toolCalls Array of tool calls. Each entry needs `name` and
+   *   `args`; `id` is optional and auto-generated when omitted.
+   * @returns `this`, for chaining.
+   */
+  respondWithTools(toolCalls: Array<{
+    name: string;
+    args: Record<string, any>;
+    id?: string;
+  }>): this;
+  /**
+   * Make every invocation throw the given error, regardless of the queue.
+   * @param error The error to throw.
+   * @returns `this`, for chaining.
+   */
+  alwaysThrow(error: Error): this;
+  /**
+   * Set the value that {@link withStructuredOutput} will resolve to.
+   * @param value The structured object to return.
+   * @returns `this`, for chaining.
+   */
+  structuredResponse(value: Record<string, any>): this;
+  /**
+   * Bind tools to the model. Returns a new model that shares the same
+   * response queue and call history.
+   * @param tools The tools to bind, as {@link StructuredTool} instances or
+   *   plain {@link ToolSpec} objects.
+   * @returns A new RunnableBinding with the tools bound.
+   */
+  bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk<MessageStructure<MessageToolSet>>, BaseChatModelCallOptions>;
+  /**
+   * Returns a {@link Runnable} that produces the {@link structuredResponse}
+   * value. The schema argument is accepted for compatibility but ignored.
+   * @param _params Schema or params (ignored).
+   * @param _config Options (ignored).
+   * @returns A Runnable that resolves to the structured response value.
+   */
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, boolean> | InteropZodType<RunOutput> | Record<string, any>, _config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    raw: BaseMessage;
+    parsed: RunOutput;
+  }>;
+  _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+}
+/**
+ * Creates a new {@link FakeBuiltModel} for testing.
+ *
+ * Returns a chainable builder — queue responses, then pass the model
+ * anywhere a chat model is expected. Responses are consumed in FIFO
+ * order, one per `invoke()` call.
+ *
+ * ## API summary
+ *
+ * | Method | Description |
+ * | --- | --- |
+ * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |
+ * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |
+ * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |
+ * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \| Error` for dynamic responses. |
+ * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |
+ * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |
+ * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |
+ * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |
+ * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |
+ * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |
+ * | `.callCount` | Number of times the model has been invoked. |
+ *
+ * @example
+ * ```typescript
+ * const model = fakeModel()
+ *   .respondWithTools([{ name: "search", args: { query: "weather" } }])
+ *   .respond(new AIMessage("Sunny and warm."));
+ *
+ * const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
+ * // r1.tool_calls[0].name === "search"
+ *
+ * const r2 = await model.invoke([new HumanMessage("Thanks")]);
+ * // r2.content === "Sunny and warm."
+ * ```
+ */
+declare function fakeModel(): FakeBuiltModel;
+//#endregion
+export { FakeBuiltModel, fakeModel };
+//# sourceMappingURL=fake_model_builder.d.cts.map

package/dist/testing/fake_model_builder.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake_model_builder.d.cts","names":[],"sources":["../../src/testing/fake_model_builder.ts"],"mappings":";;;;;;;;;;;;;KAmBK,eAAA,IAAmB,QAAA,EAAU,WAAA,OAAkB,WAAA,GAAc,KAAA;AAAA,UAQxD,aAAA;EACR,QAAA,EAAU,WAAA;EACV,OAAA;AAAA;AAZ8D;;;;;;;;AAAA,cAyCnD,cAAA,SAAuB,aAAA;EAAA,QAC1B,KAAA;EAAA,QAEA,iBAAA;EAAA,QAEA,wBAAA;EAAA,QAEA,MAAA;EAAA,QAEA,MAAA;EAxCA;;;;;EAAA,IA+CJ,KAAA,CAAA,GAAS,aAAA;EA7Cb;;;EAAA,IAoDI,SAAA,CAAA;EAIJ,WAAA,CAAA;EAIA,QAAA,CAAA;EAIA,iBAAA,CAAA;EAUe;;;;;;EAAf,OAAA,CAAQ,KAAA,EAAO,WAAA,GAAc,KAAA,GAAQ,eAAA;EA4DnB;;;;;;;EA1ClB,gBAAA,CACE,SAAA,EAAW,KAAA;IAAQ,IAAA;IAAc,IAAA,EAAM,MAAA;IAAqB,EAAA;EAAA;EAiEzC;;;;;EA9CrB,WAAA,CAAY,KAAA,EAAO,KAAA;EAkDf;;;;;EAxCJ,kBAAA,CAAmB,KAAA,EAAO,MAAA;EAsDV;;;;;;;EA1ChB,SAAA,CAAU,KAAA,GAAQ,cAAA,GAAiB,QAAA,MAAW,QAAA,CAAA,sBAAA,EAAA,cAAA,CAAA,gBAAA,CAAA,cAAA,IAAA,wBAAA;EAtGtC;;;;;;;EAyHR,oBAAA,mBACoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,OAAA,EACI,4BAAA,CAA6B,SAAA,aAC7B,cAAA,CAAe,SAAA,IACf,MAAA,eACJ,OAAA,GAAU,6BAAA,YAER,QAAA,CAAS,sBAAA,EAAwB,SAAA,IACjC,QAAA,CACE,sBAAA;IACE,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAQ5B,SAAA,CACJ,QAAA,EAAU,WAAA,IACV,OAAA,8BACA,WAAA,GAAc,wBAAA,GACb,OAAA,CAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6FG,SAAA,CAAA,GAAa,cAAA"}

package/dist/testing/fake_model_builder.d.ts

@@ -0,0 +1,137 @@
+import { BaseMessage } from "../messages/base.js";
+import { AIMessageChunk } from "../messages/ai.js";
+import { MessageStructure, MessageToolSet } from "../messages/message.js";
+import { ChatResult } from "../outputs.js";
+import { InteropZodType } from "../utils/types/zod.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { Runnable } from "../runnables/base.js";
+import { BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "../language_models/base.js";
+import { StructuredTool } from "../tools/index.js";
+import { BaseChatModel, BaseChatModelCallOptions } from "../language_models/chat_models.js";
+import { ToolSpec } from "../utils/testing/chat_models.js";
+
+//#region src/testing/fake_model_builder.d.ts
+type ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;
+interface FakeModelCall {
+  messages: BaseMessage[];
+  options: any;
+}
+/**
+ * A fake chat model for testing, created via {@link fakeModel}.
+ *
+ * Queue responses with `.respond()` and `.respondWithTools()`, then
+ * pass the instance directly wherever a chat model is expected.
+ * Responses are consumed in first-in-first-out order — one per `invoke()` call.
+ * When all queued responses are consumed, further invocations throw.
+ */
+declare class FakeBuiltModel extends BaseChatModel {
+  private queue;
+  private _alwaysThrowError;
+  private _structuredResponseValue;
+  private _tools;
+  private _state;
+  /**
+   * All invocations recorded by this model, in order.
+   * Each entry contains the `messages` array and `options` that were
+   * passed to `invoke()`.
+   */
+  get calls(): FakeModelCall[];
+  /**
+   * The number of times this model has been invoked.
+   */
+  get callCount(): number;
+  constructor();
+  _llmType(): string;
+  _combineLLMOutput(): never[];
+  /**
+   * Enqueue a response that the model will return on its next invocation.
+   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or
+   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.
+   * @returns `this`, for chaining.
+   */
+  respond(entry: BaseMessage | Error | ResponseFactory): this;
+  /**
+   * Enqueue an {@link AIMessage} that carries the given tool calls.
+   * Content is derived from the input messages at invocation time.
+   * @param toolCalls Array of tool calls. Each entry needs `name` and
+   *   `args`; `id` is optional and auto-generated when omitted.
+   * @returns `this`, for chaining.
+   */
+  respondWithTools(toolCalls: Array<{
+    name: string;
+    args: Record<string, any>;
+    id?: string;
+  }>): this;
+  /**
+   * Make every invocation throw the given error, regardless of the queue.
+   * @param error The error to throw.
+   * @returns `this`, for chaining.
+   */
+  alwaysThrow(error: Error): this;
+  /**
+   * Set the value that {@link withStructuredOutput} will resolve to.
+   * @param value The structured object to return.
+   * @returns `this`, for chaining.
+   */
+  structuredResponse(value: Record<string, any>): this;
+  /**
+   * Bind tools to the model. Returns a new model that shares the same
+   * response queue and call history.
+   * @param tools The tools to bind, as {@link StructuredTool} instances or
+   *   plain {@link ToolSpec} objects.
+   * @returns A new RunnableBinding with the tools bound.
+   */
+  bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk<MessageStructure<MessageToolSet>>, BaseChatModelCallOptions>;
+  /**
+   * Returns a {@link Runnable} that produces the {@link structuredResponse}
+   * value. The schema argument is accepted for compatibility but ignored.
+   * @param _params Schema or params (ignored).
+   * @param _config Options (ignored).
+   * @returns A Runnable that resolves to the structured response value.
+   */
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, boolean> | InteropZodType<RunOutput> | Record<string, any>, _config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    raw: BaseMessage;
+    parsed: RunOutput;
+  }>;
+  _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+}
+/**
+ * Creates a new {@link FakeBuiltModel} for testing.
+ *
+ * Returns a chainable builder — queue responses, then pass the model
+ * anywhere a chat model is expected. Responses are consumed in FIFO
+ * order, one per `invoke()` call.
+ *
+ * ## API summary
+ *
+ * | Method | Description |
+ * | --- | --- |
+ * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |
+ * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |
+ * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |
+ * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \| Error` for dynamic responses. |
+ * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |
+ * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |
+ * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |
+ * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |
+ * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |
+ * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |
+ * | `.callCount` | Number of times the model has been invoked. |
+ *
+ * @example
+ * ```typescript
+ * const model = fakeModel()
+ *   .respondWithTools([{ name: "search", args: { query: "weather" } }])
+ *   .respond(new AIMessage("Sunny and warm."));
+ *
+ * const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
+ * // r1.tool_calls[0].name === "search"
+ *
+ * const r2 = await model.invoke([new HumanMessage("Thanks")]);
+ * // r2.content === "Sunny and warm."
+ * ```
+ */
+declare function fakeModel(): FakeBuiltModel;
+//#endregion
+export { FakeBuiltModel, fakeModel };
+//# sourceMappingURL=fake_model_builder.d.ts.map

package/dist/testing/fake_model_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake_model_builder.d.ts","names":[],"sources":["../../src/testing/fake_model_builder.ts"],"mappings":";;;;;;;;;;;;;KAmBK,eAAA,IAAmB,QAAA,EAAU,WAAA,OAAkB,WAAA,GAAc,KAAA;AAAA,UAQxD,aAAA;EACR,QAAA,EAAU,WAAA;EACV,OAAA;AAAA;AAZ8D;;;;;;;;AAAA,cAyCnD,cAAA,SAAuB,aAAA;EAAA,QAC1B,KAAA;EAAA,QAEA,iBAAA;EAAA,QAEA,wBAAA;EAAA,QAEA,MAAA;EAAA,QAEA,MAAA;EAxCA;;;;;EAAA,IA+CJ,KAAA,CAAA,GAAS,aAAA;EA7Cb;;;EAAA,IAoDI,SAAA,CAAA;EAIJ,WAAA,CAAA;EAIA,QAAA,CAAA;EAIA,iBAAA,CAAA;EAUe;;;;;;EAAf,OAAA,CAAQ,KAAA,EAAO,WAAA,GAAc,KAAA,GAAQ,eAAA;EA4DnB;;;;;;;EA1ClB,gBAAA,CACE,SAAA,EAAW,KAAA;IAAQ,IAAA;IAAc,IAAA,EAAM,MAAA;IAAqB,EAAA;EAAA;EAiEzC;;;;;EA9CrB,WAAA,CAAY,KAAA,EAAO,KAAA;EAkDf;;;;;EAxCJ,kBAAA,CAAmB,KAAA,EAAO,MAAA;EAsDV;;;;;;;EA1ChB,SAAA,CAAU,KAAA,GAAQ,cAAA,GAAiB,QAAA,MAAW,QAAA,CAAA,sBAAA,EAAA,cAAA,CAAA,gBAAA,CAAA,cAAA,IAAA,wBAAA;EAtGtC;;;;;;;EAyHR,oBAAA,mBACoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,OAAA,EACI,4BAAA,CAA6B,SAAA,aAC7B,cAAA,CAAe,SAAA,IACf,MAAA,eACJ,OAAA,GAAU,6BAAA,YAER,QAAA,CAAS,sBAAA,EAAwB,SAAA,IACjC,QAAA,CACE,sBAAA;IACE,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAQ5B,SAAA,CACJ,QAAA,EAAU,WAAA,IACV,OAAA,8BACA,WAAA,GAAc,wBAAA,GACb,OAAA,CAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6FG,SAAA,CAAA,GAAa,cAAA"}