@mastra/connect 1.1.0-alpha.1 → 1.1.0-alpha.3

package/dist/index.cjs

@@ -7888,10 +7888,15 @@ const SentenceSchema = zod.z.object({
 	speaker_name: zod.z.string().nullish(),
 	speaker_id: zod.z.string().nullish(),
 	raw_text: zod.z.string().nullish(),
-	start_time: zod.z.string().nullish(),
-	end_time: zod.z.string().nullish(),
+	start_time: zod.z.number().nullish(),
+	end_time: zod.z.number().nullish(),
 	text: zod.z.string().nullish()
 });
+const ProviderSentenceSchema = SentenceSchema.extend({
+	speaker_id: zod.z.union([zod.z.string(), zod.z.number()]).nullish(),
+	start_time: zod.z.union([zod.z.number(), zod.z.string()]).nullish(),
+	end_time: zod.z.union([zod.z.number(), zod.z.string()]).nullish()
+});
 const SummarySectionSchema = zod.z.object({
 	title: zod.z.string().nullish(),
 	content: zod.z.string().nullish()
@@ -7958,7 +7963,7 @@ const AnalyticsSchema = zod.z.object({
 const TranscriptSchema = zod.z.object({
 	id: zod.z.string().nullish(),
 	title: zod.z.string().nullish(),
-	sentences: zod.z.array(SentenceSchema).nullish(),
+	sentences: zod.z.array(ProviderSentenceSchema).nullish(),
 	summary: ProviderSummarySchema$1.nullable().optional(),
 	speakers: zod.z.array(SpeakerSchema).nullish(),
 	meeting_info: MeetingInfoSchema.nullable().optional(),
@@ -7986,6 +7991,22 @@ const getTranscriptOutputSchema = zod.z.object({
 function normalizeActionItems$1(actionItems) {
 	return Array.isArray(actionItems) ? actionItems.join("\n") : actionItems;
 }
+function toFiniteNumber(value) {
+	if (value == null) return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	const parsed = Number(trimmed);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeSentence(sentence) {
+	return {
+		...sentence,
+		speaker_id: sentence.speaker_id != null ? String(sentence.speaker_id) : sentence.speaker_id,
+		start_time: toFiniteNumber(sentence.start_time),
+		end_time: toFiniteNumber(sentence.end_time)
+	};
+}
 function getTranscriptTool(proxy) {
 	return (0, _mastra_core_tools.createTool)({
 		id: "fireflies_get_transcript",
@@ -8091,7 +8112,7 @@ function getTranscriptTool(proxy) {
 			return {
 				id: transcript.id ?? void 0,
 				title: transcript.title ?? void 0,
-				sentences: transcript.sentences ?? void 0,
+				sentences: transcript.sentences ? transcript.sentences.map(normalizeSentence) : void 0,
 				summary: transcript.summary ? {
 					...transcript.summary,
 					action_items: transcript.summary.action_items != null ? normalizeActionItems$1(transcript.summary.action_items) : transcript.summary.action_items
@@ -19820,11 +19841,11 @@ function insertTextTool(proxy) {
 }
 //#endregion
 //#region src/providers/google-docs/tools/list-revisions.ts
-const listRevisionsInputSchema = zod.z.object({
+const listRevisionsInputSchema$1 = zod.z.object({
 	documentId: zod.z.string().describe("Google Docs document ID. Example: \"1Kj3d86Z-Sfd56YP4dImQ-ggMRyP2QZ_BRO33zOO224c\""),
 	pageToken: zod.z.string().optional().describe("Pagination token from the previous response. Omit for the first page.")
 });
-const LastModifyingUserSchema = zod.z.object({
+const LastModifyingUserSchema$1 = zod.z.object({
 	kind: zod.z.string().optional(),
 	displayName: zod.z.string().optional(),
 	photoLink: zod.z.string().optional(),
@@ -19832,27 +19853,27 @@ const LastModifyingUserSchema = zod.z.object({
 	permissionId: zod.z.string().optional(),
 	emailAddress: zod.z.string().optional()
 });
-const RevisionSchema = zod.z.object({
+const RevisionSchema$1 = zod.z.object({
 	id: zod.z.string(),
 	modifiedTime: zod.z.string().optional(),
-	lastModifyingUser: LastModifyingUserSchema.optional(),
+	lastModifyingUser: LastModifyingUserSchema$1.optional(),
 	keepForever: zod.z.boolean().optional(),
 	published: zod.z.boolean().optional()
 });
-const listRevisionsOutputSchema = zod.z.object({
-	revisions: zod.z.array(RevisionSchema),
+const listRevisionsOutputSchema$1 = zod.z.object({
+	revisions: zod.z.array(RevisionSchema$1),
 	nextPageToken: zod.z.string().optional()
 });
-const DriveRevisionsResponseSchema = zod.z.object({
+const DriveRevisionsResponseSchema$1 = zod.z.object({
 	nextPageToken: zod.z.string().optional(),
 	revisions: zod.z.array(zod.z.unknown()).optional()
 });
-function listRevisionsTool(proxy) {
+function listRevisionsTool$1(proxy) {
 	return (0, _mastra_core_tools.createTool)({
 		id: "google_docs_list_revisions",
 		description: "List the revision history for a Google Doc.",
-		inputSchema: listRevisionsInputSchema,
-		outputSchema: listRevisionsOutputSchema,
+		inputSchema: listRevisionsInputSchema$1,
+		outputSchema: listRevisionsOutputSchema$1,
 		execute: async (input, { requestContext }) => {
 			const platformProxy = proxy.withRequestContext(requestContext);
 			const response = await platformProxy.get({
@@ -19865,7 +19886,7 @@ function listRevisionsTool(proxy) {
 				baseUrlOverride: "https://www.googleapis.com",
 				retries: 3
 			});
-			const parsedResponse = DriveRevisionsResponseSchema.safeParse(response.data);
+			const parsedResponse = DriveRevisionsResponseSchema$1.safeParse(response.data);
 			if (!parsedResponse.success) throw new platformProxy.ActionError({
 				type: "invalid_response",
 				message: "Invalid response from Google Drive API"
@@ -19873,7 +19894,7 @@ function listRevisionsTool(proxy) {
 			const rawRevisions = parsedResponse.data.revisions ?? [];
 			const revisions = [];
 			for (const rawRevision of rawRevisions) {
-				const parsedRevision = RevisionSchema.safeParse(rawRevision);
+				const parsedRevision = RevisionSchema$1.safeParse(rawRevision);
 				if (parsedRevision.success) revisions.push(parsedRevision.data);
 			}
 			return {
@@ -20769,7 +20790,7 @@ function createGoogleDocsTools(options) {
 		google_docs_insert_table_row: insertTableRowTool$1(platformProxy),
 		google_docs_insert_table: insertTableTool(platformProxy),
 		google_docs_insert_text: insertTextTool(platformProxy),
-		google_docs_list_revisions: listRevisionsTool(platformProxy),
+		google_docs_list_revisions: listRevisionsTool$1(platformProxy),
 		google_docs_merge_table_cells: mergeTableCellsTool(platformProxy),
 		google_docs_pin_table_header_rows: pinTableHeaderRowsTool(platformProxy),
 		google_docs_replace_all_text: replaceAllTextTool(platformProxy),
@@ -20923,7 +20944,10 @@ function createFolderTool(proxy) {
 			if (input.parentId) requestBody["parents"] = [input.parentId];
 			const response = await platformProxy.post({
 				endpoint: "/drive/v3/files",
-				params: { fields: "id,name,mimeType,createdTime,parents" },
+				params: {
+					supportsAllDrives: "true",
+					fields: "id,name,mimeType,createdTime,parents"
+				},
 				data: requestBody,
 				retries: 3
 			});
@@ -21122,6 +21146,56 @@ function emptyTrashTool(proxy) {
 	});
 }
 //#endregion
+//#region src/providers/google-drive/tools/export-file.ts
+const exportFileInputSchema = zod.z.object({
+	fileId: zod.z.string().describe("The ID of the Google Workspace file to export (Doc, Sheet, Slide, etc.). Example: \"1Kj3d86Z-Sfd56YP4dImQ-ggMRyP2QZ_BRO33zOO224c\""),
+	mimeType: zod.z.enum([
+		"application/pdf",
+		"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		"text/html",
+		"text/plain",
+		"text/csv",
+		"application/rtf",
+		"application/epub+zip"
+	]).describe("The target MIME type for the export.")
+});
+const exportFileOutputSchema = zod.z.object({
+	fileId: zod.z.string(),
+	mimeType: zod.z.string(),
+	data: zod.z.string().describe("The exported file encoded as a base64 string."),
+	size: zod.z.number().describe("The size of the exported data in bytes.")
+});
+function exportFileTool(proxy) {
+	return (0, _mastra_core_tools.createTool)({
+		id: "google_drive_export_file",
+		description: "Export a Google Workspace file (Doc, Sheet, Slide, etc.) to the specified MIME type.",
+		inputSchema: exportFileInputSchema,
+		outputSchema: exportFileOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const rawData = (await platformProxy.get({
+				endpoint: `/drive/v3/files/${encodeURIComponent(input.fileId)}/export`,
+				params: { mimeType: input.mimeType },
+				responseType: "arraybuffer",
+				retries: 3
+			})).data;
+			if (typeof rawData !== "object" || rawData === null) throw new platformProxy.ActionError({
+				type: "invalid_response",
+				message: "Expected binary response from export API."
+			});
+			const buffer = Buffer.isBuffer(rawData) ? rawData : Buffer.from(rawData);
+			return {
+				fileId: input.fileId,
+				mimeType: input.mimeType,
+				data: buffer.toString("base64"),
+				size: buffer.length
+			};
+		}
+	});
+}
+//#endregion
 //#region src/providers/google-drive/tools/find-file.ts
 const findFileInputSchema = zod.z.object({
 	query: zod.z.string().optional().describe("Search query string. Uses Google Drive search query syntax. Example: \"name contains 'report'\" or \"mimeType = 'application/pdf'\". If not provided, returns all files."),
@@ -21947,6 +22021,70 @@ function listPermissionsTool(proxy) {
 	});
 }
 //#endregion
+//#region src/providers/google-drive/tools/list-revisions.ts
+const listRevisionsInputSchema = zod.z.object({
+	fileId: zod.z.string().describe("The Drive file ID. Example: \"1Kj3d86Z-Sfd56YP4dImQ-ggMRyP2QZ_BRO33zOO224c\""),
+	pageToken: zod.z.string().optional().describe("Pagination token from the previous response. Omit for the first page.")
+});
+const LastModifyingUserSchema = zod.z.object({
+	kind: zod.z.string().optional(),
+	displayName: zod.z.string().optional(),
+	photoLink: zod.z.string().optional(),
+	me: zod.z.boolean().optional(),
+	permissionId: zod.z.string().optional(),
+	emailAddress: zod.z.string().optional()
+});
+const RevisionSchema = zod.z.object({
+	id: zod.z.string(),
+	modifiedTime: zod.z.string().optional(),
+	lastModifyingUser: LastModifyingUserSchema.optional(),
+	keepForever: zod.z.boolean().optional(),
+	published: zod.z.boolean().optional()
+});
+const listRevisionsOutputSchema = zod.z.object({
+	revisions: zod.z.array(RevisionSchema),
+	nextPageToken: zod.z.string().optional()
+});
+const DriveRevisionsResponseSchema = zod.z.object({
+	nextPageToken: zod.z.string().optional(),
+	revisions: zod.z.array(zod.z.unknown()).optional()
+});
+function listRevisionsTool(proxy) {
+	return (0, _mastra_core_tools.createTool)({
+		id: "google_drive_list_revisions",
+		description: "List the revision history for a Drive file.",
+		inputSchema: listRevisionsInputSchema,
+		outputSchema: listRevisionsOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const response = await platformProxy.get({
+				endpoint: `/drive/v3/files/${encodeURIComponent(input.fileId)}/revisions`,
+				params: {
+					fields: "nextPageToken,revisions(id,modifiedTime,lastModifyingUser,keepForever,published)",
+					pageSize: "100",
+					...input.pageToken !== void 0 && { pageToken: input.pageToken }
+				},
+				retries: 3
+			});
+			const parsedResponse = DriveRevisionsResponseSchema.safeParse(response.data);
+			if (!parsedResponse.success) throw new platformProxy.ActionError({
+				type: "invalid_response",
+				message: "Invalid response from Google Drive API"
+			});
+			const rawRevisions = parsedResponse.data.revisions ?? [];
+			const revisions = [];
+			for (const rawRevision of rawRevisions) {
+				const parsedRevision = RevisionSchema.safeParse(rawRevision);
+				if (parsedRevision.success) revisions.push(parsedRevision.data);
+			}
+			return {
+				revisions,
+				...parsedResponse.data.nextPageToken !== void 0 && { nextPageToken: parsedResponse.data.nextPageToken }
+			};
+		}
+	});
+}
+//#endregion
 //#region src/providers/google-drive/tools/move-file.ts
 const moveFileInputSchema = zod.z.object({
 	fileId: zod.z.string().describe("The ID of the file to move. Example: \"1mD3ukEAmRqo8u0RF_Cr6IJl9f_uWTYH03vesDhB5Svw\""),
@@ -21972,6 +22110,7 @@ function moveFileTool(proxy) {
 				params: {
 					addParents: input.toFolderId,
 					removeParents: input.fromFolderId,
+					supportsAllDrives: "true",
 					fields: "id,name,mimeType,parents"
 				},
 				retries: 3
@@ -22321,7 +22460,10 @@ function uploadDocumentTool(proxy) {
 			if (input.folderId) metadataBody["parents"] = [input.folderId];
 			const createResponse = await platformProxy.post({
 				endpoint: "/drive/v3/files",
-				params: { fields: "id,name,mimeType,webViewLink,webContentLink" },
+				params: {
+					supportsAllDrives: "true",
+					fields: "id,name,mimeType,webViewLink,webContentLink"
+				},
 				data: metadataBody,
 				retries: 3
 			});
@@ -22336,6 +22478,7 @@ function uploadDocumentTool(proxy) {
 					endpoint: `/upload/drive/v3/files/${fileId}`,
 					params: {
 						uploadType: "media",
+						supportsAllDrives: "true",
 						fields: "id,name,mimeType,webViewLink,webContentLink"
 					},
 					headers: { "Content-Type": input.mimeType },
@@ -22346,6 +22489,7 @@ function uploadDocumentTool(proxy) {
 				const status = error?.response?.status;
 				if (typeof status === "number" && status >= 400 && status < 500) await platformProxy.delete({
 					endpoint: `/drive/v3/files/${fileId}`,
+					params: { supportsAllDrives: "true" },
 					retries: 3
 				}).catch(() => void 0);
 				throw error;
@@ -22382,6 +22526,7 @@ function createGoogleDriveTools(options) {
 		google_drive_delete_permission: deletePermissionTool(platformProxy),
 		google_drive_delete_shared_drive: deleteSharedDriveTool(platformProxy),
 		google_drive_empty_trash: emptyTrashTool(platformProxy),
+		google_drive_export_file: exportFileTool(platformProxy),
 		google_drive_find_file: findFileTool(platformProxy),
 		google_drive_find_folder: findFolderTool(platformProxy),
 		google_drive_get_about: getAboutTool(platformProxy),
@@ -22396,6 +22541,7 @@ function createGoogleDriveTools(options) {
 		google_drive_list_drives: listDrivesTool(platformProxy),
 		google_drive_list_files_non_unified: listFilesNonUnifiedTool(platformProxy),
 		google_drive_list_permissions: listPermissionsTool(platformProxy),
+		google_drive_list_revisions: listRevisionsTool(platformProxy),
 		google_drive_move_file: moveFileTool(platformProxy),
 		google_drive_unhide_shared_drive: unhideSharedDriveTool(platformProxy),
 		google_drive_update_comment: updateCommentTool$2(platformProxy),
@@ -75103,8 +75249,14 @@ let nextResolverId = 0;
 * Expected provider absence is silently skipped. Actionable per-integration
 * problems during resolution (needs re-auth or ambiguity) are downgraded to
 * warn-and-skip so one bad integration never takes down the whole toolset.
+*
+* Pass a callback instead of an options object to vary options per request
+* (see {@link ToolsOptionsInput}). With the callback form, configuration
+* validation runs at the first resolution that produces a given options
+* value — still failing loudly — instead of at call time.
 */
 function tools(options = {}) {
+	if (typeof options === "function") return dynamicTools(options);
 	const projectId = options.projectId?.trim() || process.env.MASTRA_PROJECT_ID?.trim();
 	if (!projectId) throw new MastraConnectError("missing_project_id", "Missing project id: set MASTRA_PROJECT_ID or pass projectId.");
 	if (options.ttlMs !== void 0 && (!Number.isFinite(options.ttlMs) || options.ttlMs < 0)) throw new MastraConnectError("invalid_options", `Invalid ttlMs (${options.ttlMs}): expected a finite number of milliseconds >= 0.`);
@@ -75212,6 +75364,130 @@ function tools(options = {}) {
 	return resolver;
 }
 /**
+* Most distinct options values a callback-form resolver keeps live caches
+* (and MCP clients) for at once. Callbacks are expected to produce a small,
+* closed set of option shapes (one per role, say); the cap exists so a
+* callback that accidentally derives options from unbounded per-request data
+* cannot leak an MCP client per request. Eviction is least-recently-used and
+* disconnects the evicted variant's transports.
+*/
+const MAX_OPTION_VARIANTS = 32;
+/**
+* Builds the callback-form resolver: each resolution invokes `getOptions`
+* with the request context, then delegates to a memoized static resolver for
+* that options value, so every distinct options value gets its own snapshot
+* cache with the normal TTL / stale-while-revalidate semantics. Options
+* validation happens when a value is first seen (inside `tools()`), so
+* configuration errors fail that resolution loudly instead of being
+* swallowed.
+*/
+function dynamicTools(getOptions) {
+	const variants = /* @__PURE__ */ new Map();
+	let closing;
+	const disconnectEvicted = (entry) => {
+		entry.resolver.disconnect().catch((error) => {
+			console.warn(`[@mastra/connect] Failed to disconnect evicted tools variant: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	const releaseVariant = (entry) => {
+		entry.inUse -= 1;
+		if (entry.evicted && entry.inUse === 0) disconnectEvicted(entry);
+	};
+	const acquireVariant = async (ctx) => {
+		if (closing) await closing;
+		const options = await getOptions(ctx);
+		if (closing) await closing;
+		if (typeof options !== "object" || options === null || Array.isArray(options)) throw new MastraConnectError("invalid_options", `The tools() options callback must return a ToolsOptions object, got ${options === null ? "null" : Array.isArray(options) ? "an array" : typeof options}.`);
+		const key = hashOptions(options);
+		const existing = variants.get(key);
+		if (existing) {
+			variants.delete(key);
+			variants.set(key, existing);
+			existing.inUse += 1;
+			return existing;
+		}
+		const entry = {
+			resolver: tools(options),
+			inUse: 1,
+			evicted: false
+		};
+		variants.set(key, entry);
+		if (variants.size > MAX_OPTION_VARIANTS) {
+			const [oldestKey, oldest] = variants.entries().next().value;
+			variants.delete(oldestKey);
+			console.warn(`[@mastra/connect] tools() options callback produced more than ${MAX_OPTION_VARIANTS} distinct options values; evicting the least recently used variant. Derive options from a small, closed set of inputs (e.g. roles), not per-request data.`);
+			oldest.evicted = true;
+			if (oldest.inUse === 0) disconnectEvicted(oldest);
+		}
+		return entry;
+	};
+	const resolve = async (ctx) => {
+		const entry = await acquireVariant(ctx);
+		try {
+			return await entry.resolver(ctx);
+		} finally {
+			releaseVariant(entry);
+		}
+	};
+	const resolver = Object.assign(resolve, {
+		refresh: async () => {
+			const entry = await acquireVariant(void 0);
+			try {
+				return await entry.resolver.refresh();
+			} finally {
+				releaseVariant(entry);
+			}
+		},
+		disconnect: () => {
+			closing ??= (async () => {
+				try {
+					const all = Array.from(variants.values());
+					variants.clear();
+					await Promise.allSettled(all.map((entry) => entry.resolver.disconnect()));
+				} finally {
+					closing = void 0;
+				}
+			})();
+			return closing;
+		},
+		with: (extra) => withExtraTools(resolver, extra)
+	});
+	return resolver;
+}
+/** Identity registry for non-serializable option values (e.g. a custom `client.fetch`). */
+const functionIdentity = /* @__PURE__ */ new WeakMap();
+let nextFunctionIdentity = 0;
+/**
+* Stable key for an options value: JSON with sorted object keys, so two
+* callbacks returning structurally equal options share one cached variant.
+* Functions (and other non-plain values) hash by identity — the same
+* instance maps to the same key, two different instances to different keys —
+* which is the safe direction: at worst a duplicate cache entry, never a
+* false merge of different configurations.
+*/
+function hashOptions(options) {
+	const byIdentity = (value) => {
+		let id = functionIdentity.get(value);
+		if (id === void 0) {
+			id = ++nextFunctionIdentity;
+			functionIdentity.set(value, id);
+		}
+		return `__identity_${id}__`;
+	};
+	const encode = (value) => {
+		if (value === void 0) return "__undefined__";
+		if (typeof value === "function") return byIdentity(value);
+		if (Array.isArray(value)) return value.map(encode);
+		if (typeof value === "object" && value !== null) {
+			const proto = Object.getPrototypeOf(value);
+			if (proto !== Object.prototype && proto !== null) return byIdentity(value);
+			return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([entryKey, entryValue]) => [entryKey, encode(entryValue)]));
+		}
+		return value;
+	};
+	return JSON.stringify(encode(options));
+}
+/**
 * Builds the resolver `.with()` returns: resolutions merge the base
 * resolver's tools with `extra` (extra wins on key collision), cache handles
 * delegate to the base, and further `.with()` calls chain.