@keystrokehq/segment 0.0.1

package/dist/triggers.mjs

@@ -0,0 +1,341 @@
+import { t as segment } from "./integration-B5zYasBZ.mjs";
+import { createSegmentClient } from "./client.mjs";
+import { segmentAudienceEventSchema, segmentAudienceSyncEventSchema, segmentAudienceWebhookEnvelopeSchema, segmentComputedTraitEventSchema, segmentDeletionRegulationEventSchema, segmentDestinationCreatedEventSchema, segmentFunctionVersionEventSchema, segmentMonitoringAlertEnvelopeSchema, segmentMonitoringEventSchema, segmentReverseEtlRunEventSchema, segmentSourceCreatedEventSchema, segmentTrackingPlanViolationEventSchema } from "./events.mjs";
+import { verifySegmentWebhookFromRequest } from "./verification.mjs";
+import { createPollingTriggerBindingFactory, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+function isAudienceEntered(envelope) {
+	const type = typeof envelope.type === "string" ? envelope.type.toLowerCase() : "";
+	const properties = envelope.properties;
+	const propsType = typeof properties?.type === "string" ? properties.type.toLowerCase() : "";
+	if (!audienceKeyFromEnvelope(envelope)) return false;
+	return type === "entered" || propsType === "entered" || audienceValueFromEnvelope(envelope) === true;
+}
+function isAudienceExited(envelope) {
+	const type = typeof envelope.type === "string" ? envelope.type.toLowerCase() : "";
+	const properties = envelope.properties;
+	const propsType = typeof properties?.type === "string" ? properties.type.toLowerCase() : "";
+	if (!audienceKeyFromEnvelope(envelope)) return false;
+	return type === "exited" || propsType === "exited" || audienceValueFromEnvelope(envelope) === false;
+}
+function audienceKeyFromEnvelope(envelope) {
+	const props = envelope.properties;
+	if (props && typeof props.audience_key === "string") return props.audience_key;
+	if (props && typeof props.audienceKey === "string") return props.audienceKey;
+	if (typeof envelope.event === "string" && envelope.event.length > 0) return envelope.event;
+}
+function audienceValueFromEnvelope(envelope) {
+	const props = envelope.properties;
+	if (!props) return void 0;
+	const key = audienceKeyFromEnvelope(envelope);
+	if (!key) return void 0;
+	const value = props[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function mapAudienceEvent(envelope, type) {
+	const audienceKey = audienceKeyFromEnvelope(envelope);
+	if (!audienceKey) return null;
+	return segmentAudienceEventSchema.parse({
+		type,
+		audienceKey,
+		...envelope.userId !== void 0 ? { userId: envelope.userId } : {},
+		...envelope.anonymousId !== void 0 ? { anonymousId: envelope.anonymousId } : {},
+		...envelope.userId !== void 0 ? { profileId: envelope.userId } : {},
+		...envelope.traits !== void 0 ? { traits: envelope.traits } : {},
+		...envelope.properties !== void 0 ? { properties: envelope.properties } : {},
+		...envelope.messageId !== void 0 ? { messageId: envelope.messageId } : {},
+		...envelope.timestamp !== void 0 ? { timestamp: envelope.timestamp } : {},
+		raw: envelope
+	});
+}
+function mapComputedTraitEvent(envelope) {
+	const key = audienceKeyFromEnvelope(envelope);
+	if (!key) return null;
+	const props = envelope.properties;
+	const value = props ? props[key] : void 0;
+	return segmentComputedTraitEventSchema.parse({
+		traitKey: key,
+		value,
+		...envelope.userId !== void 0 ? { userId: envelope.userId } : {},
+		...envelope.userId !== void 0 ? { profileId: envelope.userId } : {},
+		...envelope.messageId !== void 0 ? { messageId: envelope.messageId } : {},
+		...envelope.timestamp !== void 0 ? { timestamp: envelope.timestamp } : {},
+		raw: envelope
+	});
+}
+function mapMonitoringEvent(envelope) {
+	if (!envelope.id) return null;
+	return segmentMonitoringEventSchema.parse({
+		alertId: envelope.id,
+		eventType: envelope.eventType ?? "unknown",
+		...envelope.severity !== void 0 ? { severity: envelope.severity } : {},
+		...envelope.firedAt !== void 0 ? { firedAt: envelope.firedAt } : {},
+		...envelope.sourceId !== void 0 ? { sourceId: envelope.sourceId } : {},
+		...envelope.destinationId !== void 0 ? { destinationId: envelope.destinationId } : {},
+		...envelope.functionId !== void 0 ? { functionId: envelope.functionId } : {},
+		...envelope.message !== void 0 ? { message: envelope.message } : {},
+		raw: envelope
+	});
+}
+function verifyAudienceRequest(request, credentials) {
+	const secret = credentials.SEGMENT_WEBHOOK_SHARED_SECRET;
+	if (!secret) throw new Error("Segment webhook triggers require SEGMENT_WEBHOOK_SHARED_SECRET. Set it on the connection and configure the same shared secret on the Segment-side Webhook destination.");
+	if (!verifySegmentWebhookFromRequest(request, secret)) throw new Error("Invalid Segment webhook signature.");
+}
+function buildWebhookBinding(config) {
+	return createWebhookTriggerBindingFactory({
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		path: "/segment",
+		method: "POST",
+		payload: config.envelope,
+		credentialSets: [segment],
+		verify: (request, ctx) => {
+			const credentials = ctx.credentials.segment;
+			verifyAudienceRequest(request, credentials);
+		},
+		definitionFilter: config.filter,
+		mapPayload: config.mapPayload,
+		idempotencyKey: config.idempotencyKey,
+		response: { successStatus: 200 }
+	});
+}
+const audienceEnteredBinding = buildWebhookBinding({
+	defaultName: "Segment audience entered",
+	defaultDescription: "A profile entered a Segment Engage audience.",
+	envelope: segmentAudienceWebhookEnvelopeSchema,
+	filter: isAudienceEntered,
+	mapPayload: (envelope) => mapAudienceEvent(envelope, "entered"),
+	idempotencyKey: (env, payload) => payload?.messageId ?? `${payload?.audienceKey ?? env.event ?? "unknown"}:${payload?.userId ?? payload?.profileId ?? env.userId ?? "anon"}:${payload?.timestamp ?? env.timestamp ?? ""}:entered`
+});
+const audienceExitedBinding = buildWebhookBinding({
+	defaultName: "Segment audience exited",
+	defaultDescription: "A profile exited a Segment Engage audience.",
+	envelope: segmentAudienceWebhookEnvelopeSchema,
+	filter: isAudienceExited,
+	mapPayload: (envelope) => mapAudienceEvent(envelope, "exited"),
+	idempotencyKey: (env, payload) => payload?.messageId ?? `${payload?.audienceKey ?? env.event ?? "unknown"}:${payload?.userId ?? payload?.profileId ?? env.userId ?? "anon"}:${payload?.timestamp ?? env.timestamp ?? ""}:exited`
+});
+const computedTraitsUpdatedBinding = buildWebhookBinding({
+	defaultName: "Segment computed trait updated",
+	defaultDescription: "A profile computed trait value changed.",
+	envelope: segmentAudienceWebhookEnvelopeSchema,
+	filter: (envelope) => Boolean(audienceKeyFromEnvelope(envelope)),
+	mapPayload: mapComputedTraitEvent,
+	idempotencyKey: (env, payload) => payload?.messageId ?? `${payload?.traitKey ?? env.event ?? "unknown"}:${payload?.userId ?? payload?.profileId ?? env.userId ?? "anon"}:${payload?.timestamp ?? env.timestamp ?? ""}`
+});
+const functionsInvocationFailedBinding = buildWebhookBinding({
+	defaultName: "Segment function invocation failed",
+	defaultDescription: "A Segment Function invocation failure alert fired.",
+	envelope: segmentMonitoringAlertEnvelopeSchema,
+	filter: (envelope) => typeof envelope.eventType === "string" && envelope.eventType.toLowerCase().includes("function"),
+	mapPayload: mapMonitoringEvent,
+	idempotencyKey: (env, payload) => `${payload?.alertId ?? env.id ?? "unknown"}:${payload?.firedAt ?? env.firedAt ?? ""}`
+});
+const deliveryFailureSpikeBinding = buildWebhookBinding({
+	defaultName: "Segment delivery failure spike",
+	defaultDescription: "A destination delivery failure rate exceeded threshold.",
+	envelope: segmentMonitoringAlertEnvelopeSchema,
+	filter: (envelope) => typeof envelope.eventType === "string" && envelope.eventType.toLowerCase().includes("delivery"),
+	mapPayload: mapMonitoringEvent,
+	idempotencyKey: (env, payload) => `${payload?.alertId ?? env.id ?? "unknown"}:${payload?.firedAt ?? env.firedAt ?? ""}`
+});
+const webhooks = Object.freeze({
+	audienceEntered: (options) => audienceEnteredBinding(options),
+	audienceExited: (options) => audienceExitedBinding(options),
+	computedTraitsUpdated: (options) => computedTraitsUpdatedBinding(options),
+	functionsInvocationFailed: (options) => functionsInvocationFailedBinding(options),
+	deliveryFailureSpike: (options) => deliveryFailureSpikeBinding(options)
+});
+function buildPollingBinding(definition, options) {
+	const schedule = options?.schedule ?? definition.defaultSchedule;
+	return createPollingTriggerBindingFactory({
+		defaultName: definition.defaultName,
+		defaultDescription: definition.defaultDescription,
+		schedule,
+		credentialSets: [segment],
+		response: definition.eventSchema,
+		poll: async (ctx) => {
+			const credentials = ctx.credentials.segment;
+			return definition.poll(credentials, ctx.lastPolledAt);
+		},
+		idempotencyKey: (event) => definition.idempotencyKey(event)
+	})({
+		...options?.name ? { name: options.name } : {},
+		...options?.description ? { description: options.description } : {},
+		...options?.filter ? { filter: options.filter } : {},
+		...options?.transform ? { transform: options.transform } : {}
+	});
+}
+function audienceSyncCompleted(params, options) {
+	return buildPollingBinding({
+		defaultName: "Segment audience sync completed",
+		defaultDescription: `Poll /spaces/${params.spaceId}/audiences/${params.audienceId}/syncs and emit the most recent completed sync.`,
+		defaultSchedule: "5m",
+		eventSchema: segmentAudienceSyncEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request(`/spaces/${encodeURIComponent(params.spaceId)}/audiences/${encodeURIComponent(params.audienceId)}/syncs`);
+			const obj = (rec.data?.syncs ?? rec.syncs ?? [])[0] ?? {};
+			return segmentAudienceSyncEventSchema.parse({
+				syncId: obj.id ?? "unknown",
+				audienceId: params.audienceId,
+				spaceId: params.spaceId,
+				status: obj.status ?? "success",
+				...typeof obj.finishedAt === "string" ? { finishedAt: obj.finishedAt } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => `${event.audienceId}:${event.syncId}:${event.finishedAt ?? ""}`
+	}, options);
+}
+function reverseEtlRunPollDefinition(params, status, label) {
+	return {
+		defaultName: `Segment reverse-ETL run ${label}`,
+		defaultDescription: `Poll /reverse-etl-models/${params.modelId}/runs and emit the latest run that is ${status}.`,
+		defaultSchedule: "5m",
+		eventSchema: segmentReverseEtlRunEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request(`/reverse-etl-models/${encodeURIComponent(params.modelId)}/runs`);
+			const obj = (rec.data?.runs ?? rec.runs ?? []).find((run) => {
+				if (!run || typeof run !== "object") return false;
+				return run.status === status;
+			}) ?? {};
+			return segmentReverseEtlRunEventSchema.parse({
+				runId: obj.id ?? "unknown",
+				modelId: params.modelId,
+				status,
+				...typeof obj.startedAt === "string" ? { startedAt: obj.startedAt } : {},
+				...typeof obj.finishedAt === "string" ? { finishedAt: obj.finishedAt } : {},
+				...typeof obj.error === "string" ? { error: obj.error } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => `${event.modelId}:${event.runId}:${status}:${event.finishedAt ?? event.startedAt ?? ""}`
+	};
+}
+function reverseEtlRunSucceeded(params, options) {
+	return buildPollingBinding(reverseEtlRunPollDefinition(params, "SUCCEEDED", "succeeded"), options);
+}
+function reverseEtlRunFailed(params, options) {
+	return buildPollingBinding(reverseEtlRunPollDefinition(params, "FAILED", "failed"), options);
+}
+function reverseEtlRunStarted(params, options) {
+	return buildPollingBinding(reverseEtlRunPollDefinition(params, "IN_PROGRESS", "started"), options);
+}
+function functionsDeploymentCompleted(params, options) {
+	return buildPollingBinding({
+		defaultName: "Segment function deployment completed",
+		defaultDescription: `Poll /functions/${params.functionId}/versions and emit the latest version.`,
+		defaultSchedule: "5m",
+		eventSchema: segmentFunctionVersionEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request(`/functions/${encodeURIComponent(params.functionId)}/versions`);
+			const obj = (rec.data?.versions ?? rec.versions ?? [])[0] ?? {};
+			return segmentFunctionVersionEventSchema.parse({
+				functionId: params.functionId,
+				versionId: obj.id ?? "unknown",
+				...typeof obj.createdAt === "string" ? { createdAt: obj.createdAt } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => `${event.functionId}:${event.versionId}`
+	}, options);
+}
+function trackingPlanViolationDetected(options) {
+	return buildPollingBinding({
+		defaultName: "Segment tracking plan violation detected",
+		defaultDescription: "Poll /events/violations and emit the most recent violation.",
+		defaultSchedule: "10m",
+		eventSchema: segmentTrackingPlanViolationEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request("/events/violations");
+			const obj = (rec.data?.violations ?? rec.violations ?? [])[0] ?? {};
+			return segmentTrackingPlanViolationEventSchema.parse({
+				violationId: obj.id ?? "unknown",
+				...typeof obj.eventName === "string" ? { eventName: obj.eventName } : {},
+				...typeof obj.trackingPlanId === "string" ? { trackingPlanId: obj.trackingPlanId } : {},
+				...typeof obj.sourceId === "string" ? { sourceId: obj.sourceId } : {},
+				...typeof obj.messageId === "string" ? { messageId: obj.messageId } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => event.violationId
+	}, options);
+}
+function sourceCreated(options) {
+	return buildPollingBinding({
+		defaultName: "Segment source created",
+		defaultDescription: "Poll /sources and emit the most recent source.",
+		defaultSchedule: "10m",
+		eventSchema: segmentSourceCreatedEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request("/sources");
+			const obj = (rec.data?.sources ?? rec.sources ?? [])[0] ?? {};
+			return segmentSourceCreatedEventSchema.parse({
+				sourceId: obj.id ?? "unknown",
+				...typeof obj.name === "string" ? { name: obj.name } : {},
+				...typeof obj.createdAt === "string" ? { createdAt: obj.createdAt } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => event.sourceId
+	}, options);
+}
+function destinationCreated(options) {
+	return buildPollingBinding({
+		defaultName: "Segment destination created",
+		defaultDescription: "Poll /destinations and emit the most recent destination.",
+		defaultSchedule: "10m",
+		eventSchema: segmentDestinationCreatedEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request("/destinations");
+			const obj = (rec.data?.destinations ?? rec.destinations ?? [])[0] ?? {};
+			return segmentDestinationCreatedEventSchema.parse({
+				destinationId: obj.id ?? "unknown",
+				...typeof obj.name === "string" ? { name: obj.name } : {},
+				...typeof obj.sourceId === "string" ? { sourceId: obj.sourceId } : {},
+				...typeof obj.createdAt === "string" ? { createdAt: obj.createdAt } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => event.destinationId
+	}, options);
+}
+function deletionRegulationCompleted(options) {
+	return buildPollingBinding({
+		defaultName: "Segment deletion regulation completed",
+		defaultDescription: "Poll /workspace/regulations for finished GDPR regulations.",
+		defaultSchedule: "15m",
+		eventSchema: segmentDeletionRegulationEventSchema,
+		poll: async (credentials) => {
+			const rec = await createSegmentClient(credentials).publicApi.request("/workspace/regulations");
+			const obj = (rec.data?.regulations ?? rec.regulations ?? []).find((r) => {
+				if (!r || typeof r !== "object") return false;
+				const record = r;
+				return typeof record.finishedAt === "string" && record.finishedAt.length > 0;
+			}) ?? {};
+			return segmentDeletionRegulationEventSchema.parse({
+				regulationId: obj.id ?? "unknown",
+				...typeof obj.regulationType === "string" ? { regulationType: obj.regulationType } : {},
+				...typeof obj.finishedAt === "string" ? { finishedAt: obj.finishedAt } : {},
+				raw: obj
+			});
+		},
+		idempotencyKey: (event) => event.regulationId
+	}, options);
+}
+const polling = Object.freeze({
+	audienceSyncCompleted,
+	reverseEtlRunSucceeded,
+	reverseEtlRunFailed,
+	reverseEtlRunStarted,
+	functionsDeploymentCompleted,
+	trackingPlanViolationDetected,
+	sourceCreated,
+	destinationCreated,
+	deletionRegulationCompleted
+});
+
+//#endregion
+export { audienceSyncCompleted, deletionRegulationCompleted, destinationCreated, functionsDeploymentCompleted, polling, reverseEtlRunFailed, reverseEtlRunStarted, reverseEtlRunSucceeded, sourceCreated, trackingPlanViolationDetected, webhooks };

package/dist/usage.d.mts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+
+//#region src/usage.d.ts
+declare const getDailyPerSourceUsage: _keystrokehq_core0.Operation<z.ZodObject<{
+  startDate: z.ZodOptional<z.ZodString>;
+  endDate: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    date: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    callCount: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getMonthlyWorkspaceUsage: _keystrokehq_core0.Operation<z.ZodObject<{
+  month: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  month: z.ZodOptional<z.ZodString>;
+  mtu: z.ZodOptional<z.ZodNumber>;
+  events: z.ZodOptional<z.ZodNumber>;
+  breakdowns: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getDailyPerSourceUsage, getMonthlyWorkspaceUsage };

package/dist/usage.mjs

@@ -0,0 +1,55 @@
+import { createSegmentClient } from "./client.mjs";
+import { a as segmentLooseObjectSchema } from "./common-CdGiJbjq.mjs";
+import { t as segmentOperation } from "./factory-CvfKfzMq.mjs";
+import { z } from "zod";
+
+//#region src/usage.ts
+/**
+* segment/usage.ts — API call usage per source + monthly workspace usage.
+* 2 actions (PLAN § 6.22).
+*/
+const dailyEntrySchema = segmentLooseObjectSchema({
+	date: z.string().optional(),
+	sourceId: z.string().optional(),
+	callCount: z.number().optional()
+});
+const monthlyWorkspaceSchema = segmentLooseObjectSchema({
+	month: z.string().optional(),
+	mtu: z.number().optional(),
+	events: z.number().optional(),
+	breakdowns: z.array(z.record(z.string(), z.unknown())).optional()
+});
+const getDailyPerSourceUsage = segmentOperation({
+	id: "segment.usage.getDailyPerSource",
+	name: "Get daily per-source usage",
+	description: "Daily API call counts per source.",
+	input: z.object({
+		startDate: z.string().optional(),
+		endDate: z.string().optional(),
+		sourceId: z.string().optional()
+	}),
+	output: z.object({ items: z.array(dailyEntrySchema) }),
+	run: async (input, credentials) => {
+		const rec = await createSegmentClient(credentials).publicApi.request("/usage/sources/daily-api-calls", { query: {
+			startDate: input.startDate,
+			endDate: input.endDate,
+			sourceId: input.sourceId
+		} });
+		return { items: (rec.data?.usage ?? rec.usage ?? []).map((entry) => dailyEntrySchema.parse(entry)) };
+	}
+});
+const getMonthlyWorkspaceUsage = segmentOperation({
+	id: "segment.usage.getMonthlyWorkspace",
+	name: "Get monthly workspace usage",
+	description: "Monthly MTU and event totals for the workspace.",
+	input: z.object({ month: z.string().optional() }),
+	output: monthlyWorkspaceSchema,
+	run: async (input, credentials) => {
+		const body = await createSegmentClient(credentials).publicApi.request("/usage/workspace/monthly", { query: { month: input.month } });
+		const rec = body;
+		return monthlyWorkspaceSchema.parse(rec.data ?? body);
+	}
+});
+
+//#endregion
+export { getDailyPerSourceUsage, getMonthlyWorkspaceUsage };

package/dist/verification.d.mts

@@ -0,0 +1,17 @@
+import { WebhookRequest } from "@keystrokehq/core";
+
+//#region src/verification.d.ts
+/** Default header name Segment uses for its webhook signature. */
+declare const SEGMENT_SIGNATURE_HEADER = "x-signature";
+/** Hex-encoded HMAC-SHA1 of `rawBody` using `secret`. */
+declare function buildSegmentWebhookSignature(rawBody: string, secret: string): string;
+interface VerifySegmentWebhookOptions {
+  readonly rawBody: string;
+  readonly signatureHeader: string | undefined;
+  readonly secret: string;
+}
+declare function verifySegmentWebhookRequest(options: VerifySegmentWebhookOptions): boolean;
+/** Convenience wrapper for the `WebhookRequest` shape the runtime passes. */
+declare function verifySegmentWebhookFromRequest(request: Pick<WebhookRequest, 'headers' | 'rawBody'>, secret: string, signatureHeader?: string): boolean;
+//#endregion
+export { SEGMENT_SIGNATURE_HEADER, VerifySegmentWebhookOptions, buildSegmentWebhookSignature, verifySegmentWebhookFromRequest, verifySegmentWebhookRequest };

package/dist/verification.mjs

@@ -0,0 +1,51 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+//#region src/verification.ts
+/**
+* segment/verification.ts
+*
+* HMAC signature verification for Segment Audience webhook destinations,
+* Engage computed-trait webhook destinations, Functions webhooks, and
+* Monitoring alert webhooks.
+*
+* Segment signs webhook bodies with HMAC-SHA1 by default when a shared
+* secret is configured on the Webhook destination / subscription. The
+* signature is sent as a hex string in the `X-Signature` header.
+*
+* Reference:
+*   https://segment.com/docs/connections/destinations/catalog/webhooks/#authentication
+*   https://segment.com/docs/connections/functions/destination-functions/#shared-secret
+*
+* We expose helpers for:
+*   - `verifySegmentWebhookRequest({ rawBody, signatureHeader, secret })`
+*     — constant-time compare against `sha1(secret, rawBody)` in hex.
+*   - `buildSegmentWebhookSignature(rawBody, secret)` — produce the expected
+*     hex signature (useful for tests).
+*/
+/** Default header name Segment uses for its webhook signature. */
+const SEGMENT_SIGNATURE_HEADER = "x-signature";
+/** Hex-encoded HMAC-SHA1 of `rawBody` using `secret`. */
+function buildSegmentWebhookSignature(rawBody, secret) {
+	return createHmac("sha1", secret).update(rawBody, "utf8").digest("hex");
+}
+function verifySegmentWebhookRequest(options) {
+	if (!options.signatureHeader || !options.secret) return false;
+	const expected = buildSegmentWebhookSignature(options.rawBody, options.secret);
+	const provided = options.signatureHeader.trim().toLowerCase();
+	const expectedBuf = Buffer.from(expected, "utf8");
+	const providedBuf = Buffer.from(provided, "utf8");
+	if (expectedBuf.length !== providedBuf.length) return false;
+	return timingSafeEqual(expectedBuf, providedBuf);
+}
+/** Convenience wrapper for the `WebhookRequest` shape the runtime passes. */
+function verifySegmentWebhookFromRequest(request, secret, signatureHeader = SEGMENT_SIGNATURE_HEADER) {
+	const header = request.headers[signatureHeader] ?? request.headers[signatureHeader.toLowerCase()];
+	return verifySegmentWebhookRequest({
+		rawBody: request.rawBody,
+		signatureHeader: header,
+		secret
+	});
+}
+
+//#endregion
+export { SEGMENT_SIGNATURE_HEADER, buildSegmentWebhookSignature, verifySegmentWebhookFromRequest, verifySegmentWebhookRequest };