@mastra/client-js 1.55.1-alpha.0 → 1.56.0-alpha.2

package/dist/index.js

@@ -1,4 +1,3 @@
-import { parsePartialJson, processDataStream } from "@ai-sdk/ui-utils";
 import { v4 } from "@lukeed/uuid";
 import { getErrorFromUnknown } from "@mastra/core/error";
 import { standardSchemaToJSONSchema, toStandardSchema } from "@mastra/schema-compat/schema";
@@ -386,6 +385,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
@@ -7851,11 +8427,21 @@ var MastraClient = class extends BaseResource {
 	* Lists all datasets with optional pagination
 	*/
 	listDatasets(params) {
+		if (params?.datasetIds?.length === 0) return Promise.resolve({
+			datasets: [],
+			pagination: {
+				total: 0,
+				page: 0,
+				perPage: false,
+				hasMore: false
+			}
+		});
 		const searchParams = new URLSearchParams();
 		if (params?.page !== void 0) searchParams.set("page", String(params.page));
 		if (params?.perPage !== void 0) searchParams.set("perPage", String(params.perPage));
 		if (params?.targetType !== void 0) searchParams.set("targetType", params.targetType);
 		for (const id of params?.targetIds ?? []) searchParams.append("targetIds", id);
+		for (const id of params?.datasetIds ?? []) searchParams.append("datasetIds", id);
 		if (params?.orderBy) {
 			searchParams.set("orderBy[field]", params.orderBy.field);
 			searchParams.set("orderBy[direction]", params.orderBy.direction);