@langchain/langgraph-sdk 1.9.4 → 1.9.6

package/dist/client/stream/handles/tools.d.cts

@@ -5,22 +5,68 @@ import { ToolsEvent } from "@langchain/protocol";
  * High-level outcome of a single tool call.
  */
 type ToolCallStatus = "running" | "finished" | "error";
+/** Shared metadata for assembled tool-call handles. */
+interface ToolCallBase<TName extends string = string, TInput = unknown> {
+  readonly name: TName;
+  readonly callId: string;
+  /**
+   * Pre-v1 alias for {@link callId}. Matches `ToolCallWithResult.id` and
+   * `ToolCall.id` on message-level tool calls.
+   */
+  readonly id: string;
+  readonly namespace: string[];
+  readonly input: TInput;
+  /**
+   * Pre-v1 alias for {@link input}. Matches `ToolCallFromTool` `args`.
+   */
+  readonly args: TInput;
+}
+/**
+ * Script-oriented tool handle from the client SDK (`ThreadStream.toolCalls`,
+ * subagent/subgraph projections). Completion and errors are surfaced only
+ * through {@link output}.
+ */
+interface ClientAssembledToolCall<TName extends string = string, TInput = unknown, TOutput = unknown> extends ToolCallBase<TName, TInput> {
+  readonly output: Promise<TOutput>;
+}
 /**
- * Assembled view of a single tool call lifecycle (`tool-started` →
- * optional `tool-output-delta` → `tool-finished` | `tool-error`).
+ * Reactive tool handle for framework bindings (`stream.toolCalls`,
+ * `useToolCalls`, `injectToolCalls`).
  *
- * Mirrors the in-process `ToolCallStream` interface so that remote
- * consumers get the same ergonomics.
+ * {@link status}, {@link error}, and {@link output} are plain values that
+ * the assembler updates in place as tool events arrive. That lets React,
+ * Vue, Svelte, and Angular re-render from a snapshot on each store tick
+ * without `await`, effects, or Suspense boundaries around a promise.
+ * {@link ClientAssembledToolCall} keeps a promise-based {@link output}
+ * instead for script consumers that read tool results sequentially.
+ *
+ * {@link output} is `null` while the call is running or after it fails;
+ * successful completion sets it to the parsed tool return value (objects
+ * and strings are unwrapped from ToolMessage wire envelopes when needed).
  */
-interface AssembledToolCall {
-  readonly name: string;
-  readonly callId: string;
-  readonly namespace: string[];
-  readonly input: unknown;
-  readonly output: Promise<unknown>;
-  readonly status: Promise<ToolCallStatus>;
-  readonly error: Promise<string | undefined>;
+interface AssembledToolCall<TName extends string = string, TInput = unknown, TOutput = unknown> extends ToolCallBase<TName, TInput> {
+  readonly output: TOutput | null;
+  readonly status: ToolCallStatus;
+  readonly error: string | undefined;
 }
+/**
+ * Parse wire-format tool payloads into structured values.
+ *
+ * Tool events may carry JSON-encoded object strings on the wire; this
+ * helper normalises them to plain objects for consumers. Non-JSON strings
+ * are returned unchanged.
+ */
+declare function parseToolPayload(value: unknown): unknown;
+/**
+ * Parse a `tool-finished` output payload into the tool's return value.
+ *
+ * Wire events often wrap structured tool results in a ToolMessage-shaped
+ * object (`{ type: "tool", content: "..." }`). This unwraps that envelope,
+ * JSON-decodes string content when possible, and leaves plain strings as-is.
+ * Returns `null` when a ToolMessage envelope is present but its content
+ * cannot be normalised.
+ */
+declare function parseToolOutput(value: unknown): unknown | null;
 //#endregion
-export { AssembledToolCall, ToolCallStatus };
+export { AssembledToolCall, ClientAssembledToolCall, ToolCallStatus, parseToolOutput, parseToolPayload };
 //# sourceMappingURL=tools.d.cts.map

package/dist/client/stream/handles/tools.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.cts","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"mappings":";;;;;AAUA;KAAY,cAAA;;;;AASZ;;;;UAAiB,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,MAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAAA,SACR,MAAA,EAAQ,OAAA,CAAQ,cAAA;EAAA,SAChB,KAAA,EAAO,OAAA;AAAA"}
+{"version":3,"file":"tools.d.cts","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"mappings":";;;;;AAUA;KAAY,cAAA;;UAGF,YAAA;EAAA,SACC,IAAA,EAAM,KAAA;EAAA,SACN,MAAA;EAFW;;;;EAAA,SAOX,EAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,EAAO,MAAA;EATK;;;EAAA,SAaZ,IAAA,EAAM,MAAA;AAAA;;;;;;UAQA,uBAAA,6EAIP,YAAA,CAAa,KAAA,EAAO,MAAA;EAAA,SACnB,MAAA,EAAQ,OAAA,CAAQ,OAAA;AAAA;AAL3B;;;;;;;;;;;;;;;AAAA,UAuBiB,iBAAA,6EAIP,YAAA,CAAa,KAAA,EAAO,MAAA;EAAA,SACnB,MAAA,EAAQ,OAAA;EAAA,SACR,MAAA,EAAQ,cAAA;EAAA,SACR,KAAA;AAAA;;;;;;;AA0CX;iBAAgB,gBAAA,CAAiB,KAAA;;;;AAsEjC;;;;;;iBAAgB,eAAA,CAAgB,KAAA"}

package/dist/client/stream/handles/tools.d.ts

@@ -5,22 +5,68 @@ import { ToolsEvent } from "@langchain/protocol";
  * High-level outcome of a single tool call.
  */
 type ToolCallStatus = "running" | "finished" | "error";
+/** Shared metadata for assembled tool-call handles. */
+interface ToolCallBase<TName extends string = string, TInput = unknown> {
+  readonly name: TName;
+  readonly callId: string;
+  /**
+   * Pre-v1 alias for {@link callId}. Matches `ToolCallWithResult.id` and
+   * `ToolCall.id` on message-level tool calls.
+   */
+  readonly id: string;
+  readonly namespace: string[];
+  readonly input: TInput;
+  /**
+   * Pre-v1 alias for {@link input}. Matches `ToolCallFromTool` `args`.
+   */
+  readonly args: TInput;
+}
+/**
+ * Script-oriented tool handle from the client SDK (`ThreadStream.toolCalls`,
+ * subagent/subgraph projections). Completion and errors are surfaced only
+ * through {@link output}.
+ */
+interface ClientAssembledToolCall<TName extends string = string, TInput = unknown, TOutput = unknown> extends ToolCallBase<TName, TInput> {
+  readonly output: Promise<TOutput>;
+}
 /**
- * Assembled view of a single tool call lifecycle (`tool-started` →
- * optional `tool-output-delta` → `tool-finished` | `tool-error`).
+ * Reactive tool handle for framework bindings (`stream.toolCalls`,
+ * `useToolCalls`, `injectToolCalls`).
  *
- * Mirrors the in-process `ToolCallStream` interface so that remote
- * consumers get the same ergonomics.
+ * {@link status}, {@link error}, and {@link output} are plain values that
+ * the assembler updates in place as tool events arrive. That lets React,
+ * Vue, Svelte, and Angular re-render from a snapshot on each store tick
+ * without `await`, effects, or Suspense boundaries around a promise.
+ * {@link ClientAssembledToolCall} keeps a promise-based {@link output}
+ * instead for script consumers that read tool results sequentially.
+ *
+ * {@link output} is `null` while the call is running or after it fails;
+ * successful completion sets it to the parsed tool return value (objects
+ * and strings are unwrapped from ToolMessage wire envelopes when needed).
  */
-interface AssembledToolCall {
-  readonly name: string;
-  readonly callId: string;
-  readonly namespace: string[];
-  readonly input: unknown;
-  readonly output: Promise<unknown>;
-  readonly status: Promise<ToolCallStatus>;
-  readonly error: Promise<string | undefined>;
+interface AssembledToolCall<TName extends string = string, TInput = unknown, TOutput = unknown> extends ToolCallBase<TName, TInput> {
+  readonly output: TOutput | null;
+  readonly status: ToolCallStatus;
+  readonly error: string | undefined;
 }
+/**
+ * Parse wire-format tool payloads into structured values.
+ *
+ * Tool events may carry JSON-encoded object strings on the wire; this
+ * helper normalises them to plain objects for consumers. Non-JSON strings
+ * are returned unchanged.
+ */
+declare function parseToolPayload(value: unknown): unknown;
+/**
+ * Parse a `tool-finished` output payload into the tool's return value.
+ *
+ * Wire events often wrap structured tool results in a ToolMessage-shaped
+ * object (`{ type: "tool", content: "..." }`). This unwraps that envelope,
+ * JSON-decodes string content when possible, and leaves plain strings as-is.
+ * Returns `null` when a ToolMessage envelope is present but its content
+ * cannot be normalised.
+ */
+declare function parseToolOutput(value: unknown): unknown | null;
 //#endregion
-export { AssembledToolCall, ToolCallStatus };
+export { AssembledToolCall, ClientAssembledToolCall, ToolCallStatus, parseToolOutput, parseToolPayload };
 //# sourceMappingURL=tools.d.ts.map

package/dist/client/stream/handles/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"mappings":";;;;;AAUA;KAAY,cAAA;;;;AASZ;;;;UAAiB,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,MAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAAA,SACR,MAAA,EAAQ,OAAA,CAAQ,cAAA;EAAA,SAChB,KAAA,EAAO,OAAA;AAAA"}
+{"version":3,"file":"tools.d.ts","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"mappings":";;;;;AAUA;KAAY,cAAA;;UAGF,YAAA;EAAA,SACC,IAAA,EAAM,KAAA;EAAA,SACN,MAAA;EAFW;;;;EAAA,SAOX,EAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,EAAO,MAAA;EATK;;;EAAA,SAaZ,IAAA,EAAM,MAAA;AAAA;;;;;;UAQA,uBAAA,6EAIP,YAAA,CAAa,KAAA,EAAO,MAAA;EAAA,SACnB,MAAA,EAAQ,OAAA,CAAQ,OAAA;AAAA;AAL3B;;;;;;;;;;;;;;;AAAA,UAuBiB,iBAAA,6EAIP,YAAA,CAAa,KAAA,EAAO,MAAA;EAAA,SACnB,MAAA,EAAQ,OAAA;EAAA,SACR,MAAA,EAAQ,cAAA;EAAA,SACR,KAAA;AAAA;;;;;;;AA0CX;iBAAgB,gBAAA,CAAiB,KAAA;;;;AAsEjC;;;;;;iBAAgB,eAAA,CAAgB,KAAA"}

package/dist/client/stream/handles/tools.js

@@ -1,92 +1,161 @@
 //#region src/client/stream/handles/tools.ts
 /**
-* Incrementally assembles `tools` events into complete
-* {@link AssembledToolCall} objects with promise-based output/status/error.
+* Project a runtime handle to the client SDK surface (promise-only
+* {@link output}, no {@link status} / {@link error} fields).
+*/
+function toClientAssembledToolCall(handle) {
+	return {
+		name: handle.name,
+		callId: handle.callId,
+		id: handle.id,
+		namespace: handle.namespace,
+		input: handle.input,
+		args: handle.args,
+		output: handle.outputPromise
+	};
+}
+/**
+* Parse wire-format tool payloads into structured values.
+*
+* Tool events may carry JSON-encoded object strings on the wire; this
+* helper normalises them to plain objects for consumers. Non-JSON strings
+* are returned unchanged.
+*/
+function parseToolPayload(value) {
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return value;
+	}
+}
+function isToolMessageLike(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	if (record.type === "tool") return true;
+	return typeof record.tool_call_id === "string" && "content" in record;
+}
+function textFromContentBlocks(content) {
+	let out = "";
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type === "text" && typeof record.text === "string") out += record.text;
+	}
+	return out;
+}
+/**
+* Normalise tool-result `content` from a wire ToolMessage into the value
+* a tool implementation returned (object, string, etc.).
+*/
+function parseToolResultContent(content) {
+	if (content == null) return null;
+	if (typeof content === "string") {
+		if (content.trim().length === 0) return null;
+		return parseToolPayload(content);
+	}
+	if (Array.isArray(content)) {
+		const text = textFromContentBlocks(content);
+		if (text.length === 0) return null;
+		return parseToolPayload(text);
+	}
+	if (typeof content === "object") return content;
+	return null;
+}
+/**
+* Parse a `tool-finished` output payload into the tool's return value.
 *
-* Each `tool-started` event produces an {@link AssembledToolCall} whose
-* `output`, `status`, and `error` promises resolve when `tool-finished`
-* or `tool-error` arrives for the same `tool_call_id`.
+* Wire events often wrap structured tool results in a ToolMessage-shaped
+* object (`{ type: "tool", content: "..." }`). This unwraps that envelope,
+* JSON-decodes string content when possible, and leaves plain strings as-is.
+* Returns `null` when a ToolMessage envelope is present but its content
+* cannot be normalised.
+*/
+function parseToolOutput(value) {
+	const parsed = parseToolPayload(value);
+	if (isToolMessageLike(parsed)) return parseToolResultContent(parsed.content);
+	return parsed ?? null;
+}
+/**
+* Incrementally assembles `tools` events into mutable tool-call handles.
+*
+* Framework consumers store the handle directly; client SDK consumers
+* should map with {@link toClientAssembledToolCall} before yielding.
 */
 var ToolCallAssembler = class {
 	active = /* @__PURE__ */ new Map();
 	consume(event) {
 		const data = event.params.data;
 		if (data.event === "tool-started") return this.handleStarted(event, data);
-		if (data.event === "tool-finished") {
-			this.handleFinished(data);
-			return;
-		}
-		if (data.event === "tool-error") {
-			this.handleError(data);
-			return;
-		}
+		if (data.event === "tool-finished") return this.handleFinished(data);
+		if (data.event === "tool-error") return this.handleError(data);
 	}
 	/**
 	* Reject any in-flight tool calls (e.g. on session close).
 	*/
 	failAll(reason) {
-		for (const tc of this.active.values()) {
-			tc.rejectOutput(reason);
-			tc.resolveStatus("error");
-			tc.resolveError(reason.message);
+		for (const entry of this.active.values()) {
+			entry.rejectOutput(reason);
+			entry.handle.status = "error";
+			entry.handle.error = reason.message;
 		}
 		this.active.clear();
 	}
 	handleStarted(event, data) {
 		let resolveOutput;
 		let rejectOutput;
-		let resolveStatus;
-		let resolveError;
-		const output = new Promise((resolve, reject) => {
+		const outputPromise = new Promise((resolve, reject) => {
 			resolveOutput = resolve;
 			rejectOutput = reject;
 		});
-		output.catch(() => void 0);
-		const status = new Promise((resolve) => {
-			resolveStatus = resolve;
-		});
-		const error = new Promise((resolve) => {
-			resolveError = resolve;
-		});
-		const entry = {
-			name: data.tool_name,
-			callId: data.tool_call_id,
+		outputPromise.catch(() => void 0);
+		const input = parseToolPayload(data.input);
+		const name = data.tool_name;
+		const callId = data.tool_call_id;
+		const handle = {
+			name,
+			callId,
+			id: callId,
 			namespace: [...event.params.namespace],
-			input: data.input,
-			resolveOutput,
-			rejectOutput,
-			resolveStatus,
-			resolveError
-		};
-		this.active.set(data.tool_call_id, entry);
-		return {
-			name: entry.name,
-			callId: entry.callId,
-			namespace: entry.namespace,
-			input: entry.input,
-			output,
-			status,
-			error
+			input,
+			args: input,
+			output: null,
+			status: "running",
+			error: void 0,
+			outputPromise
 		};
+		this.active.set(callId, {
+			handle,
+			resolveOutput,
+			rejectOutput
+		});
+		return handle;
 	}
 	handleFinished(data) {
 		const entry = this.active.get(data.tool_call_id);
-		if (!entry) return;
+		if (!entry) return void 0;
 		this.active.delete(data.tool_call_id);
-		entry.resolveOutput(data.output);
-		entry.resolveStatus("finished");
-		entry.resolveError(void 0);
+		const value = parseToolOutput(data.output);
+		entry.resolveOutput(value);
+		entry.handle.output = value;
+		entry.handle.status = "finished";
+		entry.handle.error = void 0;
+		return entry.handle;
 	}
 	handleError(data) {
 		const entry = this.active.get(data.tool_call_id);
-		if (!entry) return;
+		if (!entry) return void 0;
 		this.active.delete(data.tool_call_id);
 		entry.rejectOutput(new Error(data.message));
-		entry.resolveStatus("error");
-		entry.resolveError(data.message);
+		entry.handle.output = null;
+		entry.handle.status = "error";
+		entry.handle.error = data.message;
+		return entry.handle;
 	}
 };
 //#endregion
-export { ToolCallAssembler };
+export { ToolCallAssembler, parseToolOutput, parseToolPayload, toClientAssembledToolCall };
 
 //# sourceMappingURL=tools.js.map

package/dist/client/stream/handles/tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.js","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"sourcesContent":["import type {\n  ToolsEvent,\n  ToolStartedData,\n  ToolFinishedData,\n  ToolErrorData,\n} from \"@langchain/protocol\";\n\n/**\n * High-level outcome of a single tool call.\n */\nexport type ToolCallStatus = \"running\" | \"finished\" | \"error\";\n\n/**\n * Assembled view of a single tool call lifecycle (`tool-started` →\n * optional `tool-output-delta` → `tool-finished` | `tool-error`).\n *\n * Mirrors the in-process `ToolCallStream` interface so that remote\n * consumers get the same ergonomics.\n */\nexport interface AssembledToolCall {\n  readonly name: string;\n  readonly callId: string;\n  readonly namespace: string[];\n  readonly input: unknown;\n  readonly output: Promise<unknown>;\n  readonly status: Promise<ToolCallStatus>;\n  readonly error: Promise<string | undefined>;\n}\n\ntype ActiveToolCall = {\n  name: string;\n  callId: string;\n  namespace: string[];\n  input: unknown;\n  resolveOutput: (value: unknown) => void;\n  rejectOutput: (err: Error) => void;\n  resolveStatus: (value: ToolCallStatus) => void;\n  resolveError: (value: string | undefined) => void;\n};\n\n/**\n * Incrementally assembles `tools` events into complete\n * {@link AssembledToolCall} objects with promise-based output/status/error.\n *\n * Each `tool-started` event produces an {@link AssembledToolCall} whose\n * `output`, `status`, and `error` promises resolve when `tool-finished`\n * or `tool-error` arrives for the same `tool_call_id`.\n */\nexport class ToolCallAssembler {\n  private readonly active = new Map<string, ActiveToolCall>();\n\n  consume(event: ToolsEvent): AssembledToolCall | undefined {\n    const data = event.params.data;\n\n    if (data.event === \"tool-started\") {\n      return this.handleStarted(event, data);\n    }\n\n    if (data.event === \"tool-finished\") {\n      this.handleFinished(data);\n      return undefined;\n    }\n\n    if (data.event === \"tool-error\") {\n      this.handleError(data);\n      return undefined;\n    }\n\n    // tool-output-delta: no action needed at assembly level\n    return undefined;\n  }\n\n  /**\n   * Reject any in-flight tool calls (e.g. on session close).\n   */\n  failAll(reason: Error): void {\n    for (const tc of this.active.values()) {\n      tc.rejectOutput(reason);\n      tc.resolveStatus(\"error\");\n      tc.resolveError(reason.message);\n    }\n    this.active.clear();\n  }\n\n  private handleStarted(\n    event: ToolsEvent,\n    data: ToolStartedData\n  ): AssembledToolCall {\n    let resolveOutput!: (value: unknown) => void;\n    let rejectOutput!: (err: Error) => void;\n    let resolveStatus!: (value: ToolCallStatus) => void;\n    let resolveError!: (value: string | undefined) => void;\n\n    const output = new Promise<unknown>((resolve, reject) => {\n      resolveOutput = resolve;\n      rejectOutput = reject;\n    });\n    // Attach a default no-op catch so if no consumer awaits\n    // `output` the eventual rejection on `tool-error` / `failAll`\n    // doesn't surface as an unhandled Promise rejection.\n    output.catch(() => undefined);\n    const status = new Promise<ToolCallStatus>((resolve) => {\n      resolveStatus = resolve;\n    });\n    const error = new Promise<string | undefined>((resolve) => {\n      resolveError = resolve;\n    });\n\n    const entry: ActiveToolCall = {\n      name: data.tool_name,\n      callId: data.tool_call_id,\n      namespace: [...event.params.namespace],\n      input: data.input,\n      resolveOutput,\n      rejectOutput,\n      resolveStatus,\n      resolveError,\n    };\n    this.active.set(data.tool_call_id, entry);\n\n    return {\n      name: entry.name,\n      callId: entry.callId,\n      namespace: entry.namespace,\n      input: entry.input,\n      output,\n      status,\n      error,\n    };\n  }\n\n  private handleFinished(data: ToolFinishedData): void {\n    const entry = this.active.get(data.tool_call_id);\n    if (!entry) return;\n    this.active.delete(data.tool_call_id);\n    entry.resolveOutput(data.output);\n    entry.resolveStatus(\"finished\");\n    entry.resolveError(undefined);\n  }\n\n  private handleError(data: ToolErrorData): void {\n    const entry = this.active.get(data.tool_call_id);\n    if (!entry) return;\n    this.active.delete(data.tool_call_id);\n    entry.rejectOutput(new Error(data.message));\n    entry.resolveStatus(\"error\");\n    entry.resolveError(data.message);\n  }\n}\n"],"mappings":";;;;;;;;;AAgDA,IAAa,oBAAb,MAA+B;CAC7B,yBAA0B,IAAI,KAA6B;CAE3D,QAAQ,OAAkD;EACxD,MAAM,OAAO,MAAM,OAAO;AAE1B,MAAI,KAAK,UAAU,eACjB,QAAO,KAAK,cAAc,OAAO,KAAK;AAGxC,MAAI,KAAK,UAAU,iBAAiB;AAClC,QAAK,eAAe,KAAK;AACzB;;AAGF,MAAI,KAAK,UAAU,cAAc;AAC/B,QAAK,YAAY,KAAK;AACtB;;;;;;CAUJ,QAAQ,QAAqB;AAC3B,OAAK,MAAM,MAAM,KAAK,OAAO,QAAQ,EAAE;AACrC,MAAG,aAAa,OAAO;AACvB,MAAG,cAAc,QAAQ;AACzB,MAAG,aAAa,OAAO,QAAQ;;AAEjC,OAAK,OAAO,OAAO;;CAGrB,cACE,OACA,MACmB;EACnB,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EAEJ,MAAM,SAAS,IAAI,SAAkB,SAAS,WAAW;AACvD,mBAAgB;AAChB,kBAAe;IACf;AAIF,SAAO,YAAY,KAAA,EAAU;EAC7B,MAAM,SAAS,IAAI,SAAyB,YAAY;AACtD,mBAAgB;IAChB;EACF,MAAM,QAAQ,IAAI,SAA6B,YAAY;AACzD,kBAAe;IACf;EAEF,MAAM,QAAwB;GAC5B,MAAM,KAAK;GACX,QAAQ,KAAK;GACb,WAAW,CAAC,GAAG,MAAM,OAAO,UAAU;GACtC,OAAO,KAAK;GACZ;GACA;GACA;GACA;GACD;AACD,OAAK,OAAO,IAAI,KAAK,cAAc,MAAM;AAEzC,SAAO;GACL,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,WAAW,MAAM;GACjB,OAAO,MAAM;GACb;GACA;GACA;GACD;;CAGH,eAAuB,MAA8B;EACnD,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,aAAa;AAChD,MAAI,CAAC,MAAO;AACZ,OAAK,OAAO,OAAO,KAAK,aAAa;AACrC,QAAM,cAAc,KAAK,OAAO;AAChC,QAAM,cAAc,WAAW;AAC/B,QAAM,aAAa,KAAA,EAAU;;CAG/B,YAAoB,MAA2B;EAC7C,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,aAAa;AAChD,MAAI,CAAC,MAAO;AACZ,OAAK,OAAO,OAAO,KAAK,aAAa;AACrC,QAAM,aAAa,IAAI,MAAM,KAAK,QAAQ,CAAC;AAC3C,QAAM,cAAc,QAAQ;AAC5B,QAAM,aAAa,KAAK,QAAQ"}
+{"version":3,"file":"tools.js","names":[],"sources":["../../../../src/client/stream/handles/tools.ts"],"sourcesContent":["import type {\n  ToolsEvent,\n  ToolStartedData,\n  ToolFinishedData,\n  ToolErrorData,\n} from \"@langchain/protocol\";\n\n/**\n * High-level outcome of a single tool call.\n */\nexport type ToolCallStatus = \"running\" | \"finished\" | \"error\";\n\n/** Shared metadata for assembled tool-call handles. */\ninterface ToolCallBase<TName extends string = string, TInput = unknown> {\n  readonly name: TName;\n  readonly callId: string;\n  /**\n   * Pre-v1 alias for {@link callId}. Matches `ToolCallWithResult.id` and\n   * `ToolCall.id` on message-level tool calls.\n   */\n  readonly id: string;\n  readonly namespace: string[];\n  readonly input: TInput;\n  /**\n   * Pre-v1 alias for {@link input}. Matches `ToolCallFromTool` `args`.\n   */\n  readonly args: TInput;\n}\n\n/**\n * Script-oriented tool handle from the client SDK (`ThreadStream.toolCalls`,\n * subagent/subgraph projections). Completion and errors are surfaced only\n * through {@link output}.\n */\nexport interface ClientAssembledToolCall<\n  TName extends string = string,\n  TInput = unknown,\n  TOutput = unknown,\n> extends ToolCallBase<TName, TInput> {\n  readonly output: Promise<TOutput>;\n}\n\n/**\n * Reactive tool handle for framework bindings (`stream.toolCalls`,\n * `useToolCalls`, `injectToolCalls`).\n *\n * {@link status}, {@link error}, and {@link output} are plain values that\n * the assembler updates in place as tool events arrive. That lets React,\n * Vue, Svelte, and Angular re-render from a snapshot on each store tick\n * without `await`, effects, or Suspense boundaries around a promise.\n * {@link ClientAssembledToolCall} keeps a promise-based {@link output}\n * instead for script consumers that read tool results sequentially.\n *\n * {@link output} is `null` while the call is running or after it fails;\n * successful completion sets it to the parsed tool return value (objects\n * and strings are unwrapped from ToolMessage wire envelopes when needed).\n */\nexport interface AssembledToolCall<\n  TName extends string = string,\n  TInput = unknown,\n  TOutput = unknown,\n> extends ToolCallBase<TName, TInput> {\n  readonly output: TOutput | null;\n  readonly status: ToolCallStatus;\n  readonly error: string | undefined;\n}\n\n/** @internal Mutable runtime handle shared by client and framework views. */\ntype MutableToolCallHandle = {\n  name: string;\n  callId: string;\n  id: string;\n  namespace: string[];\n  input: unknown;\n  args: unknown;\n  output: unknown | null;\n  status: ToolCallStatus;\n  error: string | undefined;\n  outputPromise: Promise<unknown>;\n};\n\n/**\n * Project a runtime handle to the client SDK surface (promise-only\n * {@link output}, no {@link status} / {@link error} fields).\n */\nexport function toClientAssembledToolCall(\n  handle: MutableToolCallHandle\n): ClientAssembledToolCall {\n  return {\n    name: handle.name,\n    callId: handle.callId,\n    id: handle.id,\n    namespace: handle.namespace,\n    input: handle.input,\n    args: handle.args,\n    output: handle.outputPromise as Promise<unknown>,\n  };\n}\n\n/**\n * Parse wire-format tool payloads into structured values.\n *\n * Tool events may carry JSON-encoded object strings on the wire; this\n * helper normalises them to plain objects for consumers. Non-JSON strings\n * are returned unchanged.\n */\nexport function parseToolPayload(value: unknown): unknown {\n  if (typeof value !== \"string\") return value;\n  const trimmed = value.trim();\n  if (!trimmed.startsWith(\"{\") && !trimmed.startsWith(\"[\")) {\n    return value;\n  }\n\n  try {\n    return JSON.parse(trimmed) as unknown;\n  } catch {\n    return value;\n  }\n}\n\nfunction isToolMessageLike(\n  value: unknown\n): value is Record<string, unknown> & { content: unknown } {\n  if (!value || typeof value !== \"object\") return false;\n  const record = value as Record<string, unknown>;\n  if (record.type === \"tool\") return true;\n  return typeof record.tool_call_id === \"string\" && \"content\" in record;\n}\n\nfunction textFromContentBlocks(content: unknown[]): string {\n  let out = \"\";\n  for (const block of content) {\n    if (!block || typeof block !== \"object\") continue;\n    const record = block as Record<string, unknown>;\n    if (record.type === \"text\" && typeof record.text === \"string\") {\n      out += record.text;\n    }\n  }\n  return out;\n}\n\n/**\n * Normalise tool-result `content` from a wire ToolMessage into the value\n * a tool implementation returned (object, string, etc.).\n */\nfunction parseToolResultContent(content: unknown): unknown | null {\n  if (content == null) return null;\n\n  if (typeof content === \"string\") {\n    const trimmed = content.trim();\n    if (trimmed.length === 0) return null;\n    return parseToolPayload(content);\n  }\n\n  if (Array.isArray(content)) {\n    const text = textFromContentBlocks(content);\n    if (text.length === 0) return null;\n    return parseToolPayload(text);\n  }\n\n  if (typeof content === \"object\") {\n    return content;\n  }\n\n  return null;\n}\n\n/**\n * Parse a `tool-finished` output payload into the tool's return value.\n *\n * Wire events often wrap structured tool results in a ToolMessage-shaped\n * object (`{ type: \"tool\", content: \"...\" }`). This unwraps that envelope,\n * JSON-decodes string content when possible, and leaves plain strings as-is.\n * Returns `null` when a ToolMessage envelope is present but its content\n * cannot be normalised.\n */\nexport function parseToolOutput(value: unknown): unknown | null {\n  const parsed = parseToolPayload(value);\n  if (isToolMessageLike(parsed)) {\n    return parseToolResultContent(parsed.content);\n  }\n  return parsed ?? null;\n}\n\ntype ActiveToolCall = {\n  handle: MutableToolCallHandle;\n  resolveOutput: (value: unknown) => void;\n  rejectOutput: (err: Error) => void;\n};\n\n/**\n * Incrementally assembles `tools` events into mutable tool-call handles.\n *\n * Framework consumers store the handle directly; client SDK consumers\n * should map with {@link toClientAssembledToolCall} before yielding.\n */\nexport class ToolCallAssembler {\n  private readonly active = new Map<string, ActiveToolCall>();\n\n  consume(event: ToolsEvent): MutableToolCallHandle | undefined {\n    const data = event.params.data;\n\n    if (data.event === \"tool-started\") {\n      return this.handleStarted(event, data);\n    }\n\n    if (data.event === \"tool-finished\") {\n      return this.handleFinished(data);\n    }\n\n    if (data.event === \"tool-error\") {\n      return this.handleError(data);\n    }\n\n    // tool-output-delta: no action needed at assembly level\n    return undefined;\n  }\n\n  /**\n   * Reject any in-flight tool calls (e.g. on session close).\n   */\n  failAll(reason: Error): void {\n    for (const entry of this.active.values()) {\n      entry.rejectOutput(reason);\n      entry.handle.status = \"error\";\n      entry.handle.error = reason.message;\n    }\n    this.active.clear();\n  }\n\n  private handleStarted(\n    event: ToolsEvent,\n    data: ToolStartedData\n  ): MutableToolCallHandle {\n    let resolveOutput!: (value: unknown) => void;\n    let rejectOutput!: (err: Error) => void;\n\n    const outputPromise = new Promise<unknown>((resolve, reject) => {\n      resolveOutput = resolve;\n      rejectOutput = reject;\n    });\n    // Attach a default no-op catch so if no consumer awaits\n    // `output` the eventual rejection on `tool-error` / `failAll`\n    // doesn't surface as an unhandled Promise rejection.\n    outputPromise.catch(() => undefined);\n\n    const input = parseToolPayload(data.input);\n    const name = data.tool_name;\n    const callId = data.tool_call_id;\n    const namespace = [...event.params.namespace];\n\n    const handle: MutableToolCallHandle = {\n      name,\n      callId,\n      id: callId,\n      namespace,\n      input,\n      args: input,\n      output: null,\n      status: \"running\",\n      error: undefined,\n      outputPromise,\n    };\n\n    this.active.set(callId, {\n      handle,\n      resolveOutput,\n      rejectOutput,\n    });\n\n    return handle;\n  }\n\n  private handleFinished(\n    data: ToolFinishedData\n  ): MutableToolCallHandle | undefined {\n    const entry = this.active.get(data.tool_call_id);\n    if (!entry) return undefined;\n    this.active.delete(data.tool_call_id);\n    const value = parseToolOutput(data.output);\n    entry.resolveOutput(value);\n    entry.handle.output = value;\n    entry.handle.status = \"finished\";\n    entry.handle.error = undefined;\n    return entry.handle;\n  }\n\n  private handleError(data: ToolErrorData): MutableToolCallHandle | undefined {\n    const entry = this.active.get(data.tool_call_id);\n    if (!entry) return undefined;\n    this.active.delete(data.tool_call_id);\n    entry.rejectOutput(new Error(data.message));\n    entry.handle.output = null;\n    entry.handle.status = \"error\";\n    entry.handle.error = data.message;\n    return entry.handle;\n  }\n}\n"],"mappings":";;;;;AAqFA,SAAgB,0BACd,QACyB;AACzB,QAAO;EACL,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,IAAI,OAAO;EACX,WAAW,OAAO;EAClB,OAAO,OAAO;EACd,MAAM,OAAO;EACb,QAAQ,OAAO;EAChB;;;;;;;;;AAUH,SAAgB,iBAAiB,OAAyB;AACxD,KAAI,OAAO,UAAU,SAAU,QAAO;CACtC,MAAM,UAAU,MAAM,MAAM;AAC5B,KAAI,CAAC,QAAQ,WAAW,IAAI,IAAI,CAAC,QAAQ,WAAW,IAAI,CACtD,QAAO;AAGT,KAAI;AACF,SAAO,KAAK,MAAM,QAAQ;SACpB;AACN,SAAO;;;AAIX,SAAS,kBACP,OACyD;AACzD,KAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;CAChD,MAAM,SAAS;AACf,KAAI,OAAO,SAAS,OAAQ,QAAO;AACnC,QAAO,OAAO,OAAO,iBAAiB,YAAY,aAAa;;AAGjE,SAAS,sBAAsB,SAA4B;CACzD,IAAI,MAAM;AACV,MAAK,MAAM,SAAS,SAAS;AAC3B,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU;EACzC,MAAM,SAAS;AACf,MAAI,OAAO,SAAS,UAAU,OAAO,OAAO,SAAS,SACnD,QAAO,OAAO;;AAGlB,QAAO;;;;;;AAOT,SAAS,uBAAuB,SAAkC;AAChE,KAAI,WAAW,KAAM,QAAO;AAE5B,KAAI,OAAO,YAAY,UAAU;AAE/B,MADgB,QAAQ,MAAM,CAClB,WAAW,EAAG,QAAO;AACjC,SAAO,iBAAiB,QAAQ;;AAGlC,KAAI,MAAM,QAAQ,QAAQ,EAAE;EAC1B,MAAM,OAAO,sBAAsB,QAAQ;AAC3C,MAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,SAAO,iBAAiB,KAAK;;AAG/B,KAAI,OAAO,YAAY,SACrB,QAAO;AAGT,QAAO;;;;;;;;;;;AAYT,SAAgB,gBAAgB,OAAgC;CAC9D,MAAM,SAAS,iBAAiB,MAAM;AACtC,KAAI,kBAAkB,OAAO,CAC3B,QAAO,uBAAuB,OAAO,QAAQ;AAE/C,QAAO,UAAU;;;;;;;;AAenB,IAAa,oBAAb,MAA+B;CAC7B,yBAA0B,IAAI,KAA6B;CAE3D,QAAQ,OAAsD;EAC5D,MAAM,OAAO,MAAM,OAAO;AAE1B,MAAI,KAAK,UAAU,eACjB,QAAO,KAAK,cAAc,OAAO,KAAK;AAGxC,MAAI,KAAK,UAAU,gBACjB,QAAO,KAAK,eAAe,KAAK;AAGlC,MAAI,KAAK,UAAU,aACjB,QAAO,KAAK,YAAY,KAAK;;;;;CAUjC,QAAQ,QAAqB;AAC3B,OAAK,MAAM,SAAS,KAAK,OAAO,QAAQ,EAAE;AACxC,SAAM,aAAa,OAAO;AAC1B,SAAM,OAAO,SAAS;AACtB,SAAM,OAAO,QAAQ,OAAO;;AAE9B,OAAK,OAAO,OAAO;;CAGrB,cACE,OACA,MACuB;EACvB,IAAI;EACJ,IAAI;EAEJ,MAAM,gBAAgB,IAAI,SAAkB,SAAS,WAAW;AAC9D,mBAAgB;AAChB,kBAAe;IACf;AAIF,gBAAc,YAAY,KAAA,EAAU;EAEpC,MAAM,QAAQ,iBAAiB,KAAK,MAAM;EAC1C,MAAM,OAAO,KAAK;EAClB,MAAM,SAAS,KAAK;EAGpB,MAAM,SAAgC;GACpC;GACA;GACA,IAAI;GACJ,WANgB,CAAC,GAAG,MAAM,OAAO,UAAU;GAO3C;GACA,MAAM;GACN,QAAQ;GACR,QAAQ;GACR,OAAO,KAAA;GACP;GACD;AAED,OAAK,OAAO,IAAI,QAAQ;GACtB;GACA;GACA;GACD,CAAC;AAEF,SAAO;;CAGT,eACE,MACmC;EACnC,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,aAAa;AAChD,MAAI,CAAC,MAAO,QAAO,KAAA;AACnB,OAAK,OAAO,OAAO,KAAK,aAAa;EACrC,MAAM,QAAQ,gBAAgB,KAAK,OAAO;AAC1C,QAAM,cAAc,MAAM;AAC1B,QAAM,OAAO,SAAS;AACtB,QAAM,OAAO,SAAS;AACtB,QAAM,OAAO,QAAQ,KAAA;AACrB,SAAO,MAAM;;CAGf,YAAoB,MAAwD;EAC1E,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,aAAa;AAChD,MAAI,CAAC,MAAO,QAAO,KAAA;AACnB,OAAK,OAAO,OAAO,KAAK,aAAa;AACrC,QAAM,aAAa,IAAI,MAAM,KAAK,QAAQ,CAAC;AAC3C,QAAM,OAAO,SAAS;AACtB,QAAM,OAAO,SAAS;AACtB,QAAM,OAAO,QAAQ,KAAK;AAC1B,SAAO,MAAM"}

package/dist/client/stream/index.cjs

@@ -476,10 +476,18 @@ var ThreadStream = class {
 	* Reset interrupt state and resume all paused user subscriptions.
 	* Called before `run.start()` and `input.respond()` so that
 	* iterators on the same handle pick up the next run's events.
+	*
+	* @param respondedInterruptId - When responding to one of several
+	*   pending interrupts, only that entry is removed. Clearing the
+	*   full list here would drop other headless-tool interrupts that
+	*   are still awaiting client execution.
 	*/
-	#prepareForNextRun() {
+	#prepareForNextRun(respondedInterruptId) {
 		this.interrupted = false;
-		this.interrupts.length = 0;
+		if (respondedInterruptId != null) {
+			const index = this.interrupts.findIndex((entry) => entry.interruptId === respondedInterruptId);
+			if (index >= 0) this.interrupts.splice(index, 1);
+		} else this.interrupts.length = 0;
 		if (this.#terminalPauseTimer != null) {
 			clearTimeout(this.#terminalPauseTimer);
 			this.#terminalPauseTimer = void 0;
@@ -532,7 +540,7 @@ var ThreadStream = class {
 		return projection;
 	}
 	/**
-	* Tool calls with promise-based output/status/error.
+	* Tool calls with a promise-based {@link output} for script consumers.
 	* Mirrors the in-process `run.toolCalls`.
 	*/
 	get toolCalls() {
@@ -543,7 +551,7 @@ var ThreadStream = class {
 		this.#startProjection(["tools", ...this.#lifecycleChannels()], (event) => {
 			if (event.method !== "tools") return;
 			const tc = assembler.consume(event);
-			if (tc) buffer.push(tc);
+			if (tc) buffer.push(require_tools.toClientAssembledToolCall(tc));
 		}, () => buffer.close());
 		return buffer;
 	}
@@ -829,7 +837,7 @@ var ThreadStream = class {
 	* {@link input.respond}.
 	*/
 	async respondInput(params) {
-		this.#prepareForNextRun();
+		this.#prepareForNextRun(params.interrupt_id);
 		this.#startLifecycleWatcher();
 		await this.#send("input.respond", params);
 	}