@mastra/connect 0.6.0 → 0.7.0-alpha.0

package/dist/index.js

@@ -13367,6 +13367,817 @@ const githubProvider = {
 	createTools: createGithubTools
 };
 //#endregion
+//#region src/providers/google-analytics/tools/archive-conversion-event.ts
+const archiveConversionEventInputSchema = z.object({
+	property_id: z.string().describe("GA4 property numeric ID. Example: \"12345\""),
+	conversion_event_id: z.string().describe("Conversion event numeric ID. Example: \"67890\"")
+});
+const archiveConversionEventOutputSchema = z.object({
+	success: z.boolean(),
+	name: z.string().describe("Resource name of the archived conversion event.")
+});
+function archiveConversionEventTool(proxy) {
+	return createTool({
+		id: "google_analytics_archive_conversion_event",
+		description: "Archive a GA4 conversion event.",
+		inputSchema: archiveConversionEventInputSchema,
+		outputSchema: archiveConversionEventOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const name = `properties/${input.property_id}/conversionEvents/${input.conversion_event_id}`;
+			await platformProxy.delete({
+				endpoint: `/v1beta/properties/${encodeURIComponent(input.property_id)}/conversionEvents/${encodeURIComponent(input.conversion_event_id)}`,
+				baseUrlOverride: "https://analyticsadmin.googleapis.com",
+				retries: 3
+			});
+			return {
+				success: true,
+				name
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/batch-run-reports.ts
+const DateRangeSchema$1 = z.object({
+	startDate: z.string(),
+	endDate: z.string()
+});
+const DimensionSchema$9 = z.object({ name: z.string() });
+const MetricSchema$3 = z.object({ name: z.string() });
+const ReportRequestSchema = z.object({
+	dimensions: z.array(DimensionSchema$9).optional(),
+	metrics: z.array(MetricSchema$3).optional(),
+	dateRanges: z.array(DateRangeSchema$1).optional(),
+	offset: z.string().optional(),
+	limit: z.string().optional(),
+	keepEmptyRows: z.boolean().optional(),
+	returnPropertyQuota: z.boolean().optional()
+}).passthrough();
+const batchRunReportsInputSchema = z.object({
+	property: z.string().describe("Google Analytics property ID. Example: \"properties/123456789\""),
+	requests: z.array(ReportRequestSchema).min(1).max(5)
+});
+const DimensionValueSchema$2 = z.object({ value: z.string().optional() });
+const MetricValueSchema$2 = z.object({ value: z.string().optional() });
+const RowSchema$2 = z.object({
+	dimensionValues: z.array(DimensionValueSchema$2).optional(),
+	metricValues: z.array(MetricValueSchema$2).optional()
+});
+const DimensionHeaderSchema$2 = z.object({ name: z.string().optional() });
+const MetricHeaderSchema$2 = z.object({
+	name: z.string().optional(),
+	type: z.string().optional()
+});
+const RunReportResponseSchema = z.object({
+	dimensionHeaders: z.array(DimensionHeaderSchema$2).optional(),
+	metricHeaders: z.array(MetricHeaderSchema$2).optional(),
+	rows: z.array(RowSchema$2).optional(),
+	totals: z.array(RowSchema$2).optional(),
+	maximums: z.array(RowSchema$2).optional(),
+	minimums: z.array(RowSchema$2).optional(),
+	rowCount: z.number().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	propertyQuota: z.record(z.string(), z.unknown()).optional(),
+	kind: z.string().optional()
+});
+const batchRunReportsOutputSchema = z.object({
+	reports: z.array(RunReportResponseSchema),
+	kind: z.string().optional()
+});
+function batchRunReportsTool(proxy) {
+	return createTool({
+		id: "google_analytics_batch_run_reports",
+		description: "Run multiple GA4 reports in one request.",
+		inputSchema: batchRunReportsInputSchema,
+		outputSchema: batchRunReportsOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const propertyId = input.property.replace(/^properties\//, "");
+			const response = await platformProxy.post({
+				endpoint: `/v1beta/properties/${encodeURIComponent(propertyId)}:batchRunReports`,
+				baseUrlOverride: "https://analyticsdata.googleapis.com",
+				data: { requests: input.requests },
+				retries: 3
+			});
+			const providerResponse = z.object({
+				reports: z.array(z.unknown()).optional(),
+				kind: z.string().optional()
+			}).parse(response.data);
+			return {
+				reports: providerResponse.reports?.map((report) => RunReportResponseSchema.parse(report)) ?? [],
+				kind: providerResponse.kind
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/create-conversion-event.ts
+const DefaultConversionValueInputSchema = z.object({
+	value: z.number(),
+	currencyCode: z.string()
+});
+const createConversionEventInputSchema = z.object({
+	propertyId: z.string().describe("GA4 property ID. Example: \"123456789\""),
+	eventName: z.string().describe("The event name for this conversion event. Example: \"click\""),
+	countingMethod: z.string().optional().describe("Optional. The method by which conversions will be counted. Example: \"ONCE_PER_EVENT\""),
+	defaultConversionValue: DefaultConversionValueInputSchema.optional().describe("Optional. Defines a default value/currency for a conversion event.")
+});
+const ProviderDefaultConversionValueSchema = z.object({
+	value: z.number(),
+	currencyCode: z.string()
+});
+const ProviderConversionEventSchema = z.object({
+	name: z.string(),
+	eventName: z.string(),
+	createTime: z.string().optional(),
+	deletable: z.boolean().optional(),
+	custom: z.boolean().optional(),
+	countingMethod: z.string().optional(),
+	defaultConversionValue: ProviderDefaultConversionValueSchema.optional()
+});
+const createConversionEventOutputSchema = z.object({
+	name: z.string(),
+	eventName: z.string(),
+	createTime: z.string().optional(),
+	deletable: z.boolean().optional(),
+	custom: z.boolean().optional(),
+	countingMethod: z.string().optional(),
+	defaultConversionValue: z.object({
+		value: z.number(),
+		currencyCode: z.string()
+	}).optional()
+});
+function createConversionEventTool(proxy) {
+	return createTool({
+		id: "google_analytics_create_conversion_event",
+		description: "Create a conversion event for a GA4 property.",
+		inputSchema: createConversionEventInputSchema,
+		outputSchema: createConversionEventOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const response = await proxy.withRequestContext(requestContext).post({
+				endpoint: `/v1beta/properties/${encodeURIComponent(input.propertyId)}/conversionEvents`,
+				data: {
+					eventName: input.eventName,
+					...input.countingMethod !== void 0 && { countingMethod: input.countingMethod },
+					...input.defaultConversionValue !== void 0 && { defaultConversionValue: input.defaultConversionValue }
+				},
+				retries: 3,
+				baseUrlOverride: "https://analyticsadmin.googleapis.com"
+			});
+			const providerEvent = ProviderConversionEventSchema.parse(response.data);
+			return {
+				name: providerEvent.name,
+				eventName: providerEvent.eventName,
+				...providerEvent.createTime !== void 0 && { createTime: providerEvent.createTime },
+				...providerEvent.deletable !== void 0 && { deletable: providerEvent.deletable },
+				...providerEvent.custom !== void 0 && { custom: providerEvent.custom },
+				...providerEvent.countingMethod !== void 0 && { countingMethod: providerEvent.countingMethod },
+				...providerEvent.defaultConversionValue !== void 0 && { defaultConversionValue: providerEvent.defaultConversionValue }
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/create-data-stream.ts
+const DataStreamTypeSchema = z.enum([
+	"DATA_STREAM_TYPE_UNSPECIFIED",
+	"WEB_DATA_STREAM",
+	"ANDROID_APP_DATA_STREAM",
+	"IOS_APP_DATA_STREAM"
+]).or(z.string());
+const WebStreamDataInputSchema = z.object({ default_uri: z.string().describe("Domain name of the web app being measured. Example: \"https://www.example.com\"") });
+const AndroidAppStreamDataInputSchema = z.object({ package_name: z.string().describe("The package name for the app being measured. Example: \"com.example.myandroidapp\"") });
+const IosAppStreamDataInputSchema = z.object({ bundle_id: z.string().describe("The Apple App Store Bundle ID for the app. Example: \"com.example.myiosapp\"") });
+const CommonInputSchema = {
+	property_id: z.string().describe("GA4 property numeric ID. Example: \"1234\""),
+	display_name: z.string().describe("Human-readable display name for the Data Stream.")
+};
+const createDataStreamInputSchema = z.discriminatedUnion("type", [
+	z.object({
+		...CommonInputSchema,
+		type: z.literal("WEB_DATA_STREAM"),
+		web_stream_data: WebStreamDataInputSchema.describe("Data specific to web streams. Required when type is WEB_DATA_STREAM.")
+	}),
+	z.object({
+		...CommonInputSchema,
+		type: z.literal("ANDROID_APP_DATA_STREAM"),
+		android_app_stream_data: AndroidAppStreamDataInputSchema.describe("Data specific to Android app streams. Required when type is ANDROID_APP_DATA_STREAM.")
+	}),
+	z.object({
+		...CommonInputSchema,
+		type: z.literal("IOS_APP_DATA_STREAM"),
+		ios_app_stream_data: IosAppStreamDataInputSchema.describe("Data specific to iOS app streams. Required when type is IOS_APP_DATA_STREAM.")
+	}),
+	z.object({
+		...CommonInputSchema,
+		type: z.literal("DATA_STREAM_TYPE_UNSPECIFIED")
+	})
+]);
+const WebStreamDataSchema$1 = z.object({
+	measurementId: z.string().optional(),
+	firebaseAppId: z.string().optional(),
+	defaultUri: z.string().optional()
+});
+const AndroidAppStreamDataSchema$1 = z.object({
+	firebaseAppId: z.string().optional(),
+	packageName: z.string().optional()
+});
+const IosAppStreamDataSchema$1 = z.object({
+	firebaseAppId: z.string().optional(),
+	bundleId: z.string().optional()
+});
+const DataStreamSchema$1 = z.object({
+	name: z.string().optional(),
+	type: DataStreamTypeSchema.optional(),
+	displayName: z.string().optional(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	webStreamData: WebStreamDataSchema$1.optional(),
+	androidAppStreamData: AndroidAppStreamDataSchema$1.optional(),
+	iosAppStreamData: IosAppStreamDataSchema$1.optional()
+});
+const createDataStreamOutputSchema = z.object({
+	name: z.string().optional(),
+	type: DataStreamTypeSchema.optional(),
+	displayName: z.string().optional(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	webStreamData: WebStreamDataSchema$1.optional(),
+	androidAppStreamData: AndroidAppStreamDataSchema$1.optional(),
+	iosAppStreamData: IosAppStreamDataSchema$1.optional()
+});
+function createDataStreamTool(proxy) {
+	return createTool({
+		id: "google_analytics_create_data_stream",
+		description: "Create a data stream for a GA4 property.",
+		inputSchema: createDataStreamInputSchema,
+		outputSchema: createDataStreamOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const body = {
+				type: input.type,
+				displayName: input.display_name
+			};
+			if (input.type === "WEB_DATA_STREAM") body.webStreamData = { defaultUri: input.web_stream_data.default_uri };
+			else if (input.type === "ANDROID_APP_DATA_STREAM") body.androidAppStreamData = { packageName: input.android_app_stream_data.package_name };
+			else if (input.type === "IOS_APP_DATA_STREAM") body.iosAppStreamData = { bundleId: input.ios_app_stream_data.bundle_id };
+			const response = await platformProxy.post({
+				endpoint: `/v1beta/properties/${encodeURIComponent(input.property_id)}/dataStreams`,
+				data: body,
+				baseUrlOverride: "https://analyticsadmin.googleapis.com",
+				retries: 3
+			});
+			const dataStream = DataStreamSchema$1.parse(response.data);
+			return {
+				...dataStream.name !== void 0 && { name: dataStream.name },
+				...dataStream.type !== void 0 && { type: dataStream.type },
+				...dataStream.displayName !== void 0 && { displayName: dataStream.displayName },
+				...dataStream.createTime !== void 0 && { createTime: dataStream.createTime },
+				...dataStream.updateTime !== void 0 && { updateTime: dataStream.updateTime },
+				...dataStream.webStreamData !== void 0 && { webStreamData: dataStream.webStreamData },
+				...dataStream.androidAppStreamData !== void 0 && { androidAppStreamData: dataStream.androidAppStreamData },
+				...dataStream.iosAppStreamData !== void 0 && { iosAppStreamData: dataStream.iosAppStreamData }
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/create-property.ts
+const createPropertyInputSchema$1 = z.object({
+	parent: z.string().describe("The resource name of the account under which to create the property. Example: \"accounts/12345\""),
+	displayName: z.string().describe("Human-readable display name for the property. Max 100 UTF-16 code units."),
+	timeZone: z.string().describe("Reporting time zone for the property. Example: \"America/Los_Angeles\""),
+	currencyCode: z.string().optional().describe("Currency type used in reports. Example: \"USD\""),
+	industryCategory: z.string().optional().describe("Industry category for benchmarking. Example: \"TECHNOLOGY\""),
+	serviceLevel: z.string().optional().describe("Service level. Example: \"STANDARD\" or \"GOOGLE_ANALYTICS_360\""),
+	propertyType: z.string().optional().describe("Property type. Example: \"ORDINARY_PROPERTY\"")
+});
+const ProviderPropertySchema$1 = z.object({
+	name: z.string(),
+	parent: z.string(),
+	displayName: z.string(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	timeZone: z.string().optional(),
+	currencyCode: z.string().optional(),
+	industryCategory: z.string().optional(),
+	serviceLevel: z.string().optional(),
+	propertyType: z.string().optional(),
+	account: z.string().optional(),
+	deleteTime: z.string().optional(),
+	expireTime: z.string().optional()
+});
+const createPropertyOutputSchema$1 = z.object({
+	name: z.string().describe("Resource name of the created property. Example: \"properties/12345\""),
+	parent: z.string().describe("Parent account name. Example: \"accounts/12345\""),
+	displayName: z.string(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	timeZone: z.string().optional(),
+	currencyCode: z.string().optional(),
+	industryCategory: z.string().optional(),
+	serviceLevel: z.string().optional(),
+	propertyType: z.string().optional(),
+	account: z.string().optional()
+});
+function createPropertyTool$1(proxy) {
+	return createTool({
+		id: "google_analytics_create_property",
+		description: "Create a GA4 property under an account.",
+		inputSchema: createPropertyInputSchema$1,
+		outputSchema: createPropertyOutputSchema$1,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const requestBody = {
+				parent: input.parent,
+				displayName: input.displayName
+			};
+			if (input.timeZone !== void 0) requestBody.timeZone = input.timeZone;
+			if (input.currencyCode !== void 0) requestBody.currencyCode = input.currencyCode;
+			if (input.industryCategory !== void 0) requestBody.industryCategory = input.industryCategory;
+			if (input.serviceLevel !== void 0) requestBody.serviceLevel = input.serviceLevel;
+			if (input.propertyType !== void 0) requestBody.propertyType = input.propertyType;
+			const response = await platformProxy.post({
+				baseUrlOverride: "https://analyticsadmin.googleapis.com",
+				endpoint: "/v1beta/properties",
+				data: requestBody,
+				retries: 3
+			});
+			if (!response.data) throw new platformProxy.ActionError({
+				type: "provider_error",
+				message: "Empty response from Google Analytics Admin API when creating property."
+			});
+			const providerProperty = ProviderPropertySchema$1.parse(response.data);
+			return {
+				name: providerProperty.name,
+				parent: providerProperty.parent,
+				displayName: providerProperty.displayName,
+				...providerProperty.createTime !== void 0 && { createTime: providerProperty.createTime },
+				...providerProperty.updateTime !== void 0 && { updateTime: providerProperty.updateTime },
+				...providerProperty.timeZone !== void 0 && { timeZone: providerProperty.timeZone },
+				...providerProperty.currencyCode !== void 0 && { currencyCode: providerProperty.currencyCode },
+				...providerProperty.industryCategory !== void 0 && { industryCategory: providerProperty.industryCategory },
+				...providerProperty.serviceLevel !== void 0 && { serviceLevel: providerProperty.serviceLevel },
+				...providerProperty.propertyType !== void 0 && { propertyType: providerProperty.propertyType },
+				...providerProperty.account !== void 0 && { account: providerProperty.account }
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/get-metadata.ts
+const getMetadataInputSchema = z.object({ propertyId: z.string().describe("GA4 property ID. Use \"0\" for universal metadata. Example: \"123456789\"") });
+const DimensionSchema$8 = z.object({
+	apiName: z.string(),
+	uiName: z.string(),
+	description: z.string(),
+	category: z.string(),
+	deprecatedApiNames: z.array(z.string()).optional()
+});
+const MetricSchema$2 = z.object({
+	apiName: z.string(),
+	uiName: z.string(),
+	description: z.string(),
+	type: z.string(),
+	category: z.string(),
+	deprecatedApiNames: z.array(z.string()).optional()
+});
+const getMetadataOutputSchema = z.object({
+	name: z.string(),
+	dimensions: z.array(DimensionSchema$8),
+	metrics: z.array(MetricSchema$2)
+});
+function getMetadataTool(proxy) {
+	return createTool({
+		id: "google_analytics_get_metadata",
+		description: "Retrieve GA4 dimensions and metrics metadata.",
+		inputSchema: getMetadataInputSchema,
+		outputSchema: getMetadataOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const config = {
+				endpoint: `/v1beta/properties/${encodeURIComponent(input.propertyId)}/metadata`,
+				retries: 3,
+				baseUrlOverride: "https://analyticsdata.googleapis.com"
+			};
+			const response = await platformProxy.get(config);
+			if (!response.data) throw new platformProxy.ActionError({
+				type: "not_found",
+				message: "Metadata not found for the specified property."
+			});
+			return getMetadataOutputSchema.parse(response.data);
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/run-pivot-report.ts
+const runPivotReportInputSchema = z.object({
+	property: z.string().describe("Google Analytics property numeric ID. Example: 535258304"),
+	dimensions: z.array(z.record(z.string(), z.unknown())).optional(),
+	metrics: z.array(z.record(z.string(), z.unknown())).optional(),
+	dateRanges: z.array(z.record(z.string(), z.unknown())).optional(),
+	pivots: z.array(z.record(z.string(), z.unknown())).optional(),
+	dimensionFilter: z.record(z.string(), z.unknown()).optional(),
+	metricFilter: z.record(z.string(), z.unknown()).optional(),
+	currencyCode: z.string().optional(),
+	cohortSpec: z.record(z.string(), z.unknown()).optional(),
+	keepEmptyRows: z.boolean().optional(),
+	returnPropertyQuota: z.boolean().optional(),
+	comparisons: z.array(z.record(z.string(), z.unknown())).optional()
+});
+const runPivotReportOutputSchema = z.object({
+	pivotHeaders: z.array(z.record(z.string(), z.unknown())).optional(),
+	dimensionHeaders: z.array(z.record(z.string(), z.unknown())).optional(),
+	metricHeaders: z.array(z.record(z.string(), z.unknown())).optional(),
+	rows: z.array(z.record(z.string(), z.unknown())).optional(),
+	aggregates: z.array(z.record(z.string(), z.unknown())).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	propertyQuota: z.record(z.string(), z.unknown()).optional(),
+	kind: z.string().optional()
+}).passthrough();
+function runPivotReportTool(proxy) {
+	return createTool({
+		id: "google_analytics_run_pivot_report",
+		description: "Run a GA4 pivot report.",
+		inputSchema: runPivotReportInputSchema,
+		outputSchema: runPivotReportOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const { property, ...requestBody } = input;
+			const response = await platformProxy.post({
+				endpoint: `/v1beta/properties/${encodeURIComponent(property)}:runPivotReport`,
+				data: requestBody,
+				baseUrlOverride: "https://analyticsdata.googleapis.com",
+				retries: 3
+			});
+			return runPivotReportOutputSchema.parse(response.data);
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/run-realtime-report.ts
+const DimensionSchema$7 = z.object({ name: z.string().optional() });
+const MetricSchema$1 = z.object({
+	name: z.string().optional(),
+	expression: z.string().optional(),
+	invisible: z.boolean().optional()
+});
+const FilterExpressionSchema = z.object({}).passthrough();
+const OrderBySchema$1 = z.object({}).passthrough();
+const MinuteRangeSchema = z.object({
+	name: z.string().optional(),
+	startMinutesAgo: z.number().optional(),
+	endMinutesAgo: z.number().optional()
+});
+const runRealtimeReportInputSchema = z.object({
+	property: z.string().describe("A Google Analytics property identifier. Example: \"properties/1234\""),
+	dimensions: z.array(DimensionSchema$7).optional(),
+	metrics: z.array(MetricSchema$1).optional(),
+	dimensionFilter: FilterExpressionSchema.optional(),
+	metricFilter: FilterExpressionSchema.optional(),
+	limit: z.string().optional().describe("The number of rows to return. If unspecified, 10,000 rows are returned."),
+	metricAggregations: z.array(z.string()).optional(),
+	orderBys: z.array(OrderBySchema$1).optional(),
+	returnPropertyQuota: z.boolean().optional(),
+	minuteRanges: z.array(MinuteRangeSchema).optional()
+});
+const DimensionHeaderSchema$1 = z.object({ name: z.string().optional() });
+const MetricHeaderSchema$1 = z.object({
+	name: z.string().optional(),
+	type: z.string().optional()
+});
+const DimensionValueSchema$1 = z.object({
+	value: z.string().optional(),
+	oneValue: z.string().optional()
+});
+const MetricValueSchema$1 = z.object({ value: z.string().optional() });
+const RowSchema$1 = z.object({
+	dimensionValues: z.array(DimensionValueSchema$1).optional(),
+	metricValues: z.array(MetricValueSchema$1).optional()
+});
+const PropertyQuotaSchema = z.object({}).passthrough();
+const runRealtimeReportOutputSchema = z.object({
+	dimensionHeaders: z.array(DimensionHeaderSchema$1).optional(),
+	metricHeaders: z.array(MetricHeaderSchema$1).optional(),
+	rows: z.array(RowSchema$1).optional(),
+	totals: z.array(RowSchema$1).optional(),
+	maximums: z.array(RowSchema$1).optional(),
+	minimums: z.array(RowSchema$1).optional(),
+	rowCount: z.number().optional(),
+	propertyQuota: PropertyQuotaSchema.optional(),
+	kind: z.string().optional()
+});
+function runRealtimeReportTool(proxy) {
+	return createTool({
+		id: "google_analytics_run_realtime_report",
+		description: "Run a realtime GA4 report.",
+		inputSchema: runRealtimeReportInputSchema,
+		outputSchema: runRealtimeReportOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const propertyParts = input.property.split("/");
+			if (propertyParts.length !== 2 || propertyParts[0] !== "properties" || !propertyParts[1]) throw new platformProxy.ActionError({
+				type: "invalid_property",
+				message: "Property must be in the format \"properties/{propertyId}\". Example: \"properties/1234\""
+			});
+			const propertyId = encodeURIComponent(propertyParts[1]);
+			const requestBody = {
+				...input.dimensions !== void 0 && { dimensions: input.dimensions },
+				...input.metrics !== void 0 && { metrics: input.metrics },
+				...input.dimensionFilter !== void 0 && { dimensionFilter: input.dimensionFilter },
+				...input.metricFilter !== void 0 && { metricFilter: input.metricFilter },
+				...input.limit !== void 0 && { limit: input.limit },
+				...input.metricAggregations !== void 0 && { metricAggregations: input.metricAggregations },
+				...input.orderBys !== void 0 && { orderBys: input.orderBys },
+				...input.returnPropertyQuota !== void 0 && { returnPropertyQuota: input.returnPropertyQuota },
+				...input.minuteRanges !== void 0 && { minuteRanges: input.minuteRanges }
+			};
+			const response = await platformProxy.post({
+				endpoint: `/v1beta/properties/${propertyId}:runRealtimeReport`,
+				baseUrlOverride: "https://analyticsdata.googleapis.com",
+				data: requestBody,
+				retries: 3
+			});
+			return runRealtimeReportOutputSchema.parse(response.data);
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/run-report.ts
+const DimensionSchema$6 = z.object({ name: z.string() });
+const MetricSchema = z.object({ name: z.string() });
+const DateRangeSchema = z.object({
+	startDate: z.string(),
+	endDate: z.string()
+});
+const OrderBySchema = z.object({
+	dimension: z.object({ dimensionName: z.string() }).optional(),
+	metric: z.object({ metricName: z.string() }).optional(),
+	desc: z.boolean().optional()
+});
+const runReportInputSchema = z.object({
+	property: z.string().describe("GA4 property ID. Example: \"properties/123456789\" or \"123456789\""),
+	dimensions: z.array(DimensionSchema$6).optional(),
+	metrics: z.array(MetricSchema).optional(),
+	dateRanges: z.array(DateRangeSchema).optional(),
+	dimensionFilter: z.object({}).passthrough().optional(),
+	metricFilter: z.object({}).passthrough().optional(),
+	ordering: z.array(OrderBySchema).optional(),
+	limit: z.number().optional()
+});
+const DimensionHeaderSchema = z.object({ name: z.string().optional() });
+const MetricHeaderSchema = z.object({
+	name: z.string().optional(),
+	type: z.string().optional()
+});
+const DimensionValueSchema = z.object({ value: z.string().optional() });
+const MetricValueSchema = z.object({ value: z.string().optional() });
+const RowSchema = z.object({
+	dimensionValues: z.array(DimensionValueSchema).optional(),
+	metricValues: z.array(MetricValueSchema).optional()
+});
+const runReportOutputSchema = z.object({
+	dimensionHeaders: z.array(DimensionHeaderSchema).optional(),
+	metricHeaders: z.array(MetricHeaderSchema).optional(),
+	rows: z.array(RowSchema).optional(),
+	rowCount: z.number().optional(),
+	totals: z.array(RowSchema).optional(),
+	maximums: z.array(RowSchema).optional(),
+	minimums: z.array(RowSchema).optional()
+});
+function runReportTool(proxy) {
+	return createTool({
+		id: "google_analytics_run_report",
+		description: "Run a GA4 report for a property",
+		inputSchema: runReportInputSchema,
+		outputSchema: runReportOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const propertyNumericId = input.property.replace(/^properties\//, "");
+			const response = await platformProxy.post({
+				endpoint: `/v1beta/properties/${encodeURIComponent(propertyNumericId)}:runReport`,
+				baseUrlOverride: "https://analyticsdata.googleapis.com",
+				data: {
+					...input.dimensions !== void 0 && { dimensions: input.dimensions },
+					...input.metrics !== void 0 && { metrics: input.metrics },
+					...input.dateRanges !== void 0 && { dateRanges: input.dateRanges },
+					...input.dimensionFilter !== void 0 && { dimensionFilter: input.dimensionFilter },
+					...input.metricFilter !== void 0 && { metricFilter: input.metricFilter },
+					...input.ordering !== void 0 && { orderBys: input.ordering },
+					...input.limit !== void 0 && { limit: input.limit }
+				},
+				retries: 3
+			});
+			const providerResponse = z.object({
+				dimensionHeaders: z.array(z.object({ name: z.string().optional() })).optional(),
+				metricHeaders: z.array(z.object({
+					name: z.string().optional(),
+					type: z.string().optional()
+				})).optional(),
+				rows: z.array(z.object({
+					dimensionValues: z.array(z.object({ value: z.string().optional() })).optional(),
+					metricValues: z.array(z.object({ value: z.string().optional() })).optional()
+				})).optional(),
+				rowCount: z.number().optional(),
+				totals: z.array(z.object({
+					dimensionValues: z.array(z.object({ value: z.string().optional() })).optional(),
+					metricValues: z.array(z.object({ value: z.string().optional() })).optional()
+				})).optional(),
+				maximums: z.array(z.object({
+					dimensionValues: z.array(z.object({ value: z.string().optional() })).optional(),
+					metricValues: z.array(z.object({ value: z.string().optional() })).optional()
+				})).optional(),
+				minimums: z.array(z.object({
+					dimensionValues: z.array(z.object({ value: z.string().optional() })).optional(),
+					metricValues: z.array(z.object({ value: z.string().optional() })).optional()
+				})).optional()
+			}).parse(response.data);
+			return {
+				dimensionHeaders: providerResponse.dimensionHeaders,
+				metricHeaders: providerResponse.metricHeaders,
+				rows: providerResponse.rows,
+				rowCount: providerResponse.rowCount,
+				totals: providerResponse.totals,
+				maximums: providerResponse.maximums,
+				minimums: providerResponse.minimums
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/update-data-stream.ts
+const updateDataStreamInputSchema = z.object({
+	propertyId: z.string().describe("GA4 property ID."),
+	dataStreamId: z.string().describe("Data stream ID to update."),
+	displayName: z.string().optional().describe("Human-readable display name for the Data Stream."),
+	webStreamData: z.object({ defaultUri: z.string().optional().describe("Domain name of the web app being measured.") }).optional().describe("Data specific to web streams."),
+	updateMask: z.string().optional().describe("The list of fields to be updated. If omitted, it will be computed from provided fields.")
+});
+const WebStreamDataSchema = z.object({
+	defaultUri: z.string().optional(),
+	measurementId: z.string().optional(),
+	firebaseAppId: z.string().optional()
+});
+const AndroidAppStreamDataSchema = z.object({
+	packageName: z.string().optional(),
+	firebaseAppId: z.string().optional()
+});
+const IosAppStreamDataSchema = z.object({
+	bundleId: z.string().optional(),
+	firebaseAppId: z.string().optional()
+});
+const DataStreamSchema = z.object({
+	name: z.string(),
+	type: z.string().optional(),
+	displayName: z.string().optional(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	webStreamData: WebStreamDataSchema.optional(),
+	androidAppStreamData: AndroidAppStreamDataSchema.optional(),
+	iosAppStreamData: IosAppStreamDataSchema.optional()
+});
+const updateDataStreamOutputSchema = DataStreamSchema;
+function updateDataStreamTool(proxy) {
+	return createTool({
+		id: "google_analytics_update_data_stream",
+		description: "Update a GA4 data stream.",
+		inputSchema: updateDataStreamInputSchema,
+		outputSchema: updateDataStreamOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const updateMaskParts = [];
+			if (input.displayName !== void 0) updateMaskParts.push("displayName");
+			if (input.webStreamData?.defaultUri !== void 0) updateMaskParts.push("webStreamData.defaultUri");
+			const updateMask = input.updateMask || updateMaskParts.join(",");
+			if (!updateMask) throw new platformProxy.ActionError({
+				type: "invalid_input",
+				message: "No fields to update. Provide at least one of displayName or webStreamData.defaultUri, or specify updateMask explicitly."
+			});
+			const requestBody = {};
+			if (input.displayName !== void 0) requestBody.displayName = input.displayName;
+			if (input.webStreamData?.defaultUri !== void 0) requestBody.webStreamData = { defaultUri: input.webStreamData.defaultUri };
+			const response = await platformProxy.patch({
+				endpoint: `/v1beta/properties/${encodeURIComponent(input.propertyId)}/dataStreams/${encodeURIComponent(input.dataStreamId)}`,
+				params: { updateMask },
+				data: requestBody,
+				retries: 3,
+				baseUrlOverride: "https://analyticsadmin.googleapis.com"
+			});
+			return DataStreamSchema.parse(response.data);
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools/update-property.ts
+const updatePropertyInputSchema = z.object({
+	name: z.string().describe("Property resource name. Example: \"properties/123456789\""),
+	displayName: z.string().optional().describe("Human-readable display name for the property."),
+	timeZone: z.string().optional().describe("The reporting time zone for the property. Example: \"America/Los_Angeles\"."),
+	currencyCode: z.string().optional().describe("The currency type used in reports. Example: \"USD\"."),
+	industryCategory: z.string().optional().describe("Industry category. Example: \"TECHNOLOGY\".")
+});
+const ProviderPropertySchema = z.object({
+	name: z.string(),
+	createTime: z.string().optional(),
+	updateTime: z.string().optional(),
+	parent: z.string().optional(),
+	displayName: z.string().optional(),
+	industryCategory: z.string().optional(),
+	timeZone: z.string().optional(),
+	currencyCode: z.string().optional(),
+	serviceLevel: z.string().optional(),
+	account: z.string().optional(),
+	propertyType: z.string().optional()
+});
+const updatePropertyOutputSchema = z.object({
+	name: z.string(),
+	displayName: z.string().optional(),
+	industryCategory: z.string().optional(),
+	timeZone: z.string().optional(),
+	currencyCode: z.string().optional(),
+	serviceLevel: z.string().optional(),
+	account: z.string().optional()
+});
+function updatePropertyTool(proxy) {
+	return createTool({
+		id: "google_analytics_update_property",
+		description: "Update a GA4 property.",
+		inputSchema: updatePropertyInputSchema,
+		outputSchema: updatePropertyOutputSchema,
+		execute: async (input, { requestContext }) => {
+			const platformProxy = proxy.withRequestContext(requestContext);
+			const propertyId = input.name.replace(/^properties\//, "");
+			if (!propertyId || propertyId.includes("/")) throw new platformProxy.ActionError({
+				type: "invalid_input",
+				message: "name must be a valid property resource name in the format \"properties/{propertyId}\"."
+			});
+			const updateMaskFields = [];
+			if (input.displayName !== void 0) updateMaskFields.push("displayName");
+			if (input.timeZone !== void 0) updateMaskFields.push("timeZone");
+			if (input.currencyCode !== void 0) updateMaskFields.push("currencyCode");
+			if (input.industryCategory !== void 0) updateMaskFields.push("industryCategory");
+			if (updateMaskFields.length === 0) throw new platformProxy.ActionError({
+				type: "invalid_input",
+				message: "At least one field to update must be provided."
+			});
+			const response = await platformProxy.patch({
+				endpoint: `/v1beta/properties/${encodeURIComponent(propertyId)}`,
+				params: { updateMask: updateMaskFields.join(",") },
+				data: {
+					...input.displayName !== void 0 && { displayName: input.displayName },
+					...input.timeZone !== void 0 && { timeZone: input.timeZone },
+					...input.currencyCode !== void 0 && { currencyCode: input.currencyCode },
+					...input.industryCategory !== void 0 && { industryCategory: input.industryCategory }
+				},
+				retries: 3,
+				baseUrlOverride: "https://analyticsadmin.googleapis.com"
+			});
+			const providerProperty = ProviderPropertySchema.parse(response.data);
+			return {
+				name: providerProperty.name,
+				...providerProperty.displayName !== void 0 && { displayName: providerProperty.displayName },
+				...providerProperty.industryCategory !== void 0 && { industryCategory: providerProperty.industryCategory },
+				...providerProperty.timeZone !== void 0 && { timeZone: providerProperty.timeZone },
+				...providerProperty.currencyCode !== void 0 && { currencyCode: providerProperty.currencyCode },
+				...providerProperty.serviceLevel !== void 0 && { serviceLevel: providerProperty.serviceLevel },
+				...providerProperty.account !== void 0 && { account: providerProperty.account }
+			};
+		}
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/tools.ts
+function createGoogleAnalyticsTools(options) {
+	const platformProxy = createPlatformProxy({
+		connectionId: options?.connectionId,
+		client: options?.client
+	});
+	return applyToolFilter({
+		google_analytics_archive_conversion_event: archiveConversionEventTool(platformProxy),
+		google_analytics_batch_run_reports: batchRunReportsTool(platformProxy),
+		google_analytics_create_conversion_event: createConversionEventTool(platformProxy),
+		google_analytics_create_data_stream: createDataStreamTool(platformProxy),
+		google_analytics_create_property: createPropertyTool$1(platformProxy),
+		google_analytics_get_metadata: getMetadataTool(platformProxy),
+		google_analytics_run_pivot_report: runPivotReportTool(platformProxy),
+		google_analytics_run_realtime_report: runRealtimeReportTool(platformProxy),
+		google_analytics_run_report: runReportTool(platformProxy),
+		google_analytics_update_data_stream: updateDataStreamTool(platformProxy),
+		google_analytics_update_property: updatePropertyTool(platformProxy)
+	}, {
+		allowTools: options?.allowTools,
+		disallowTools: options?.disallowTools
+	});
+}
+//#endregion
+//#region src/providers/google-analytics/index.ts
+const googleAnalyticsProvider = {
+	integrationId: "google-analytics",
+	envVar: "MASTRA_GOOGLE_ANALYTICS_CONNECTION_ID",
+	createTools: createGoogleAnalyticsTools
+};
+//#endregion
 //#region src/providers/google-calendar/tools/add-attendee.ts
 const addAttendeeInputSchema = z.object({
 	calendarId: z.string().describe("Calendar identifier. Use \"primary\" for the primary calendar. Example: \"primary\""),
@@ -73286,6 +74097,7 @@ const TOOLS = [
 	discordProvider,
 	firefliesProvider,
 	githubProvider,
+	googleAnalyticsProvider,
 	googleCalendarProvider,
 	googleDocsProvider,
 	googleDriveProvider,