@contractspec/integration.providers-impls 1.57.0 → 1.58.0

package/dist/node/impls/granola-meeting-recorder.js

@@ -0,0 +1,512 @@
+// src/impls/granola-meeting-recorder.mcp.ts
+var UNKNOWN_EMAIL = "unknown@granola.local";
+var EPOCH = "1970-01-01T00:00:00.000Z";
+
+class GranolaMcpClient {
+  requestId = 0;
+  mcpUrl;
+  mcpAccessToken;
+  mcpHeaders;
+  fetchFn;
+  constructor(options) {
+    this.mcpUrl = options.mcpUrl;
+    this.mcpAccessToken = options.mcpAccessToken;
+    this.mcpHeaders = options.mcpHeaders;
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async callTool(name, args) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.mcpHeaders ?? {}
+    };
+    if (this.mcpAccessToken) {
+      headers.Authorization = `Bearer ${this.mcpAccessToken}`;
+    }
+    const response = await this.fetchFn(this.mcpUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++this.requestId,
+        method: "tools/call",
+        params: {
+          name,
+          arguments: args
+        }
+      })
+    });
+    if (!response.ok) {
+      const message = await safeReadText(response);
+      throw new Error(`Granola MCP error (${response.status}): ${message}`);
+    }
+    const rpc = await response.json();
+    if (rpc.error) {
+      throw new Error(rpc.error.message ?? "Granola MCP returned an error.");
+    }
+    return extractRpcResult(rpc);
+  }
+}
+function normalizeMcpListResult(payload) {
+  const root = asObject(payload);
+  const list = asArray(payload) ?? asArray(root?.notes) ?? asArray(root?.meetings) ?? asArray(root?.items) ?? asArray(root?.results) ?? asArray(root?.data) ?? [];
+  const notes = list.map((item) => mapSummaryItem(item)).filter((item) => Boolean(item));
+  return {
+    notes,
+    nextCursor: readString(root, ["nextCursor", "next_cursor", "cursor"]),
+    hasMore: readBoolean(root, ["hasMore", "has_more"])
+  };
+}
+function normalizeMcpMeeting(payload, targetMeetingId) {
+  const root = asObject(payload);
+  const candidates = asArray(payload) ?? asArray(root?.meetings) ?? asArray(root?.notes) ?? asArray(root?.items) ?? asArray(root?.results) ?? asArray(root?.data);
+  if (candidates?.length) {
+    const selected = candidates.find((item) => readId(item) === targetMeetingId) ?? candidates.find((item) => String(readId(item) ?? "").includes(targetMeetingId)) ?? candidates[0];
+    return selected ? mapMeetingItem(selected) : undefined;
+  }
+  const direct = mapMeetingItem(payload);
+  if (direct && direct.id === targetMeetingId) {
+    return direct;
+  }
+  return direct;
+}
+function normalizeMcpTranscript(payload) {
+  const root = asObject(payload);
+  const list = asArray(payload) ?? asArray(root?.transcript) ?? asArray(root?.segments) ?? asArray(root?.items) ?? asArray(root?.data) ?? [];
+  if (list.length === 0 && typeof payload === "string") {
+    return [
+      {
+        text: payload,
+        start_time: "00:00:00",
+        end_time: "00:00:00"
+      }
+    ];
+  }
+  return list.map((item) => mapTranscriptSegment(item)).filter((item) => Boolean(item));
+}
+function extractRpcResult(rpc) {
+  const result = rpc.result;
+  if (!result)
+    return null;
+  if (result.structuredContent !== undefined)
+    return result.structuredContent;
+  if (result.data !== undefined)
+    return result.data;
+  const textPayload = result.content?.find((entry) => entry?.type === "text")?.text;
+  if (!textPayload)
+    return result;
+  try {
+    return JSON.parse(textPayload);
+  } catch {
+    return textPayload;
+  }
+}
+function mapSummaryItem(value) {
+  const object = asObject(value);
+  if (!object)
+    return;
+  const id = readId(object);
+  if (!id)
+    return;
+  const owner = mapOwner(object);
+  return {
+    id,
+    title: readString(object, ["title", "name", "meeting_title"]) ?? null,
+    owner,
+    created_at: readString(object, ["created_at", "createdAt", "date", "meeting_date"]) ?? EPOCH
+  };
+}
+function mapMeetingItem(value) {
+  const summary = mapSummaryItem(value);
+  if (!summary)
+    return;
+  const object = asObject(value) ?? {};
+  const attendees = asArray(object.attendees) ?? asArray(object.participants) ?? asArray(object.invitees) ?? [];
+  const mappedAttendees = attendees.map((entry) => mapUser(entry)).filter((entry) => Boolean(entry));
+  const folders = asArray(object.folder_membership) ?? asArray(object.folders) ?? [];
+  const folderMembership = folders.map((entry, index) => mapFolder(entry, index)).filter((entry) => Boolean(entry));
+  const calendarEvent = asObject(object.calendar_event) ? {
+    event_title: readString(asObject(object.calendar_event), [
+      "event_title",
+      "title"
+    ]) ?? null,
+    invitees: mappedAttendees.map((attendee) => ({
+      email: attendee.email
+    })),
+    organiser: readString(asObject(object.calendar_event), [
+      "organiser",
+      "organizer"
+    ]) ?? summary.owner.email,
+    calendar_event_id: readString(asObject(object.calendar_event), [
+      "calendar_event_id",
+      "id"
+    ]) ?? null,
+    scheduled_start_time: readString(asObject(object.calendar_event), [
+      "scheduled_start_time",
+      "start_time",
+      "start"
+    ]) ?? null,
+    scheduled_end_time: readString(asObject(object.calendar_event), [
+      "scheduled_end_time",
+      "end_time",
+      "end"
+    ]) ?? null
+  } : null;
+  const transcript = normalizeMcpTranscript(object.transcript ?? object.segments);
+  return {
+    ...summary,
+    calendar_event: calendarEvent,
+    attendees: mappedAttendees,
+    folder_membership: folderMembership,
+    summary_text: readString(object, ["summary_text", "summary", "enhanced_notes"]) ?? "",
+    transcript: transcript.length ? transcript : null
+  };
+}
+function mapTranscriptSegment(value) {
+  const object = asObject(value);
+  if (!object) {
+    if (typeof value !== "string")
+      return;
+    return {
+      text: value,
+      start_time: "00:00:00",
+      end_time: "00:00:00"
+    };
+  }
+  const text = readString(object, ["text", "content", "utterance"]);
+  if (!text)
+    return;
+  const speakerSource = readString(asObject(object.speaker), ["source", "name"]) ?? readString(object, ["speaker", "speaker_name"]);
+  return {
+    speaker: speakerSource ? { source: speakerSource } : undefined,
+    text,
+    start_time: readString(object, ["start_time", "startTime", "timestamp", "time"]) ?? "00:00:00",
+    end_time: readString(object, ["end_time", "endTime"]) ?? "00:00:00"
+  };
+}
+function mapOwner(object) {
+  const ownerObject = asObject(object.owner) ?? asObject(object.organizer) ?? asObject(object.organiser);
+  const attendee = asArray(object.attendees)?.[0] ?? asArray(object.participants)?.[0] ?? asArray(object.invitees)?.[0];
+  const ownerCandidate = ownerObject ?? asObject(attendee) ?? {};
+  return {
+    name: readString(ownerCandidate, ["name", "displayName"]) ?? null,
+    email: readString(ownerCandidate, ["email"]) ?? UNKNOWN_EMAIL
+  };
+}
+function mapUser(value) {
+  if (typeof value === "string") {
+    return {
+      name: null,
+      email: value
+    };
+  }
+  const object = asObject(value);
+  if (!object)
+    return;
+  const email = readString(object, ["email"]);
+  if (!email)
+    return;
+  return {
+    name: readString(object, ["name", "displayName"]) ?? null,
+    email
+  };
+}
+function mapFolder(value, index) {
+  const object = asObject(value);
+  if (!object)
+    return;
+  const id = readString(object, ["id"]) ?? `folder-${index}`;
+  const name = readString(object, ["name"]) ?? "Folder";
+  return {
+    id,
+    object: "folder",
+    name
+  };
+}
+function readId(value) {
+  const object = asObject(value);
+  if (!object)
+    return;
+  return readString(object, [
+    "id",
+    "meeting_id",
+    "meetingId",
+    "note_id",
+    "noteId"
+  ]);
+}
+function readString(object, keys) {
+  if (!object)
+    return;
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function readBoolean(object, keys) {
+  if (!object)
+    return;
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "boolean")
+      return value;
+  }
+  return;
+}
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  return value;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : undefined;
+}
+async function safeReadText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/granola-meeting-recorder.ts
+var DEFAULT_BASE_URL = "https://public-api.granola.ai";
+var DEFAULT_MCP_URL = "https://mcp.granola.ai/mcp";
+var MAX_PAGE_SIZE = 30;
+
+class GranolaMeetingRecorderProvider {
+  apiKey;
+  baseUrl;
+  defaultPageSize;
+  transport;
+  mcpClient;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.defaultPageSize = options.pageSize;
+    this.transport = options.transport ?? "api";
+    this.mcpClient = new GranolaMcpClient({
+      mcpUrl: options.mcpUrl ?? DEFAULT_MCP_URL,
+      mcpAccessToken: options.mcpAccessToken,
+      mcpHeaders: options.mcpHeaders,
+      fetchFn: options.fetchFn
+    });
+  }
+  async listMeetings(params) {
+    if (this.transport === "mcp") {
+      return this.listMeetingsViaMcp(params);
+    }
+    const query = new URLSearchParams;
+    if (params.from)
+      query.set("created_after", params.from);
+    if (params.to)
+      query.set("created_before", params.to);
+    if (params.cursor)
+      query.set("cursor", params.cursor);
+    const pageSize = params.pageSize ?? this.defaultPageSize;
+    if (pageSize) {
+      query.set("page_size", String(Math.min(pageSize, MAX_PAGE_SIZE)));
+    }
+    const data = await this.request(`/v1/notes?${query.toString()}`);
+    return {
+      meetings: data.notes.map((note) => this.mapNoteSummary(note, params)),
+      nextCursor: data.cursor ?? undefined,
+      hasMore: data.hasMore
+    };
+  }
+  async getMeeting(params) {
+    if (this.transport === "mcp") {
+      return this.getMeetingViaMcp(params);
+    }
+    const includeTranscript = params.includeTranscript ?? false;
+    const note = await this.getNote(params.meetingId, includeTranscript);
+    return this.mapNoteDetail(note, params);
+  }
+  async getTranscript(params) {
+    if (this.transport === "mcp") {
+      return this.getTranscriptViaMcp(params);
+    }
+    const note = await this.getNote(params.meetingId, true);
+    const segments = this.mapTranscriptSegments(note.transcript);
+    return {
+      id: note.id,
+      meetingId: note.id,
+      tenantId: params.tenantId,
+      connectionId: params.connectionId ?? "unknown",
+      externalId: note.id,
+      format: "segments",
+      text: segments.map((segment) => segment.text).join(`
+`),
+      segments,
+      generatedAt: note.created_at,
+      metadata: {
+        summaryText: note.summary_text
+      },
+      raw: note.transcript ?? undefined
+    };
+  }
+  async listMeetingsViaMcp(params) {
+    const payload = await this.mcpClient.callTool("list_meetings", {
+      cursor: params.cursor,
+      limit: params.pageSize ?? this.defaultPageSize,
+      query: params.query,
+      from: params.from,
+      to: params.to,
+      organizerEmail: params.organizerEmail,
+      participantEmail: params.participantEmail
+    });
+    const normalized = normalizeMcpListResult(payload);
+    return {
+      meetings: normalized.notes.map((note) => this.mapNoteSummary(note, params)),
+      nextCursor: normalized.nextCursor,
+      hasMore: normalized.hasMore ?? Boolean(normalized.nextCursor && normalized.notes.length > 0)
+    };
+  }
+  async getMeetingViaMcp(params) {
+    const primaryPayload = await this.mcpClient.callTool("list_meetings", {
+      query: params.meetingId,
+      limit: 50
+    });
+    let note = normalizeMcpMeeting(primaryPayload, params.meetingId);
+    if (!note) {
+      const fallbackPayload = await this.mcpClient.callTool("get_meetings", {
+        query: params.meetingId
+      });
+      note = normalizeMcpMeeting(fallbackPayload, params.meetingId);
+    }
+    if (!note) {
+      throw new Error(`Granola meeting "${params.meetingId}" not found via MCP.`);
+    }
+    return this.mapNoteDetail(note, params);
+  }
+  async getTranscriptViaMcp(params) {
+    const payload = await this.mcpClient.callTool("get_meeting_transcript", {
+      meeting_id: params.meetingId,
+      meetingId: params.meetingId,
+      id: params.meetingId
+    });
+    const transcript = normalizeMcpTranscript(payload);
+    const segments = this.mapTranscriptSegments(transcript);
+    return {
+      id: params.meetingId,
+      meetingId: params.meetingId,
+      tenantId: params.tenantId,
+      connectionId: params.connectionId ?? "unknown",
+      externalId: params.meetingId,
+      format: "segments",
+      text: segments.map((segment) => segment.text).join(`
+`),
+      segments,
+      metadata: {
+        provider: "granola",
+        transport: "mcp"
+      },
+      raw: payload
+    };
+  }
+  async getNote(noteId, includeTranscript) {
+    const query = includeTranscript ? "?include=transcript" : "";
+    return this.request(`/v1/notes/${noteId}${query}`);
+  }
+  mapNoteSummary(note, params) {
+    const connectionId = params.connectionId ?? "unknown";
+    return {
+      id: note.id,
+      tenantId: params.tenantId,
+      connectionId,
+      externalId: note.id,
+      title: note.title ?? undefined,
+      organizer: this.mapUser(note.owner),
+      scheduledStartAt: note.created_at,
+      recordingStartAt: note.created_at,
+      transcriptAvailable: false,
+      createdAt: note.created_at,
+      updatedAt: note.created_at,
+      sourcePlatform: "granola"
+    };
+  }
+  mapNoteDetail(note, params) {
+    const connectionId = params.connectionId ?? "unknown";
+    const calendarEvent = note.calendar_event ?? undefined;
+    const invitees = calendarEvent?.invitees ? calendarEvent.invitees.map((invitee) => this.mapInvitee(invitee)) : note.attendees?.map((attendee) => this.mapUser(attendee)).filter(Boolean);
+    const participants = note.attendees?.map((attendee) => this.mapUser(attendee)).filter(Boolean);
+    return {
+      id: note.id,
+      tenantId: params.tenantId,
+      connectionId,
+      externalId: note.id,
+      title: note.title ?? calendarEvent?.event_title ?? undefined,
+      summary: note.summary_text ?? undefined,
+      organizer: this.mapUser(note.owner),
+      invitees: invitees?.length ? invitees : undefined,
+      participants: participants?.length ? participants : undefined,
+      scheduledStartAt: calendarEvent?.scheduled_start_time ?? undefined,
+      scheduledEndAt: calendarEvent?.scheduled_end_time ?? undefined,
+      recordingStartAt: calendarEvent?.scheduled_start_time ?? note.created_at,
+      recordingEndAt: calendarEvent?.scheduled_end_time ?? undefined,
+      transcriptAvailable: Array.isArray(note.transcript),
+      createdAt: note.created_at,
+      updatedAt: note.created_at,
+      sourcePlatform: "granola",
+      metadata: {
+        calendarEvent,
+        folderMembership: note.folder_membership
+      }
+    };
+  }
+  mapTranscriptSegments(transcript) {
+    if (!transcript)
+      return [];
+    return transcript.map((segment, index) => ({
+      index,
+      speakerName: segment.speaker?.source ?? undefined,
+      text: segment.text,
+      startTime: segment.start_time,
+      endTime: segment.end_time
+    }));
+  }
+  mapUser(user) {
+    if (!user)
+      return;
+    return {
+      name: user.name ?? undefined,
+      email: user.email ?? undefined,
+      role: "organizer"
+    };
+  }
+  mapInvitee(invitee) {
+    return {
+      email: invitee.email,
+      role: "attendee"
+    };
+  }
+  async request(path) {
+    if (!this.apiKey) {
+      throw new Error('Granola apiKey is required when transport is "api".');
+    }
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const message = await safeReadError(response);
+      throw new Error(`Granola API error (${response.status}): ${message}`);
+    }
+    return await response.json();
+  }
+}
+async function safeReadError(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+export {
+  GranolaMeetingRecorderProvider
+};