@mastra/client-js 1.56.0-alpha.1 → 1.56.0-alpha.3

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-client-js
 description: Documentation for @mastra/client-js. Use when working with @mastra/client-js APIs, configuration, or implementation.
 metadata:
   package: "@mastra/client-js"
-  version: "1.56.0-alpha.1"
+  version: "1.56.0-alpha.3"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.56.0-alpha.1",
+  "version": "1.56.0-alpha.3",
   "package": "@mastra/client-js",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-harness-signals.md

@@ -416,7 +416,9 @@ Use the connection tools for distinct operations:
 
 Saved connections remain in the sender thread until explicitly disconnected. Every send independently refreshes discovery and verifies the exact endpoint before routing begins. A saved connection therefore records collaboration intent. It doesn't indicate current presence.
 
-After a send attempt reaches Core routing, the routing result is authoritative. The result can be `wake`, `deliver`, `persist`, `blocked`, or `discard`, depending on the target thread and notification policy. A send that isn't acknowledged by the advertised thread owner returns an error and doesn't consume its `messageId`, so the sender can retry it.
+After a send attempt reaches Core routing, the routing result is authoritative. The result can be `wake`, `deliver`, `persist`, `blocked`, or `discard`, depending on the target thread and notification policy. A send that fails a direct delivery because no thread owner acknowledged it isn't lost: the signal stays pending in the target's notification inbox and the send reports `persist` instead of claiming delivery. The notification dispatcher retries that delivery on its own, so the sender doesn't need to resend it. The `messageId` isn't recorded in sent history and isn't rejected as a duplicate, although the pending notification still matches on it. A resend with the same `messageId` merges into that notification while it's pending, and delivers a second copy once the retry has succeeded. A send made with `expectsReply: true` returns an error there, because the reply obligation isn't established until the signal is delivered.
+
+When the delivery policy routes a signal to a notification summary rather than delivering it directly, the send records the `messageId`, so retrying with the same id reports a duplicate instead of routing again. A low-priority send always takes this route and reports `persist`. A high- or medium-priority send to an active thread takes it too, but there the summary signal is emitted immediately, so the send reports that signal's routing result (`wake`, `deliver`, or `persist`) and records the `messageId` the same way, including when `expectsReply: true`. Only when the policy schedules a summary without emitting a signal at send time does an `expectsReply: true` send fail to establish its reply obligation: it returns an error and doesn't record the send in sent history, so establishing the reply obligation takes a new signal at a priority that routes directly.
 
 ### Discover agents in other projects
 

package/dist/index.cjs

@@ -21,7 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let _ai_sdk_ui_utils = require("@ai-sdk/ui-utils");
 let _lukeed_uuid = require("@lukeed/uuid");
 let _mastra_core_error = require("@mastra/core/error");
 let _mastra_schema_compat_schema = require("@mastra/schema-compat/schema");
@@ -410,6 +409,583 @@ function isTerminalReconnectError(error) {
 	return isTerminalHttpError(error) && status !== 408 && status !== 429;
 }
 //#endregion
+//#region src/utils/ai-sdk-v4/data-stream-parts.ts
+const dataStreamParts = [
+	{
+		code: "0",
+		name: "text",
+		parse: (value) => {
+			if (typeof value !== "string") throw new Error("\"text\" parts expect a string value.");
+			return {
+				type: "text",
+				value
+			};
+		}
+	},
+	{
+		code: "2",
+		name: "data",
+		parse: (value) => {
+			if (!Array.isArray(value)) throw new Error("\"data\" parts expect an array value.");
+			return {
+				type: "data",
+				value
+			};
+		}
+	},
+	{
+		code: "3",
+		name: "error",
+		parse: (value) => {
+			if (typeof value !== "string") throw new Error("\"error\" parts expect a string value.");
+			return {
+				type: "error",
+				value
+			};
+		}
+	},
+	{
+		code: "8",
+		name: "message_annotations",
+		parse: (value) => {
+			if (!Array.isArray(value)) throw new Error("\"message_annotations\" parts expect an array value.");
+			return {
+				type: "message_annotations",
+				value
+			};
+		}
+	},
+	{
+		code: "9",
+		name: "tool_call",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") throw new Error("\"tool_call\" parts expect an object with a \"toolCallId\", \"toolName\", and \"args\" property.");
+			return {
+				type: "tool_call",
+				value
+			};
+		}
+	},
+	{
+		code: "a",
+		name: "tool_result",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) throw new Error("\"tool_result\" parts expect an object with a \"toolCallId\" and a \"result\" property.");
+			return {
+				type: "tool_result",
+				value
+			};
+		}
+	},
+	{
+		code: "b",
+		name: "tool_call_streaming_start",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") throw new Error("\"tool_call_streaming_start\" parts expect an object with a \"toolCallId\" and \"toolName\" property.");
+			return {
+				type: "tool_call_streaming_start",
+				value
+			};
+		}
+	},
+	{
+		code: "c",
+		name: "tool_call_delta",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") throw new Error("\"tool_call_delta\" parts expect an object with a \"toolCallId\" and \"argsTextDelta\" property.");
+			return {
+				type: "tool_call_delta",
+				value
+			};
+		}
+	},
+	{
+		code: "d",
+		name: "finish_message",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") throw new Error("\"finish_message\" parts expect an object with a \"finishReason\" property.");
+			const result = { finishReason: value.finishReason };
+			if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) result.usage = {
+				promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : NaN,
+				completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : NaN
+			};
+			return {
+				type: "finish_message",
+				value: result
+			};
+		}
+	},
+	{
+		code: "e",
+		name: "finish_step",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") throw new Error("\"finish_step\" parts expect an object with a \"finishReason\" property.");
+			const result = {
+				finishReason: value.finishReason,
+				isContinued: false
+			};
+			if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) result.usage = {
+				promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : NaN,
+				completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : NaN
+			};
+			if ("isContinued" in value && typeof value.isContinued === "boolean") result.isContinued = value.isContinued;
+			return {
+				type: "finish_step",
+				value: result
+			};
+		}
+	},
+	{
+		code: "f",
+		name: "start_step",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") throw new Error("\"start_step\" parts expect an object with an \"id\" property.");
+			return {
+				type: "start_step",
+				value: { messageId: value.messageId }
+			};
+		}
+	},
+	{
+		code: "g",
+		name: "reasoning",
+		parse: (value) => {
+			if (typeof value !== "string") throw new Error("\"reasoning\" parts expect a string value.");
+			return {
+				type: "reasoning",
+				value
+			};
+		}
+	},
+	{
+		code: "h",
+		name: "source",
+		parse: (value) => {
+			if (value == null || typeof value !== "object") throw new Error("\"source\" parts expect a Source object.");
+			return {
+				type: "source",
+				value
+			};
+		}
+	},
+	{
+		code: "i",
+		name: "redacted_reasoning",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string") throw new Error("\"redacted_reasoning\" parts expect an object with a \"data\" property.");
+			return {
+				type: "redacted_reasoning",
+				value: { data: value.data }
+			};
+		}
+	},
+	{
+		code: "j",
+		name: "reasoning_signature",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("signature" in value) || typeof value.signature !== "string") throw new Error("\"reasoning_signature\" parts expect an object with a \"signature\" property.");
+			return {
+				type: "reasoning_signature",
+				value: { signature: value.signature }
+			};
+		}
+	},
+	{
+		code: "k",
+		name: "file",
+		parse: (value) => {
+			if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") throw new Error("\"file\" parts expect an object with a \"data\" and \"mimeType\" property.");
+			return {
+				type: "file",
+				value
+			};
+		}
+	}
+];
+const dataStreamPartsByCode = Object.fromEntries(dataStreamParts.map((part) => [part.code, part]));
+Object.fromEntries(dataStreamParts.map((part) => [part.name, part.code]));
+const validCodes = dataStreamParts.map((part) => part.code);
+/**
+Parses a stream part from a string.
+
+@param line The string to parse.
+@returns The parsed stream part.
+@throws An error if the string cannot be parsed.
+*/
+const parseDataStreamPart = (line) => {
+	const firstSeparatorIndex = line.indexOf(":");
+	if (firstSeparatorIndex === -1) throw new Error("Failed to parse stream string. No separator found.");
+	const prefix = line.slice(0, firstSeparatorIndex);
+	if (!validCodes.includes(prefix)) throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+	const code = prefix;
+	const textValue = line.slice(firstSeparatorIndex + 1);
+	const jsonValue = JSON.parse(textValue);
+	return dataStreamPartsByCode[code].parse(jsonValue);
+};
+//#endregion
+//#region src/utils/ai-sdk-v4/fix-json.ts
+function fixJson(input) {
+	const stack = ["ROOT"];
+	let lastValidIndex = -1;
+	let literalStart = null;
+	function processValueStart(char, i, swapState) {
+		switch (char) {
+			case "\"":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_STRING");
+				break;
+			case "f":
+			case "t":
+			case "n":
+				lastValidIndex = i;
+				literalStart = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_LITERAL");
+				break;
+			case "-":
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_NUMBER");
+				break;
+			case "0":
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_NUMBER");
+				break;
+			case "{":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_OBJECT_START");
+				break;
+			case "[":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_ARRAY_START");
+				break;
+		}
+	}
+	function processAfterObjectValue(char, i) {
+		switch (char) {
+			case ",":
+				stack.pop();
+				stack.push("INSIDE_OBJECT_AFTER_COMMA");
+				break;
+			case "}":
+				lastValidIndex = i;
+				stack.pop();
+				break;
+		}
+	}
+	function processAfterArrayValue(char, i) {
+		switch (char) {
+			case ",":
+				stack.pop();
+				stack.push("INSIDE_ARRAY_AFTER_COMMA");
+				break;
+			case "]":
+				lastValidIndex = i;
+				stack.pop();
+				break;
+		}
+	}
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		switch (stack[stack.length - 1]) {
+			case "ROOT":
+				processValueStart(char, i, "FINISH");
+				break;
+			case "INSIDE_OBJECT_START":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_KEY");
+						break;
+					case "}":
+						lastValidIndex = i;
+						stack.pop();
+						break;
+				}
+				break;
+			case "INSIDE_OBJECT_AFTER_COMMA":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_KEY");
+						break;
+				}
+				break;
+			case "INSIDE_OBJECT_KEY":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_AFTER_KEY");
+						break;
+				}
+				break;
+			case "INSIDE_OBJECT_AFTER_KEY":
+				switch (char) {
+					case ":":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+						break;
+				}
+				break;
+			case "INSIDE_OBJECT_BEFORE_VALUE":
+				processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+				break;
+			case "INSIDE_OBJECT_AFTER_VALUE":
+				processAfterObjectValue(char, i);
+				break;
+			case "INSIDE_STRING":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						lastValidIndex = i;
+						break;
+					case "\\":
+						stack.push("INSIDE_STRING_ESCAPE");
+						break;
+					default: lastValidIndex = i;
+				}
+				break;
+			case "INSIDE_ARRAY_START":
+				switch (char) {
+					case "]":
+						lastValidIndex = i;
+						stack.pop();
+						break;
+					default:
+						lastValidIndex = i;
+						processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+						break;
+				}
+				break;
+			case "INSIDE_ARRAY_AFTER_VALUE":
+				switch (char) {
+					case ",":
+						stack.pop();
+						stack.push("INSIDE_ARRAY_AFTER_COMMA");
+						break;
+					case "]":
+						lastValidIndex = i;
+						stack.pop();
+						break;
+					default:
+						lastValidIndex = i;
+						break;
+				}
+				break;
+			case "INSIDE_ARRAY_AFTER_COMMA":
+				processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+				break;
+			case "INSIDE_STRING_ESCAPE":
+				stack.pop();
+				lastValidIndex = i;
+				break;
+			case "INSIDE_NUMBER":
+				switch (char) {
+					case "0":
+					case "1":
+					case "2":
+					case "3":
+					case "4":
+					case "5":
+					case "6":
+					case "7":
+					case "8":
+					case "9":
+						lastValidIndex = i;
+						break;
+					case "e":
+					case "E":
+					case "-":
+					case ".": break;
+					case ",":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+						if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+						break;
+					case "}":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+						break;
+					case "]":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+						break;
+					default:
+						stack.pop();
+						break;
+				}
+				break;
+			case "INSIDE_LITERAL": {
+				const partialLiteral = input.substring(literalStart, i + 1);
+				if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+					stack.pop();
+					if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+					else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+				} else lastValidIndex = i;
+				break;
+			}
+		}
+	}
+	let result = input.slice(0, lastValidIndex + 1);
+	for (let i = stack.length - 1; i >= 0; i--) switch (stack[i]) {
+		case "INSIDE_STRING":
+			result += "\"";
+			break;
+		case "INSIDE_OBJECT_KEY":
+		case "INSIDE_OBJECT_AFTER_KEY":
+		case "INSIDE_OBJECT_AFTER_COMMA":
+		case "INSIDE_OBJECT_START":
+		case "INSIDE_OBJECT_BEFORE_VALUE":
+		case "INSIDE_OBJECT_AFTER_VALUE":
+			result += "}";
+			break;
+		case "INSIDE_ARRAY_START":
+		case "INSIDE_ARRAY_AFTER_COMMA":
+		case "INSIDE_ARRAY_AFTER_VALUE":
+			result += "]";
+			break;
+		case "INSIDE_LITERAL": {
+			const partialLiteral = input.substring(literalStart, input.length);
+			if ("true".startsWith(partialLiteral)) result += "true".slice(partialLiteral.length);
+			else if ("false".startsWith(partialLiteral)) result += "false".slice(partialLiteral.length);
+			else if ("null".startsWith(partialLiteral)) result += "null".slice(partialLiteral.length);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/ai-sdk-v4/parse-partial-json.ts
+function tryParse(text) {
+	try {
+		return {
+			success: true,
+			value: JSON.parse(text)
+		};
+	} catch {
+		return { success: false };
+	}
+}
+function parsePartialJson(jsonText) {
+	if (jsonText === void 0) return {
+		value: void 0,
+		state: "undefined-input"
+	};
+	let result = tryParse(jsonText);
+	if (result.success) return {
+		value: result.value,
+		state: "successful-parse"
+	};
+	result = tryParse(fixJson(jsonText));
+	if (result.success) return {
+		value: result.value,
+		state: "repaired-parse"
+	};
+	return {
+		value: void 0,
+		state: "failed-parse"
+	};
+}
+//#endregion
+//#region src/utils/ai-sdk-v4/process-data-stream.ts
+const NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+	const concatenatedChunks = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		concatenatedChunks.set(chunk, offset);
+		offset += chunk.length;
+	}
+	chunks.length = 0;
+	return concatenatedChunks;
+}
+async function processDataStream({ stream, onTextPart, onReasoningPart, onReasoningSignaturePart, onRedactedReasoningPart, onSourcePart, onFilePart, onDataPart, onErrorPart, onToolCallStreamingStartPart, onToolCallDeltaPart, onToolCallPart, onToolResultPart, onMessageAnnotationsPart, onFinishMessagePart, onFinishStepPart, onStartStepPart }) {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	let totalLength = 0;
+	while (true) {
+		const { value } = await reader.read();
+		if (value) {
+			chunks.push(value);
+			totalLength += value.length;
+			if (value[value.length - 1] !== NEWLINE) continue;
+		}
+		if (chunks.length === 0) break;
+		const concatenatedChunks = concatChunks(chunks, totalLength);
+		totalLength = 0;
+		const streamParts = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseDataStreamPart);
+		for (const { type, value } of streamParts) switch (type) {
+			case "text":
+				await onTextPart?.(value);
+				break;
+			case "reasoning":
+				await onReasoningPart?.(value);
+				break;
+			case "reasoning_signature":
+				await onReasoningSignaturePart?.(value);
+				break;
+			case "redacted_reasoning":
+				await onRedactedReasoningPart?.(value);
+				break;
+			case "file":
+				await onFilePart?.(value);
+				break;
+			case "source":
+				await onSourcePart?.(value);
+				break;
+			case "data":
+				await onDataPart?.(value);
+				break;
+			case "error":
+				await onErrorPart?.(value);
+				break;
+			case "message_annotations":
+				await onMessageAnnotationsPart?.(value);
+				break;
+			case "tool_call_streaming_start":
+				await onToolCallStreamingStartPart?.(value);
+				break;
+			case "tool_call_delta":
+				await onToolCallDeltaPart?.(value);
+				break;
+			case "tool_call":
+				await onToolCallPart?.(value);
+				break;
+			case "tool_result":
+				await onToolResultPart?.(value);
+				break;
+			case "finish_message":
+				await onFinishMessagePart?.(value);
+				break;
+			case "finish_step":
+				await onFinishStepPart?.(value);
+				break;
+			case "start_step":
+				await onStartStepPart?.(value);
+				break;
+			default: throw new Error(`Unknown stream part type: ${type}`);
+		}
+	}
+}
+//#endregion
 //#region src/utils/client-tool-model-output.ts
 /**
 * Normalize modelOutput from toModelOutput() to the AI SDK V2 tool result
@@ -1543,7 +2119,7 @@ var Agent = class extends BaseResource {
 				replaceLastMessage
 			});
 		}
-		await (0, _ai_sdk_ui_utils.processDataStream)({
+		await processDataStream({
 			stream,
 			onTextPart(value) {
 				if (currentTextPart == null) {
@@ -1634,7 +2210,7 @@ var Agent = class extends BaseResource {
 			onToolCallDeltaPart(value) {
 				const partialToolCall = partialToolCalls[value.toolCallId];
 				partialToolCall.text += value.argsTextDelta;
-				const { value: partialArgs } = (0, _ai_sdk_ui_utils.parsePartialJson)(partialToolCall.text);
+				const { value: partialArgs } = parsePartialJson(partialToolCall.text);
 				const invocation = {
 					state: "partial-call",
 					step: partialToolCall.step,
@@ -1649,7 +2225,7 @@ var Agent = class extends BaseResource {
 			},
 			async onToolCallPart(value) {
 				const partialToolCall = partialToolCalls[value.toolCallId];
-				const streamedArgs = partialToolCall?.text ? (0, _ai_sdk_ui_utils.parsePartialJson)(partialToolCall.text).value : void 0;
+				const streamedArgs = partialToolCall?.text ? parsePartialJson(partialToolCall.text).value : void 0;
 				const toolCall = streamedArgs === void 0 ? value : {
 					...value,
 					args: streamedArgs
@@ -1764,7 +2340,7 @@ var Agent = class extends BaseResource {
 			headers: response.headers
 		});
 		streamResponse.processDataStream = async (options = {}) => {
-			await (0, _ai_sdk_ui_utils.processDataStream)({
+			await processDataStream({
 				stream: streamResponse.body,
 				...options
 			});
@@ -1888,7 +2464,7 @@ var Agent = class extends BaseResource {
 						break;
 					case "tool-call": {
 						const partialToolCall = partialToolCalls[chunk.payload.toolCallId];
-						const streamedArgs = partialToolCall?.text ? (0, _ai_sdk_ui_utils.parsePartialJson)(partialToolCall.text).value : void 0;
+						const streamedArgs = partialToolCall?.text ? parsePartialJson(partialToolCall.text).value : void 0;
 						const toolCall = streamedArgs === void 0 ? chunk.payload : {
 							...chunk.payload,
 							args: streamedArgs
@@ -1947,7 +2523,7 @@ var Agent = class extends BaseResource {
 					case "tool-call-delta": {
 						const partialToolCall = partialToolCalls[chunk.payload.toolCallId];
 						partialToolCall.text += chunk.payload.argsTextDelta;
-						const { value: partialArgs } = (0, _ai_sdk_ui_utils.parsePartialJson)(partialToolCall.text);
+						const { value: partialArgs } = parsePartialJson(partialToolCall.text);
 						const invocation = {
 							state: "partial-call",
 							step: partialToolCall.step,
@@ -6430,6 +7006,7 @@ var AgentControllerSession = class extends BaseResource {
 			body: {
 				toolCallId,
 				approved,
+				...options?.alwaysAllowCategory ? { alwaysAllowCategory: true } : {},
 				...requestContext ? { requestContext } : {}
 			}
 		});