@contractspec/lib.contracts-integrations 2.0.0

package/dist/integrations/meeting-recorder/contracts/transcripts.d.ts

@@ -0,0 +1,166 @@
+import { SchemaModel } from '@contractspec/lib.schema';
+import { type AnyOperationSpec } from '@contractspec/lib.contracts-spec/operations';
+import type { OperationSpecRegistry } from '@contractspec/lib.contracts-spec/operations/registry';
+export declare const MeetingRecorderGetTranscript: import("@contractspec/lib.contracts-spec").OperationSpec<SchemaModel<{
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    meetingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    includeSegments: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+    format: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+}>, SchemaModel<{
+    id: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    meetingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    externalId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    format: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    text: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    segments: {
+        type: SchemaModel<{
+            index: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            speakerId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            speakerName: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            speakerEmail: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            text: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: false;
+            };
+            startTimeMs: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            endTimeMs: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            startTime: {
+                type: import("@contractspec/lib.schema").FieldType<Date, string>;
+                isOptional: true;
+            };
+            endTime: {
+                type: import("@contractspec/lib.schema").FieldType<Date, string>;
+                isOptional: true;
+            };
+            confidence: {
+                type: import("@contractspec/lib.schema").FieldType<number, number>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isArray: true;
+        isOptional: true;
+    };
+    language: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    sourceUrl: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    generatedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+    metadata: {
+        type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+    raw: {
+        type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+        isOptional: true;
+    };
+}>, undefined>;
+export declare const MeetingRecorderSyncTranscript: import("@contractspec/lib.contracts-spec").OperationSpec<SchemaModel<{
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    meetingId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    forceRefresh: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+    triggerWebhooks: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: true;
+    };
+}>, SchemaModel<{
+    synced: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: false;
+    };
+    failed: {
+        type: import("@contractspec/lib.schema").FieldType<number, number>;
+        isOptional: false;
+    };
+    errors: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isArray: true;
+        isOptional: true;
+    };
+    nextSyncSuggestedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+}>, undefined>;
+export declare const meetingRecorderTranscriptContracts: Record<string, AnyOperationSpec>;
+export declare function registerMeetingRecorderTranscriptContracts(registry: OperationSpecRegistry): OperationSpecRegistry;

package/dist/integrations/meeting-recorder/contracts/transcripts.js

@@ -0,0 +1,287 @@
+// @bun
+// src/integrations/meeting-recorder/models.ts
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+var MeetingParticipantRecord = new SchemaModel({
+  name: "MeetingParticipantRecord",
+  description: "Canonical participant entry for meetings and transcripts from recorder providers.",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    externalId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    email: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    role: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    isExternal: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingTranscriptSegmentRecord = new SchemaModel({
+  name: "MeetingTranscriptSegmentRecord",
+  description: "A single transcript segment with speaker attribution.",
+  fields: {
+    index: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    speakerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    speakerName: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    speakerEmail: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    text: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    startTimeMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    endTimeMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    startTime: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    endTime: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    confidence: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingRecord = new SchemaModel({
+  name: "MeetingRecord",
+  description: "Canonical meeting metadata synced from meeting recorder providers.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    summary: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    organizer: { type: MeetingParticipantRecord, isOptional: true },
+    invitees: {
+      type: MeetingParticipantRecord,
+      isArray: true,
+      isOptional: true
+    },
+    participants: {
+      type: MeetingParticipantRecord,
+      isArray: true,
+      isOptional: true
+    },
+    scheduledStartAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    scheduledEndAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    recordingStartAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    recordingEndAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    durationSeconds: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    meetingUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    recordingUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    shareUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    sourcePlatform: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    language: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    transcriptAvailable: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var MeetingTranscriptRecord = new SchemaModel({
+  name: "MeetingTranscriptRecord",
+  description: "Canonical transcript payload for a recorded meeting.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    format: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    text: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    segments: {
+      type: MeetingTranscriptSegmentRecord,
+      isArray: true,
+      isOptional: true
+    },
+    language: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    sourceUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    generatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    raw: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
+});
+var MeetingRecorderWebhookEventRecord = new SchemaModel({
+  name: "MeetingRecorderWebhookEventRecord",
+  description: "Normalized webhook event from a meeting recorder provider.",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    providerKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    eventType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    meetingId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    transcriptId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    recordingId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    receivedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    verified: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    payload: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+
+// src/integrations/meeting-recorder/telemetry.ts
+var MEETING_RECORDER_PII_FIELDS = [
+  "email",
+  "organizerEmail",
+  "participantEmail",
+  "participants",
+  "invitees",
+  "attendees",
+  "speakerName",
+  "speakerEmail",
+  "name",
+  "phone",
+  "phoneNumber",
+  "displayName"
+];
+var MEETING_RECORDER_TELEMETRY_EVENTS = {
+  meetingsSynced: "meeting-recorder.meetings.synced",
+  meetingsSyncFailed: "meeting-recorder.meetings.sync_failed",
+  transcriptsFetched: "meeting-recorder.transcripts.fetched",
+  transcriptsFetchFailed: "meeting-recorder.transcripts.fetch_failed",
+  transcriptsSynced: "meeting-recorder.transcripts.synced",
+  transcriptsSyncFailed: "meeting-recorder.transcripts.sync_failed",
+  webhookReceived: "meeting-recorder.webhooks.received",
+  webhookRejected: "meeting-recorder.webhooks.rejected"
+};
+function redactMeetingRecorderTelemetryPayload(payload) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (MEETING_RECORDER_PII_FIELDS.includes(key)) {
+      redacted[key] = maskValue(value);
+    } else if (Array.isArray(value)) {
+      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactMeetingRecorderTelemetryPayload(item) : item);
+    } else if (typeof value === "object" && value !== null) {
+      redacted[key] = redactMeetingRecorderTelemetryPayload(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function maskValue(value) {
+  if (value == null)
+    return "";
+  const str = String(value);
+  if (str.length <= 4)
+    return "*".repeat(str.length);
+  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
+}
+
+// src/integrations/meeting-recorder/contracts/transcripts.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+var MeetingRecorderGetTranscriptInput = new SchemaModel2({
+  name: "MeetingRecorderGetTranscriptInput",
+  description: "Parameters for fetching a meeting transcript.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    includeSegments: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    format: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+  }
+});
+var MeetingRecorderSyncTranscriptInput = new SchemaModel2({
+  name: "MeetingRecorderSyncTranscriptInput",
+  description: "Command payload to synchronise meeting transcripts.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    meetingId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    triggerWebhooks: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var MeetingRecorderSyncTranscriptOutput = new SchemaModel2({
+  name: "MeetingRecorderSyncTranscriptOutput",
+  description: "Result of a transcript synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    errors: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    nextSyncSuggestedAt: {
+      type: ScalarTypeEnum2.DateTime(),
+      isOptional: true
+    }
+  }
+});
+var MeetingRecorderGetTranscript = defineQuery({
+  meta: {
+    key: "meeting-recorder.transcripts.get",
+    version: "1.0.0",
+    description: "Fetch the transcript for a specific meeting recording.",
+    goal: "Expose meeting transcripts for downstream knowledge and analytics flows.",
+    context: "Used by agents and dashboards to access the transcript for a selected meeting.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderGetTranscriptInput,
+    output: MeetingTranscriptRecord
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var MeetingRecorderSyncTranscript = defineCommand({
+  meta: {
+    key: "meeting-recorder.transcripts.sync",
+    version: "1.0.0",
+    description: "Trigger a transcript sync from the meeting recorder provider.",
+    goal: "Keep canonical transcripts aligned with external meeting providers.",
+    context: "Invoked by scheduled jobs or webhooks when new transcripts are ready.",
+    owners: ["@platform.integrations"],
+    tags: ["meeting-recorder", "transcripts", "sync"],
+    stability: "experimental"
+  },
+  io: {
+    input: MeetingRecorderSyncTranscriptInput,
+    output: MeetingRecorderSyncTranscriptOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSynced },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          meetingId: payload?.meetingId,
+          synced: result?.synced,
+          failed: result?.failed
+        };
+      }
+    },
+    failure: {
+      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSyncFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          meetingId: payload?.meetingId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var meetingRecorderTranscriptContracts = {
+  MeetingRecorderGetTranscript,
+  MeetingRecorderSyncTranscript
+};
+function registerMeetingRecorderTranscriptContracts(registry) {
+  return registry.register(MeetingRecorderGetTranscript).register(MeetingRecorderSyncTranscript);
+}
+export {
+  registerMeetingRecorderTranscriptContracts,
+  meetingRecorderTranscriptContracts,
+  MeetingRecorderSyncTranscript,
+  MeetingRecorderGetTranscript
+};

package/dist/integrations/meeting-recorder/contracts/webhooks.d.ts

@@ -0,0 +1,85 @@
+import { SchemaModel } from '@contractspec/lib.schema';
+import { type AnyOperationSpec } from '@contractspec/lib.contracts-spec/operations';
+import type { OperationSpecRegistry } from '@contractspec/lib.contracts-spec/operations/registry';
+export declare const MeetingRecorderWebhookIngest: import("@contractspec/lib.contracts-spec").OperationSpec<SchemaModel<{
+    tenantId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    providerKey: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: false;
+    };
+    connectionId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    webhookId: {
+        type: import("@contractspec/lib.schema").FieldType<string, string>;
+        isOptional: true;
+    };
+    headers: {
+        type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+        isOptional: true;
+    };
+    payload: {
+        type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+        isOptional: false;
+    };
+    receivedAt: {
+        type: import("@contractspec/lib.schema").FieldType<Date, string>;
+        isOptional: true;
+    };
+}>, SchemaModel<{
+    accepted: {
+        type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+        isOptional: false;
+    };
+    event: {
+        type: SchemaModel<{
+            id: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            providerKey: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            eventType: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            meetingId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            transcriptId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            recordingId: {
+                type: import("@contractspec/lib.schema").FieldType<string, string>;
+                isOptional: true;
+            };
+            receivedAt: {
+                type: import("@contractspec/lib.schema").FieldType<Date, string>;
+                isOptional: true;
+            };
+            verified: {
+                type: import("@contractspec/lib.schema").FieldType<boolean, boolean>;
+                isOptional: true;
+            };
+            payload: {
+                type: import("@contractspec/lib.schema").FieldType<unknown, unknown>;
+                isOptional: true;
+            };
+            metadata: {
+                type: import("@contractspec/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+                isOptional: true;
+            };
+        }>;
+        isOptional: true;
+    };
+}>, undefined>;
+export declare const meetingRecorderWebhookContracts: Record<string, AnyOperationSpec>;
+export declare function registerMeetingRecorderWebhookContracts(registry: OperationSpecRegistry): OperationSpecRegistry;