@contractspec/integration.providers-impls 1.57.0 → 1.58.0

package/dist/node/impls/index.js

@@ -0,0 +1,4658 @@
+// src/impls/elevenlabs-voice.ts
+import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
+var FORMAT_MAP = {
+  mp3: "mp3_44100_128",
+  wav: "pcm_44100",
+  ogg: "mp3_44100_128",
+  pcm: "pcm_16000"
+};
+var SAMPLE_RATE = {
+  mp3_22050_32: 22050,
+  mp3_44100_32: 44100,
+  mp3_44100_64: 44100,
+  mp3_44100_96: 44100,
+  mp3_44100_128: 44100,
+  mp3_44100_192: 44100,
+  pcm_16000: 16000,
+  pcm_22050: 22050,
+  pcm_24000: 24000,
+  pcm_44100: 44100,
+  ulaw_8000: 8000
+};
+
+class ElevenLabsVoiceProvider {
+  client;
+  defaultVoiceId;
+  modelId;
+  constructor(options) {
+    this.client = options.client ?? new ElevenLabsClient({
+      apiKey: options.apiKey
+    });
+    this.defaultVoiceId = options.defaultVoiceId;
+    this.modelId = options.modelId;
+  }
+  async listVoices() {
+    const response = await this.client.voices.getAll();
+    return (response.voices ?? []).map((voice) => ({
+      id: voice.voiceId ?? "",
+      name: voice.name ?? "",
+      description: voice.description ?? undefined,
+      language: voice.labels?.language ?? undefined,
+      metadata: {
+        category: voice.category ?? "",
+        ...voice.previewUrl ? { previewUrl: voice.previewUrl } : {},
+        ...(() => {
+          const { language, ...rest } = voice.labels ?? {};
+          return rest;
+        })()
+      }
+    }));
+  }
+  async synthesize(input) {
+    const voiceId = input.voiceId ?? this.defaultVoiceId;
+    if (!voiceId) {
+      throw new Error("Voice ID is required for ElevenLabs synthesis.");
+    }
+    const formatKey = input.format ?? "mp3";
+    const outputFormat = FORMAT_MAP[formatKey] ?? FORMAT_MAP.mp3;
+    const sampleRate = input.sampleRateHz ?? SAMPLE_RATE[outputFormat] ?? SAMPLE_RATE.mp3_44100_128 ?? 44100;
+    const voiceSettings = input.stability != null || input.similarityBoost != null || input.style != null ? {
+      ...input.stability != null ? { stability: input.stability } : {},
+      ...input.similarityBoost != null ? { similarityBoost: input.similarityBoost } : {},
+      ...input.style != null ? { style: input.style } : {}
+    } : undefined;
+    const stream = await this.client.textToSpeech.convert(voiceId, {
+      text: input.text,
+      modelId: this.modelId,
+      outputFormat,
+      voiceSettings
+    });
+    const audio = await readWebStream(stream);
+    return {
+      audio,
+      format: formatKey,
+      sampleRateHz: sampleRate,
+      durationSeconds: undefined,
+      url: undefined
+    };
+  }
+}
+async function readWebStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  const length = chunks.reduce((total, chunk) => total + chunk.length, 0);
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+// src/impls/fal-voice.ts
+import { createFalClient } from "@fal-ai/client";
+var DEFAULT_MODEL_ID = "fal-ai/chatterbox/text-to-speech";
+
+class FalVoiceProvider {
+  client;
+  modelId;
+  defaultVoiceUrl;
+  defaultExaggeration;
+  defaultTemperature;
+  defaultCfg;
+  pollIntervalMs;
+  constructor(options) {
+    this.client = options.client ?? createFalClient({
+      credentials: options.apiKey
+    });
+    this.modelId = options.modelId ?? DEFAULT_MODEL_ID;
+    this.defaultVoiceUrl = options.defaultVoiceUrl;
+    this.defaultExaggeration = options.defaultExaggeration;
+    this.defaultTemperature = options.defaultTemperature;
+    this.defaultCfg = options.defaultCfg;
+    this.pollIntervalMs = options.pollIntervalMs;
+  }
+  async listVoices() {
+    const voices = [
+      {
+        id: "default",
+        name: "Default Chatterbox Voice",
+        description: "Uses the default model voice (or configured default reference audio URL).",
+        metadata: {
+          modelId: this.modelId
+        }
+      }
+    ];
+    if (this.defaultVoiceUrl) {
+      voices.push({
+        id: this.defaultVoiceUrl,
+        name: "Configured Reference Voice",
+        description: "Reference voice configured at provider setup and used when voiceId is default.",
+        previewUrl: this.defaultVoiceUrl,
+        metadata: {
+          modelId: this.modelId,
+          source: "config.defaultVoiceUrl"
+        }
+      });
+    }
+    return voices;
+  }
+  async synthesize(input) {
+    const referenceVoiceUrl = resolveVoiceUrl(input.voiceId, this.defaultVoiceUrl);
+    const result = await this.client.subscribe(this.modelId, {
+      input: {
+        text: input.text,
+        ...referenceVoiceUrl ? { audio_url: referenceVoiceUrl } : {},
+        ...this.defaultExaggeration != null ? { exaggeration: this.defaultExaggeration } : {},
+        ...this.defaultTemperature != null ? { temperature: this.defaultTemperature } : {},
+        ...this.defaultCfg != null ? { cfg: this.defaultCfg } : {}
+      },
+      pollInterval: this.pollIntervalMs
+    });
+    const audioUrl = extractAudioUrl(result.data);
+    if (!audioUrl) {
+      throw new Error("Fal synthesis completed without an audio URL in response.");
+    }
+    const response = await fetch(audioUrl);
+    if (!response.ok) {
+      throw new Error(`Fal audio download failed (${response.status}).`);
+    }
+    const audio = new Uint8Array(await response.arrayBuffer());
+    return {
+      audio,
+      format: input.format ?? inferFormatFromUrl(audioUrl) ?? "wav",
+      sampleRateHz: input.sampleRateHz ?? 24000,
+      durationSeconds: undefined,
+      url: audioUrl
+    };
+  }
+}
+function resolveVoiceUrl(voiceId, defaultVoiceUrl) {
+  if (!voiceId || voiceId === "default")
+    return defaultVoiceUrl;
+  if (isHttpUrl(voiceId))
+    return voiceId;
+  throw new Error('Fal voiceId must be "default" or a public reference audio URL.');
+}
+function extractAudioUrl(output) {
+  if (output.audio?.url)
+    return output.audio.url;
+  if (typeof output.audio_url === "string")
+    return output.audio_url;
+  if (typeof output.url === "string")
+    return output.url;
+  return;
+}
+function inferFormatFromUrl(url) {
+  const normalized = url.toLowerCase();
+  if (normalized.endsWith(".wav"))
+    return "wav";
+  if (normalized.endsWith(".mp3"))
+    return "mp3";
+  if (normalized.endsWith(".ogg") || normalized.endsWith(".opus"))
+    return "ogg";
+  if (normalized.endsWith(".pcm"))
+    return "pcm";
+  return;
+}
+function isHttpUrl(value) {
+  return value.startsWith("https://") || value.startsWith("http://");
+}
+
+// src/impls/fathom-meeting-recorder.utils.ts
+function extractItems(page) {
+  if (Array.isArray(page.items))
+    return page.items;
+  if (Array.isArray(page.data)) {
+    return page.data;
+  }
+  return [];
+}
+function extractNextCursor(page) {
+  return page.nextCursor ?? page.next_cursor ?? undefined;
+}
+function mapInvitee(invitee) {
+  const email = invitee.email;
+  const name = invitee.name;
+  if (!email && !name)
+    return;
+  return {
+    email,
+    name,
+    role: "attendee",
+    isExternal: invitee.is_external
+  };
+}
+function matchRecordingId(meeting, targetId) {
+  return meeting.recordingId === targetId;
+}
+function durationSeconds(start, end) {
+  if (!start || !end)
+    return;
+  const startDate = start instanceof Date ? start : new Date(start);
+  const endDate = end instanceof Date ? end : new Date(end);
+  if (Number.isNaN(startDate.valueOf()) || Number.isNaN(endDate.valueOf())) {
+    return;
+  }
+  return Math.max(0, (endDate.valueOf() - startDate.valueOf()) / 1000);
+}
+function mapTranscriptSegment(segment, index) {
+  return {
+    index,
+    speakerName: segment.speaker?.display_name ?? undefined,
+    speakerEmail: segment.speaker?.matched_calendar_invitee_email ?? undefined,
+    text: segment.text,
+    startTimeMs: parseTimestamp(segment.timestamp)
+  };
+}
+function parseTimestamp(value) {
+  const parts = value.split(":").map((part) => Number(part));
+  if (parts.length !== 3 || parts.some((part) => Number.isNaN(part))) {
+    return;
+  }
+  const [hours = 0, minutes = 0, seconds = 0] = parts;
+  return (hours * 3600 + minutes * 60 + seconds) * 1000;
+}
+async function safeReadError(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/fathom-meeting-recorder.mapper.ts
+var mapFathomMeetingInvites = (invitees) => {
+  return invitees.map((invitee) => ({
+    ...invitee,
+    name: invitee.name ?? undefined,
+    email: invitee.email ?? undefined
+  }));
+};
+function mapFathomMeeting(meeting, params) {
+  const connectionId = params.connectionId ?? "unknown";
+  return {
+    id: meeting.recordingId.toString(),
+    tenantId: params.tenantId,
+    connectionId,
+    externalId: meeting.recordingId.toString(),
+    title: meeting.title ?? meeting.meetingTitle,
+    organizer: meeting.recordedBy ? {
+      name: meeting.recordedBy.name ?? undefined,
+      email: meeting.recordedBy.email ?? undefined,
+      role: "organizer"
+    } : undefined,
+    invitees: meeting.calendarInvitees.length ? mapFathomMeetingInvites(meeting.calendarInvitees) : undefined,
+    participants: meeting.calendarInvitees.length ? mapFathomMeetingInvites(meeting.calendarInvitees) : undefined,
+    scheduledStartAt: meeting.scheduledStartTime?.toISOString(),
+    scheduledEndAt: meeting.scheduledEndTime?.toISOString(),
+    recordingStartAt: meeting.recordingStartTime?.toISOString(),
+    recordingEndAt: meeting.recordingEndTime?.toISOString(),
+    durationSeconds: durationSeconds(meeting.recordingStartTime, meeting.recordingEndTime),
+    meetingUrl: meeting.url ?? undefined,
+    shareUrl: meeting.shareUrl ?? undefined,
+    transcriptAvailable: Array.isArray(meeting.transcript),
+    sourcePlatform: "fathom",
+    language: meeting.transcriptLanguage,
+    metadata: {
+      calendarInviteesDomainsType: meeting.calendarInviteesDomainsType
+    }
+  };
+}
+
+// src/impls/fathom-meeting-recorder.webhooks.ts
+import { TriggeredFor } from "fathom-typescript/sdk/models/operations";
+function normalizeWebhookHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null)
+      continue;
+    const normalizedKey = key.toLowerCase();
+    if (Array.isArray(value)) {
+      if (value.length === 0)
+        continue;
+      normalized[normalizedKey] = value.join(", ");
+    } else {
+      normalized[normalizedKey] = value;
+    }
+  }
+  return normalized;
+}
+function normalizeTriggeredFor(values) {
+  if (!values)
+    return;
+  const allowed = new Set(Object.values(TriggeredFor));
+  const normalized = values.map((value) => value.trim()).filter((value) => allowed.has(value));
+  return normalized.length ? normalized : undefined;
+}
+
+// src/impls/fathom-meeting-recorder.ts
+import { Fathom } from "fathom-typescript";
+import { TriggeredFor as TriggeredFor2 } from "fathom-typescript/sdk/models/operations";
+var DEFAULT_BASE_URL = "https://api.fathom.ai/external/v1";
+
+class FathomMeetingRecorderProvider {
+  client;
+  apiKey;
+  baseUrl;
+  includeTranscript;
+  includeSummary;
+  includeActionItems;
+  includeCrmMatches;
+  triggeredFor;
+  webhookSecret;
+  maxPages;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.includeTranscript = options.includeTranscript ?? false;
+    this.includeSummary = options.includeSummary ?? false;
+    this.includeActionItems = options.includeActionItems ?? false;
+    this.includeCrmMatches = options.includeCrmMatches ?? false;
+    this.triggeredFor = options.triggeredFor;
+    this.webhookSecret = options.webhookSecret;
+    this.maxPages = options.maxPages ?? 5;
+    this.client = options.client ?? new Fathom({
+      serverURL: this.baseUrl,
+      security: {
+        apiKeyAuth: this.apiKey
+      }
+    });
+  }
+  async listMeetings(params) {
+    const request = {
+      cursor: params.cursor,
+      createdAfter: params.from,
+      createdBefore: params.to,
+      includeTranscript: params.includeTranscript ?? this.includeTranscript,
+      includeSummary: params.includeSummary ?? this.includeSummary,
+      includeActionItems: this.includeActionItems,
+      includeCrmMatches: this.includeCrmMatches
+    };
+    const result = await this.client.listMeetings(request);
+    let firstPage;
+    for await (const page of result) {
+      firstPage = page;
+      break;
+    }
+    if (!firstPage) {
+      return { meetings: [] };
+    }
+    const rawItems = extractItems(firstPage);
+    const meetings = rawItems.map((meeting) => mapFathomMeeting(meeting, params));
+    return {
+      meetings,
+      nextCursor: extractNextCursor(firstPage) ?? undefined,
+      hasMore: Boolean(extractNextCursor(firstPage))
+    };
+  }
+  async getMeeting(params) {
+    const result = await this.client.listMeetings({
+      includeTranscript: params.includeTranscript ?? this.includeTranscript,
+      includeSummary: params.includeSummary ?? this.includeSummary,
+      includeActionItems: this.includeActionItems,
+      includeCrmMatches: this.includeCrmMatches
+    });
+    let pageCount = 0;
+    const targetId = Number.parseInt(params.meetingId, 10);
+    for await (const page of result) {
+      pageCount += 1;
+      const match = extractItems(page).find((meeting) => matchRecordingId(meeting, targetId));
+      if (match) {
+        return mapFathomMeeting(match, params);
+      }
+      if (pageCount >= this.maxPages) {
+        break;
+      }
+    }
+    throw new Error(`Fathom meeting "${targetId}" not found.`);
+  }
+  async getTranscript(params) {
+    const response = await this.request(`/recordings/${encodeURIComponent(params.meetingId)}/transcript`);
+    if (!Array.isArray(response.transcript)) {
+      throw new Error("Fathom transcript response did not include transcript.");
+    }
+    const segments = response.transcript.map((segment, index) => mapTranscriptSegment(segment, index));
+    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: "fathom"
+      },
+      raw: response.transcript
+    };
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? JSON.parse(request.rawBody);
+    const body = payload;
+    const recordingId = body.recording_id ?? body.recordingId ?? body.meeting_id ?? body.meetingId;
+    const verified = this.webhookSecret ? await this.verifyWebhook(request) : undefined;
+    return {
+      providerKey: "meeting-recorder.fathom",
+      eventType: body.event_type ?? body.eventType,
+      meetingId: recordingId,
+      recordingId,
+      verified,
+      payload
+    };
+  }
+  async verifyWebhook(request) {
+    if (!this.webhookSecret)
+      return true;
+    const headers = normalizeWebhookHeaders(request.headers);
+    try {
+      return Boolean(Fathom.verifyWebhook(this.webhookSecret, headers, request.rawBody));
+    } catch {
+      return false;
+    }
+  }
+  async registerWebhook(registration) {
+    const triggeredFor = normalizeTriggeredFor(registration.triggeredFor) ?? normalizeTriggeredFor(this.triggeredFor) ?? [TriggeredFor2.MyRecordings];
+    const webhook = await this.client.createWebhook({
+      destinationUrl: registration.url,
+      includeTranscript: registration.includeTranscript ?? true,
+      includeSummary: registration.includeSummary ?? false,
+      includeActionItems: registration.includeActionItems ?? false,
+      includeCrmMatches: registration.includeCrmMatches ?? false,
+      triggeredFor
+    });
+    return {
+      id: webhook.id,
+      secret: webhook.secret
+    };
+  }
+  async request(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      const message = await safeReadError(response);
+      throw new Error(`Fathom API error (${response.status}): ${message}`);
+    }
+    return await response.json();
+  }
+}
+
+// src/impls/fireflies-meeting-recorder.queries.ts
+var TRANSCRIPTS_QUERY = `
+  query Transcripts(
+    $limit: Int
+    $skip: Int
+    $fromDate: DateTime
+    $toDate: DateTime
+    $keyword: String
+    $scope: TranscriptsQueryScope
+  ) {
+    transcripts(
+      limit: $limit
+      skip: $skip
+      fromDate: $fromDate
+      toDate: $toDate
+      keyword: $keyword
+      scope: $scope
+    ) {
+      id
+      title
+      organizer_email
+      participants
+      meeting_attendees {
+        name
+        email
+        displayName
+      }
+      dateString
+      duration
+      meeting_link
+      transcript_url
+    }
+  }
+`;
+var TRANSCRIPT_QUERY = `
+  query Transcript($transcriptId: String!) {
+    transcript(id: $transcriptId) {
+      id
+      title
+      organizer_email
+      participants
+      meeting_attendees {
+        name
+        email
+        displayName
+      }
+      dateString
+      duration
+      meeting_link
+      transcript_url
+    }
+  }
+`;
+var TRANSCRIPT_WITH_SEGMENTS_QUERY = `
+  query Transcript($transcriptId: String!) {
+    transcript(id: $transcriptId) {
+      id
+      title
+      organizer_email
+      participants
+      meeting_attendees {
+        name
+        email
+        displayName
+      }
+      dateString
+      duration
+      meeting_link
+      transcript_url
+      sentences {
+        index
+        speaker_name
+        speaker_id
+        text
+        start_time
+        end_time
+      }
+    }
+  }
+`;
+
+// src/impls/fireflies-meeting-recorder.utils.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { timingSafeEqual } from "crypto";
+function parseSeconds(value) {
+  if (value == null)
+    return;
+  const num = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(num))
+    return;
+  return num * 1000;
+}
+function normalizeHeader(headers, key) {
+  const header = headers[key] ?? headers[key.toLowerCase()] ?? headers[key.toUpperCase()];
+  if (Array.isArray(header))
+    return header[0];
+  return header;
+}
+function safeCompareHex(a, b) {
+  try {
+    const aBuffer = Buffer2.from(a, "hex");
+    const bBuffer = Buffer2.from(b, "hex");
+    if (aBuffer.length !== bBuffer.length)
+      return false;
+    return timingSafeEqual(aBuffer, bBuffer);
+  } catch {
+    return false;
+  }
+}
+async function safeReadError2(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/fireflies-meeting-recorder.ts
+import { createHmac } from "crypto";
+var DEFAULT_BASE_URL2 = "https://api.fireflies.ai/graphql";
+
+class FirefliesMeetingRecorderProvider {
+  apiKey;
+  baseUrl;
+  defaultPageSize;
+  webhookSecret;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL2;
+    this.defaultPageSize = options.pageSize;
+    this.webhookSecret = options.webhookSecret;
+  }
+  async listMeetings(params) {
+    const limit = params.pageSize ?? this.defaultPageSize ?? 25;
+    const skip = params.cursor ? Number(params.cursor) : 0;
+    const data = await this.query(TRANSCRIPTS_QUERY, {
+      limit,
+      skip: Number.isFinite(skip) ? skip : 0,
+      fromDate: params.from,
+      toDate: params.to,
+      keyword: params.query,
+      scope: params.query ? "all" : undefined
+    });
+    const meetings = data.transcripts.map((transcript) => this.mapTranscriptToMeeting(transcript, params));
+    const nextCursor = meetings.length === limit ? String(skip + limit) : undefined;
+    return {
+      meetings,
+      nextCursor,
+      hasMore: Boolean(nextCursor)
+    };
+  }
+  async getMeeting(params) {
+    const data = await this.query(TRANSCRIPT_QUERY, {
+      transcriptId: params.meetingId
+    });
+    return this.mapTranscriptToMeeting(data.transcript, params);
+  }
+  async getTranscript(params) {
+    const data = await this.query(TRANSCRIPT_WITH_SEGMENTS_QUERY, { transcriptId: params.meetingId });
+    const transcript = data.transcript;
+    const segments = (transcript.sentences ?? []).map((segment) => this.mapSentence(segment));
+    return {
+      id: transcript.id,
+      meetingId: transcript.id,
+      tenantId: params.tenantId,
+      connectionId: params.connectionId ?? "unknown",
+      externalId: transcript.id,
+      format: "segments",
+      text: segments.map((segment) => segment.text).join(`
+`),
+      segments,
+      generatedAt: transcript.dateString ?? undefined,
+      sourceUrl: transcript.transcript_url ?? undefined,
+      metadata: {
+        meetingLink: transcript.meeting_link,
+        durationMinutes: transcript.duration
+      },
+      raw: transcript
+    };
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? JSON.parse(request.rawBody);
+    const body = payload;
+    const verified = this.webhookSecret ? await this.verifyWebhook(request) : undefined;
+    return {
+      providerKey: "meeting-recorder.fireflies",
+      eventType: body.eventType,
+      meetingId: body.meetingId,
+      transcriptId: body.meetingId,
+      verified,
+      payload,
+      metadata: {
+        clientReferenceId: body.clientReferenceId
+      }
+    };
+  }
+  async verifyWebhook(request) {
+    if (!this.webhookSecret)
+      return true;
+    const signatureHeader = normalizeHeader(request.headers, "x-hub-signature");
+    if (!signatureHeader)
+      return false;
+    const signature = signatureHeader.replace(/^sha256=/, "");
+    const digest = createHmac("sha256", this.webhookSecret).update(request.rawBody).digest("hex");
+    return safeCompareHex(digest, signature);
+  }
+  mapTranscriptToMeeting(transcript, params) {
+    const connectionId = params.connectionId ?? "unknown";
+    const organizer = transcript.organizer_email ? { email: transcript.organizer_email, role: "organizer" } : undefined;
+    const attendees = transcript.meeting_attendees?.length ? transcript.meeting_attendees.map((attendee) => this.mapAttendee(attendee)) : transcript.participants?.map((email) => ({ email, role: "attendee" }));
+    return {
+      id: transcript.id,
+      tenantId: params.tenantId,
+      connectionId,
+      externalId: transcript.id,
+      title: transcript.title ?? undefined,
+      organizer,
+      invitees: attendees,
+      participants: attendees,
+      scheduledStartAt: transcript.dateString ?? undefined,
+      recordingStartAt: transcript.dateString ?? undefined,
+      durationSeconds: transcript.duration ? transcript.duration * 60 : undefined,
+      meetingUrl: transcript.meeting_link ?? transcript.transcript_url ?? undefined,
+      transcriptAvailable: Boolean(transcript.transcript_url),
+      sourcePlatform: "fireflies",
+      metadata: {
+        transcriptUrl: transcript.transcript_url
+      }
+    };
+  }
+  mapAttendee(attendee) {
+    return {
+      name: attendee.name ?? attendee.displayName ?? undefined,
+      email: attendee.email ?? undefined,
+      role: "attendee"
+    };
+  }
+  mapSentence(segment) {
+    return {
+      index: segment.index ?? undefined,
+      speakerId: segment.speaker_id ?? undefined,
+      speakerName: segment.speaker_name ?? undefined,
+      text: segment.text,
+      startTimeMs: parseSeconds(segment.start_time),
+      endTimeMs: parseSeconds(segment.end_time)
+    };
+  }
+  async query(query, variables) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    if (!response.ok) {
+      const message = await safeReadError2(response);
+      throw new Error(`Fireflies API error (${response.status}): ${message}`);
+    }
+    const result = await response.json();
+    if (result.errors?.length) {
+      throw new Error(result.errors.map((error) => error.message).join("; "));
+    }
+    if (!result.data) {
+      throw new Error("Fireflies API returned empty data payload.");
+    }
+    return result.data;
+  }
+}
+
+// src/impls/gcs-storage.ts
+import { Storage } from "@google-cloud/storage";
+
+class GoogleCloudStorageProvider {
+  storage;
+  bucketName;
+  constructor(options) {
+    this.storage = options.storage ?? new Storage(options.clientOptions ?? undefined);
+    this.bucketName = options.bucket;
+  }
+  async putObject(input) {
+    const bucketName = input.bucket ?? this.bucketName;
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(input.key);
+    const buffer = toBuffer(input.data);
+    await file.save(buffer, {
+      resumable: false,
+      contentType: input.contentType,
+      metadata: input.metadata
+    });
+    if (input.makePublic) {
+      await file.makePublic();
+    }
+    const [metadata] = await file.getMetadata();
+    return toMetadata(metadata);
+  }
+  async getObject(input) {
+    const bucketName = input.bucket ?? this.bucketName;
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(input.key);
+    const [exists] = await file.exists();
+    if (!exists)
+      return null;
+    const [contents] = await file.download();
+    const [metadata] = await file.getMetadata();
+    return {
+      ...toMetadata(metadata),
+      data: new Uint8Array(contents)
+    };
+  }
+  async deleteObject(input) {
+    const bucketName = input.bucket ?? this.bucketName;
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(input.key);
+    await file.delete({ ignoreNotFound: true });
+  }
+  async generateSignedUrl(options) {
+    const bucketName = options.bucket ?? this.bucketName;
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(options.key);
+    const action = options.method === "PUT" ? "write" : "read";
+    const expires = Date.now() + options.expiresInSeconds * 1000;
+    const [url] = await file.getSignedUrl({
+      action,
+      expires,
+      contentType: options.contentType
+    });
+    return { url, expiresAt: new Date(expires) };
+  }
+  async listObjects(query) {
+    const bucketName = query.bucket ?? this.bucketName;
+    const bucket = this.storage.bucket(bucketName);
+    const [files, nextQuery, response] = await bucket.getFiles({
+      prefix: query.prefix,
+      maxResults: query.maxResults,
+      pageToken: query.pageToken
+    });
+    const nextTokenFromQuery = typeof nextQuery === "object" && nextQuery !== null && "pageToken" in nextQuery ? nextQuery.pageToken : undefined;
+    const nextTokenFromResponse = response && typeof response === "object" && "nextPageToken" in response ? response.nextPageToken : undefined;
+    return {
+      objects: files.map((file) => toMetadata(file.metadata)),
+      nextPageToken: nextTokenFromQuery ?? nextTokenFromResponse ?? undefined
+    };
+  }
+}
+function toBuffer(data) {
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  return Buffer.from(data);
+}
+function toMetadata(metadata) {
+  const meta = metadata;
+  return {
+    bucket: String(meta.bucket ?? ""),
+    key: String(meta.name ?? ""),
+    sizeBytes: meta.size ? Number(meta.size) : undefined,
+    contentType: meta.contentType ? String(meta.contentType) : undefined,
+    etag: meta.etag ? String(meta.etag) : undefined,
+    checksum: meta.md5Hash ? String(meta.md5Hash) : undefined,
+    lastModified: meta.updated ? new Date(String(meta.updated)) : undefined,
+    metadata: meta.metadata
+  };
+}
+
+// src/impls/gmail-inbound.ts
+import { google } from "googleapis";
+
+class GmailInboundProvider {
+  gmail;
+  userId;
+  includeSpamTrash;
+  auth;
+  constructor(options) {
+    this.auth = options.auth;
+    this.gmail = options.gmail ?? google.gmail({
+      version: "v1",
+      auth: options.auth
+    });
+    this.userId = options.userId ?? "me";
+    this.includeSpamTrash = options.includeSpamTrash ?? false;
+  }
+  async listThreads(query) {
+    const response = await this.gmail.users.threads.list({
+      userId: this.userId,
+      maxResults: query?.pageSize,
+      pageToken: query?.pageToken,
+      q: query?.query,
+      labelIds: query?.label ? [query.label] : undefined,
+      includeSpamTrash: this.includeSpamTrash,
+      auth: this.auth
+    });
+    const threads = await Promise.all((response.data.threads ?? []).map(async (thread) => {
+      if (!thread.id)
+        return null;
+      return this.getThread(thread.id);
+    }));
+    return threads.filter((thread) => thread !== null);
+  }
+  async getThread(threadId) {
+    const response = await this.gmail.users.threads.get({
+      id: threadId,
+      userId: this.userId,
+      format: "full",
+      auth: this.auth
+    });
+    const thread = response.data;
+    if (!thread)
+      return null;
+    const messages = thread.messages?.map((message) => this.transformMessage(message)) ?? [];
+    const participants = dedupeAddresses(messages.flatMap((message) => [
+      message.from,
+      ...message.to,
+      ...message.cc ?? []
+    ]));
+    const firstMessage = messages[0];
+    const lastMessage = messages[messages.length - 1];
+    const updatedAt = lastMessage?.receivedAt ?? lastMessage?.sentAt ?? firstMessage?.receivedAt ?? firstMessage?.sentAt ?? new Date;
+    const labels = Array.from(new Set(messages.flatMap((message) => {
+      const labelField = message.metadata?.labelIds;
+      if (!labelField)
+        return [];
+      return labelField.split(",").map((label) => label.trim());
+    }).filter((label) => Boolean(label))));
+    return {
+      id: thread.id ?? threadId,
+      subject: messages[0]?.subject,
+      snippet: thread.snippet ?? "",
+      participants,
+      messages,
+      updatedAt,
+      labels,
+      metadata: thread.historyId ? { historyId: thread.historyId } : undefined
+    };
+  }
+  async listMessagesSince(query) {
+    const after = query.since ? Math.floor(query.since.getTime() / 1000) : undefined;
+    const q = [];
+    if (after) {
+      q.push(`after:${after}`);
+    }
+    const response = await this.gmail.users.messages.list({
+      userId: this.userId,
+      maxResults: query.pageSize,
+      pageToken: query.pageToken,
+      labelIds: query.label ? [query.label] : undefined,
+      q: q.join(" "),
+      includeSpamTrash: this.includeSpamTrash,
+      auth: this.auth
+    });
+    const messages = await Promise.all((response.data.messages ?? []).map(async (item) => {
+      if (!item.id)
+        return null;
+      const full = await this.gmail.users.messages.get({
+        userId: this.userId,
+        id: item.id,
+        format: "full",
+        auth: this.auth
+      });
+      if (!full.data)
+        return null;
+      return this.transformMessage(full.data);
+    }));
+    return {
+      messages: messages.filter((message) => message !== null),
+      nextPageToken: response.data.nextPageToken ?? undefined
+    };
+  }
+  transformMessage(message) {
+    const headers = message.payload?.headers ?? [];
+    const subject = headerValue(headers, "Subject") ?? "";
+    const from = parseAddress(headerValue(headers, "From")) ?? inferFallbackAddress("from", message.id);
+    const to = parseAddressList(headerValue(headers, "To"));
+    const cc = parseAddressList(headerValue(headers, "Cc"));
+    const bcc = parseAddressList(headerValue(headers, "Bcc"));
+    const replyTo = parseAddress(headerValue(headers, "Reply-To"));
+    const { text, html, attachments } = extractContent(message.payload);
+    const timestamp = message.internalDate ? new Date(Number(message.internalDate)) : new Date;
+    const metadata = {
+      ...message.labelIds?.length ? { labelIds: message.labelIds.join(",") } : {},
+      ...message.historyId ? { historyId: message.historyId } : {}
+    };
+    return {
+      id: message.id ?? "",
+      threadId: message.threadId ?? "",
+      subject,
+      from,
+      to,
+      cc,
+      bcc,
+      replyTo: replyTo ?? undefined,
+      sentAt: timestamp,
+      receivedAt: timestamp,
+      textBody: text ?? undefined,
+      htmlBody: html ?? undefined,
+      attachments,
+      headers: Object.fromEntries(headers.map((header) => [header.name ?? "", header.value ?? ""])),
+      metadata: Object.keys(metadata).length > 0 ? metadata : undefined
+    };
+  }
+}
+function headerValue(headers, name) {
+  const header = headers.find((candidate) => candidate.name?.toLowerCase() === name.toLowerCase());
+  const value = header?.value;
+  return typeof value === "string" ? value : undefined;
+}
+function parseAddress(header) {
+  const addresses = parseAddressList(header);
+  if (addresses.length === 0) {
+    return null;
+  }
+  const firstAddress = addresses[0];
+  return firstAddress || null;
+}
+function inferFallbackAddress(field, messageId) {
+  const suffix = messageId ? messageId.replace(/[^\w]/g, "").slice(-8) || "unknown" : "unknown";
+  return {
+    email: `${field}-${suffix}@mail.local`
+  };
+}
+function parseAddressList(header) {
+  if (!header)
+    return [];
+  return header.split(",").map((part) => part.trim()).filter(Boolean).map((value) => {
+    const match = value.match(/^(?:"?([^"]*)"?\s)?<?([^<>]+)>?$/);
+    if (!match) {
+      return { email: value };
+    }
+    const name = match[1]?.trim();
+    const email = match[2]?.trim();
+    if (!email) {
+      return { email: value };
+    }
+    return name ? { email, name } : { email };
+  });
+}
+function dedupeAddresses(addresses) {
+  const map = new Map;
+  for (const address of addresses) {
+    if (!address)
+      continue;
+    map.set(address.email.toLowerCase(), address);
+  }
+  return Array.from(map.values());
+}
+function extractContent(payload) {
+  if (!payload) {
+    return { attachments: [] };
+  }
+  const attachments = [];
+  const visit = (part) => {
+    if (!part)
+      return {};
+    if (part.filename && part.body?.attachmentId) {
+      attachments.push({
+        id: part.body.attachmentId,
+        filename: part.filename,
+        contentType: part.mimeType ?? "application/octet-stream",
+        sizeBytes: part.body.size ?? undefined
+      });
+    }
+    const mimeType = part.mimeType ?? "";
+    const data = part.body?.data;
+    if (mimeType === "text/plain" && data) {
+      return { text: decodeBase64Url(data) };
+    }
+    if (mimeType === "text/html" && data) {
+      return { html: decodeBase64Url(data) };
+    }
+    if (part.parts?.length) {
+      return part.parts.reduce((acc, nested) => {
+        const value = visit(nested);
+        return {
+          text: value.text ?? acc.text,
+          html: value.html ?? acc.html
+        };
+      }, {});
+    }
+    return {};
+  };
+  const { text, html } = visit(payload);
+  return { text, html, attachments };
+}
+function decodeBase64Url(data) {
+  const normalized = data.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = normalized.length % 4;
+  const padded = padding === 0 ? normalized : normalized + "=".repeat(4 - padding);
+  return Buffer.from(padded, "base64").toString("utf-8");
+}
+
+// src/impls/gmail-outbound.ts
+import { google as google2 } from "googleapis";
+
+class GmailOutboundProvider {
+  gmail;
+  userId;
+  auth;
+  constructor(options) {
+    this.auth = options.auth;
+    this.gmail = options.gmail ?? google2.gmail({
+      version: "v1",
+      auth: options.auth
+    });
+    this.userId = options.userId ?? "me";
+  }
+  async sendEmail(message) {
+    const raw = encodeMessage(message);
+    const response = await this.gmail.users.messages.send({
+      userId: this.userId,
+      requestBody: {
+        raw
+      },
+      auth: this.auth
+    });
+    const id = response.data.id ?? "";
+    return {
+      id,
+      providerMessageId: response.data.id ?? undefined,
+      queuedAt: new Date
+    };
+  }
+}
+function encodeMessage(message) {
+  const headers = [
+    `From: ${formatAddress(message.from)}`,
+    `To: ${message.to.map(formatAddress).join(", ")}`,
+    `Subject: ${message.subject}`,
+    "MIME-Version: 1.0"
+  ];
+  if (message.cc?.length) {
+    headers.push(`Cc: ${message.cc.map(formatAddress).join(", ")}`);
+  }
+  if (message.replyTo) {
+    headers.push(`Reply-To: ${formatAddress(message.replyTo)}`);
+  }
+  Object.entries(message.headers ?? {}).forEach(([key, value]) => {
+    headers.push(`${key}: ${value}`);
+  });
+  const attachments = message.attachments ?? [];
+  const hasHtml = Boolean(message.htmlBody);
+  const hasText = Boolean(message.textBody);
+  const boundaryMain = `mixed_${Date.now()}`;
+  const boundaryAlt = `alt_${Date.now()}`;
+  let body = "";
+  if (attachments.length > 0) {
+    headers.push(`Content-Type: multipart/mixed; boundary="${boundaryMain}"`);
+    body += `\r
+--${boundaryMain}\r
+`;
+    body += buildAlternativePart(hasText, hasHtml, boundaryAlt, message);
+    attachments.forEach((attachment) => {
+      body += buildAttachmentPart(boundaryMain, attachment);
+    });
+    body += `\r
+--${boundaryMain}--`;
+  } else if (hasText && hasHtml) {
+    headers.push(`Content-Type: multipart/alternative; boundary="${boundaryAlt}"`);
+    body += `\r
+--${boundaryAlt}\r
+`;
+    body += buildTextPart('text/plain; charset="utf-8"', message.textBody || "");
+    body += `\r
+--${boundaryAlt}\r
+`;
+    body += buildTextPart('text/html; charset="utf-8"', message.htmlBody || "");
+    body += `\r
+--${boundaryAlt}--`;
+  } else if (hasHtml) {
+    headers.push('Content-Type: text/html; charset="utf-8"');
+    body += `\r
+\r
+${message.htmlBody}`;
+  } else {
+    headers.push('Content-Type: text/plain; charset="utf-8"');
+    body += `\r
+\r
+${message.textBody ?? ""}`;
+  }
+  const mime = `${headers.join(`\r
+`)}${body}`;
+  return Buffer.from(mime).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function buildAlternativePart(hasText, hasHtml, boundary, message) {
+  let content = "";
+  content += `Content-Type: multipart/alternative; boundary="${boundary}"\r
+`;
+  content += `\r
+`;
+  if (hasText) {
+    content += `--${boundary}\r
+`;
+    content += buildTextPart('text/plain; charset="utf-8"', message.textBody || "");
+  }
+  if (hasHtml) {
+    content += `\r
+--${boundary}\r
+`;
+    content += buildTextPart('text/html; charset="utf-8"', message.htmlBody || "");
+  }
+  content += `\r
+--${boundary}--`;
+  return content;
+}
+function buildTextPart(contentType, content) {
+  return `Content-Type: ${contentType}\r
+` + `Content-Transfer-Encoding: 7bit\r
+\r
+` + content;
+}
+function buildAttachmentPart(boundary, attachment) {
+  const data = attachment.data ?? new Uint8Array;
+  const encoded = data.byteLength > 0 ? Buffer.from(data).toString("base64") : "";
+  return `\r
+--${boundary}\r
+` + `Content-Type: ${attachment.contentType}; name="${attachment.filename}"\r
+` + `Content-Transfer-Encoding: base64\r
+` + `Content-Disposition: attachment; filename="${attachment.filename}"\r
+\r
+` + encoded;
+}
+function formatAddress(address) {
+  if (address.name) {
+    return `"${address.name}" <${address.email}>`;
+  }
+  return address.email;
+}
+
+// src/impls/google-calendar.ts
+import { google as google3 } from "googleapis";
+
+class GoogleCalendarProvider {
+  calendar;
+  defaultCalendarId;
+  auth;
+  constructor(options) {
+    this.auth = options.auth;
+    this.calendar = options.calendar ?? google3.calendar({
+      version: "v3",
+      auth: options.auth
+    });
+    this.defaultCalendarId = options.calendarId ?? "primary";
+  }
+  async listEvents(query) {
+    const response = await this.calendar.events.list({
+      calendarId: query.calendarId ?? this.defaultCalendarId,
+      timeMin: query.timeMin?.toISOString(),
+      timeMax: query.timeMax?.toISOString(),
+      maxResults: query.maxResults,
+      pageToken: query.pageToken,
+      singleEvents: true,
+      orderBy: "startTime",
+      auth: this.auth
+    });
+    const events = response.data.items?.map((item) => this.fromGoogleEvent(query.calendarId ?? this.defaultCalendarId, item)) ?? [];
+    return {
+      events,
+      nextPageToken: response.data.nextPageToken ?? undefined
+    };
+  }
+  async createEvent(input) {
+    const calendarId = input.calendarId ?? this.defaultCalendarId;
+    const response = await this.calendar.events.insert({
+      calendarId,
+      requestBody: this.toGoogleEvent(input),
+      conferenceDataVersion: input.conference?.create ? 1 : undefined,
+      auth: this.auth
+    });
+    return this.fromGoogleEvent(calendarId, response.data);
+  }
+  async updateEvent(calendarId, eventId, input) {
+    const response = await this.calendar.events.patch({
+      calendarId: calendarId ?? this.defaultCalendarId,
+      eventId,
+      requestBody: this.toGoogleEvent(input),
+      conferenceDataVersion: input.conference?.create ? 1 : undefined,
+      auth: this.auth
+    });
+    return this.fromGoogleEvent(calendarId, response.data);
+  }
+  async deleteEvent(calendarId, eventId) {
+    await this.calendar.events.delete({
+      calendarId: calendarId ?? this.defaultCalendarId,
+      eventId,
+      auth: this.auth
+    });
+  }
+  fromGoogleEvent(calendarId, event) {
+    const start = parseDateTime(event.start);
+    const end = parseDateTime(event.end);
+    const attendees = event.attendees?.map((attendee) => ({
+      email: attendee.email ?? "",
+      name: attendee.displayName ?? undefined,
+      optional: attendee.optional ?? undefined,
+      responseStatus: normalizeResponseStatus(attendee.responseStatus)
+    })) ?? [];
+    const reminders = event.reminders?.overrides?.map((reminder) => ({
+      method: reminder.method ?? "popup",
+      minutesBeforeStart: reminder.minutes ?? 0
+    })) ?? [];
+    const metadata = buildMetadata(event);
+    return {
+      id: event.id ?? "",
+      calendarId,
+      title: event.summary ?? "",
+      description: event.description ?? undefined,
+      location: event.location ?? undefined,
+      start,
+      end,
+      allDay: event.start?.date ? true : undefined,
+      attendees,
+      reminders,
+      conferenceLink: event.hangoutLink ?? event.conferenceData?.entryPoints?.find((entry) => entry.uri)?.uri ?? undefined,
+      metadata,
+      createdAt: event.created ? new Date(event.created) : undefined,
+      updatedAt: event.updated ? new Date(event.updated) : undefined
+    };
+  }
+  toGoogleEvent(input) {
+    const event = {};
+    if ("title" in input && input.title)
+      event.summary = input.title;
+    if (input.description !== undefined)
+      event.description = input.description;
+    if (input.location !== undefined)
+      event.location = input.location;
+    if (input.start) {
+      event.start = formatDateTime(input.start, input.allDay);
+    }
+    if (input.end) {
+      event.end = formatDateTime(input.end, input.allDay);
+    }
+    if (input.attendees) {
+      event.attendees = input.attendees.map((attendee) => ({
+        email: attendee.email,
+        displayName: attendee.name,
+        optional: attendee.optional,
+        responseStatus: attendee.responseStatus
+      }));
+    }
+    if (input.reminders) {
+      event.reminders = {
+        useDefault: false,
+        overrides: input.reminders.map((reminder) => ({
+          method: reminder.method,
+          minutes: reminder.minutesBeforeStart
+        }))
+      };
+    }
+    if (input.conference?.create) {
+      event.conferenceData = {
+        createRequest: {
+          requestId: `conf-${Date.now()}`
+        }
+      };
+    }
+    if (input.metadata) {
+      event.extendedProperties = {
+        ...event.extendedProperties ?? {},
+        private: {
+          ...event.extendedProperties?.private ?? {},
+          ...input.metadata
+        }
+      };
+    }
+    return event;
+  }
+}
+function parseDateTime(time) {
+  if (!time)
+    return new Date;
+  if (time.dateTime)
+    return new Date(time.dateTime);
+  if (time.date)
+    return new Date(`${time.date}T00:00:00`);
+  return new Date;
+}
+function formatDateTime(date, allDay) {
+  if (allDay) {
+    return { date: date.toISOString().slice(0, 10) };
+  }
+  return { dateTime: date.toISOString() };
+}
+function normalizeResponseStatus(status) {
+  if (!status)
+    return;
+  const allowed = [
+    "needsAction",
+    "declined",
+    "tentative",
+    "accepted"
+  ];
+  return allowed.includes(status) ? status : undefined;
+}
+function buildMetadata(event) {
+  const metadata = {};
+  if (event.status)
+    metadata.status = event.status;
+  if (event.htmlLink)
+    metadata.htmlLink = event.htmlLink;
+  if (event.iCalUID)
+    metadata.iCalUID = event.iCalUID;
+  if (event.etag)
+    metadata.etag = event.etag;
+  if (event.conferenceData?.conferenceSolution?.name) {
+    metadata.conferenceSolution = event.conferenceData.conferenceSolution.name;
+  }
+  if (event.extendedProperties?.private) {
+    Object.entries(event.extendedProperties.private).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        metadata[`extended.${key}`] = value;
+      }
+    });
+  }
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+// src/impls/gradium-voice.ts
+import { Gradium } from "@confiture-ai/gradium-sdk-js";
+var FORMAT_MAP2 = {
+  mp3: "wav",
+  wav: "wav",
+  ogg: "opus",
+  pcm: "pcm"
+};
+
+class GradiumVoiceProvider {
+  client;
+  defaultVoiceId;
+  defaultOutputFormat;
+  constructor(options) {
+    this.client = options.client ?? new Gradium({
+      apiKey: options.apiKey,
+      region: options.region,
+      baseURL: options.baseUrl,
+      timeout: options.timeoutMs
+    });
+    this.defaultVoiceId = options.defaultVoiceId;
+    this.defaultOutputFormat = options.outputFormat;
+  }
+  async listVoices() {
+    const voices = await this.client.voices.list({ include_catalog: true });
+    return voices.map((voice) => this.fromGradiumVoice(voice));
+  }
+  async synthesize(input) {
+    const voiceId = input.voiceId ?? this.defaultVoiceId;
+    if (!voiceId) {
+      throw new Error("Voice ID is required for Gradium synthesis.");
+    }
+    const outputFormat = (input.format ? FORMAT_MAP2[input.format] : undefined) ?? this.defaultOutputFormat ?? "wav";
+    const response = await this.client.tts.create({
+      voice_id: voiceId,
+      output_format: outputFormat,
+      text: input.text
+    });
+    return {
+      audio: response.raw_data,
+      format: input.format ?? toContractFormat(outputFormat),
+      sampleRateHz: input.sampleRateHz ?? response.sample_rate ?? inferSampleRate(outputFormat),
+      durationSeconds: undefined,
+      url: undefined
+    };
+  }
+  fromGradiumVoice(voice) {
+    return {
+      id: voice.uid,
+      name: voice.name,
+      description: voice.description ?? undefined,
+      language: voice.language ?? undefined,
+      metadata: {
+        startSeconds: String(voice.start_s),
+        ...voice.stop_s != null ? { stopSeconds: String(voice.stop_s) } : {},
+        filename: voice.filename
+      }
+    };
+  }
+}
+function toContractFormat(format) {
+  switch (format) {
+    case "opus":
+      return "ogg";
+    case "wav":
+      return "wav";
+    case "pcm":
+    case "pcm_16000":
+    case "pcm_24000":
+      return "pcm";
+    default:
+      return format;
+  }
+}
+function inferSampleRate(format) {
+  switch (format) {
+    case "ulaw_8000":
+    case "alaw_8000":
+      return 8000;
+    case "pcm_16000":
+      return 16000;
+    case "pcm_24000":
+      return 24000;
+    default:
+      return 48000;
+  }
+}
+
+// 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) => mapTranscriptSegment2(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 mapTranscriptSegment2(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_URL3 = "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_URL3;
+    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 safeReadError3(response);
+      throw new Error(`Granola API error (${response.status}): ${message}`);
+    }
+    return await response.json();
+  }
+}
+async function safeReadError3(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/mistral-llm.ts
+import { Mistral } from "@mistralai/mistralai";
+
+class MistralLLMProvider {
+  client;
+  defaultModel;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralLLMProvider requires an apiKey");
+    }
+    this.client = options.client ?? new Mistral({
+      apiKey: options.apiKey,
+      serverURL: options.serverURL,
+      userAgent: options.userAgentSuffix ? `${options.userAgentSuffix}` : undefined
+    });
+    this.defaultModel = options.defaultModel ?? "mistral-large-latest";
+  }
+  async chat(messages, options = {}) {
+    const request = this.buildChatRequest(messages, options);
+    const response = await this.client.chat.complete(request);
+    return this.buildLLMResponse(response);
+  }
+  async* stream(messages, options = {}) {
+    const request = this.buildChatRequest(messages, options);
+    request.stream = true;
+    const stream = await this.client.chat.stream(request);
+    const aggregatedParts = [];
+    const aggregatedToolCalls = [];
+    let usage;
+    let finishReason;
+    for await (const event of stream) {
+      for (const choice of event.data.choices) {
+        const delta = choice.delta;
+        if (typeof delta.content === "string") {
+          if (delta.content.length > 0) {
+            aggregatedParts.push({ type: "text", text: delta.content });
+            yield {
+              type: "message_delta",
+              delta: { type: "text", text: delta.content },
+              index: choice.index
+            };
+          }
+        } else if (Array.isArray(delta.content)) {
+          for (const chunk of delta.content) {
+            if (chunk.type === "text" && "text" in chunk) {
+              aggregatedParts.push({ type: "text", text: chunk.text });
+              yield {
+                type: "message_delta",
+                delta: { type: "text", text: chunk.text },
+                index: choice.index
+              };
+            }
+          }
+        }
+        if (delta.toolCalls) {
+          let localIndex = 0;
+          for (const call of delta.toolCalls) {
+            const toolCall = this.fromMistralToolCall(call, localIndex);
+            aggregatedToolCalls.push(toolCall);
+            yield {
+              type: "tool_call",
+              call: toolCall,
+              index: choice.index
+            };
+            localIndex += 1;
+          }
+        }
+        if (choice.finishReason && choice.finishReason !== "null") {
+          finishReason = choice.finishReason;
+        }
+      }
+      if (event.data.usage) {
+        const usageEntry = this.fromUsage(event.data.usage);
+        if (usageEntry) {
+          usage = usageEntry;
+          yield { type: "usage", usage: usageEntry };
+        }
+      }
+    }
+    const message = {
+      role: "assistant",
+      content: aggregatedParts.length ? aggregatedParts : [{ type: "text", text: "" }]
+    };
+    if (aggregatedToolCalls.length > 0) {
+      message.content = [
+        ...aggregatedToolCalls,
+        ...aggregatedParts.length ? aggregatedParts : []
+      ];
+    }
+    yield {
+      type: "end",
+      response: {
+        message,
+        usage,
+        finishReason: mapFinishReason(finishReason)
+      }
+    };
+  }
+  async countTokens(_messages) {
+    throw new Error("Mistral API does not currently support token counting");
+  }
+  buildChatRequest(messages, options) {
+    const model = options.model ?? this.defaultModel;
+    const mappedMessages = messages.map((message) => this.toMistralMessage(message));
+    const request = {
+      model,
+      messages: mappedMessages
+    };
+    if (options.temperature != null) {
+      request.temperature = options.temperature;
+    }
+    if (options.topP != null) {
+      request.topP = options.topP;
+    }
+    if (options.maxOutputTokens != null) {
+      request.maxTokens = options.maxOutputTokens;
+    }
+    if (options.stopSequences?.length) {
+      request.stop = options.stopSequences.length === 1 ? options.stopSequences[0] : options.stopSequences;
+    }
+    if (options.tools?.length) {
+      request.tools = options.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: typeof tool.inputSchema === "object" && tool.inputSchema !== null ? tool.inputSchema : {}
+        }
+      }));
+    }
+    if (options.responseFormat === "json") {
+      request.responseFormat = { type: "json_object" };
+    }
+    return request;
+  }
+  buildLLMResponse(response) {
+    const firstChoice = response.choices[0];
+    if (!firstChoice) {
+      return {
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "" }]
+        },
+        usage: this.fromUsage(response.usage),
+        raw: response
+      };
+    }
+    const message = this.fromAssistantMessage(firstChoice.message);
+    return {
+      message,
+      usage: this.fromUsage(response.usage),
+      finishReason: mapFinishReason(firstChoice.finishReason),
+      raw: response
+    };
+  }
+  fromUsage(usage) {
+    if (!usage)
+      return;
+    return {
+      promptTokens: usage.promptTokens ?? 0,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0
+    };
+  }
+  fromAssistantMessage(message) {
+    const parts = [];
+    if (typeof message.content === "string") {
+      parts.push({ type: "text", text: message.content });
+    } else if (Array.isArray(message.content)) {
+      message.content.forEach((chunk) => {
+        if (chunk.type === "text" && "text" in chunk) {
+          parts.push({ type: "text", text: chunk.text });
+        }
+      });
+    }
+    const toolCalls = message.toolCalls?.map((call, index) => this.fromMistralToolCall(call, index)) ?? [];
+    if (toolCalls.length > 0) {
+      parts.splice(0, 0, ...toolCalls);
+    }
+    if (parts.length === 0) {
+      parts.push({ type: "text", text: "" });
+    }
+    return {
+      role: "assistant",
+      content: parts
+    };
+  }
+  fromMistralToolCall(call, index) {
+    const args = typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments);
+    return {
+      type: "tool-call",
+      id: call.id ?? `tool-call-${index}`,
+      name: call.function.name,
+      arguments: args
+    };
+  }
+  toMistralMessage(message) {
+    const textContent = this.extractText(message.content);
+    const toolCalls = this.extractToolCalls(message);
+    switch (message.role) {
+      case "system":
+        return {
+          role: "system",
+          content: textContent ?? ""
+        };
+      case "user":
+        return {
+          role: "user",
+          content: textContent ?? ""
+        };
+      case "assistant":
+        return {
+          role: "assistant",
+          content: toolCalls.length > 0 ? null : textContent ?? "",
+          toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+        };
+      case "tool":
+        return {
+          role: "tool",
+          content: textContent ?? "",
+          toolCallId: message.toolCallId ?? toolCalls[0]?.id
+        };
+      default:
+        return {
+          role: "user",
+          content: textContent ?? ""
+        };
+    }
+  }
+  extractText(parts) {
+    const textParts = parts.filter((part) => part.type === "text").map((part) => part.text);
+    if (textParts.length === 0)
+      return null;
+    return textParts.join("");
+  }
+  extractToolCalls(message) {
+    const toolCallParts = message.content.filter((part) => part.type === "tool-call");
+    return toolCallParts.map((call, index) => ({
+      id: call.id ?? `call_${index}`,
+      type: "function",
+      index,
+      function: {
+        name: call.name,
+        arguments: call.arguments
+      }
+    }));
+  }
+}
+function mapFinishReason(reason) {
+  if (!reason)
+    return;
+  const normalized = reason.toLowerCase();
+  switch (normalized) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_call":
+    case "tool_calls":
+      return "tool_call";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return;
+  }
+}
+
+// src/impls/mistral-embedding.ts
+import { Mistral as Mistral2 } from "@mistralai/mistralai";
+
+class MistralEmbeddingProvider {
+  client;
+  defaultModel;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralEmbeddingProvider requires an apiKey");
+    }
+    this.client = options.client ?? new Mistral2({
+      apiKey: options.apiKey,
+      serverURL: options.serverURL
+    });
+    this.defaultModel = options.defaultModel ?? "mistral-embed";
+  }
+  async embedDocuments(documents, options) {
+    if (documents.length === 0)
+      return [];
+    const model = options?.model ?? this.defaultModel;
+    const response = await this.client.embeddings.create({
+      model,
+      inputs: documents.map((doc) => doc.text)
+    });
+    return response.data.map((item, index) => ({
+      id: documents[index]?.id ?? (item.index != null ? `embedding-${item.index}` : `embedding-${index}`),
+      vector: item.embedding ?? [],
+      dimensions: item.embedding?.length ?? 0,
+      model: response.model,
+      metadata: documents[index]?.metadata ? Object.fromEntries(Object.entries(documents[index]?.metadata ?? {}).map(([key, value]) => [key, String(value)])) : undefined
+    }));
+  }
+  async embedQuery(query, options) {
+    const [result] = await this.embedDocuments([{ id: "query", text: query }], options);
+    if (!result) {
+      throw new Error("Failed to compute embedding for query");
+    }
+    return result;
+  }
+}
+
+// src/impls/qdrant-vector.ts
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+class QdrantVectorProvider {
+  client;
+  createCollectionIfMissing;
+  distance;
+  constructor(options) {
+    this.client = options.client ?? new QdrantClient({
+      url: options.url,
+      apiKey: options.apiKey,
+      ...options.clientParams
+    });
+    this.createCollectionIfMissing = options.createCollectionIfMissing ?? true;
+    this.distance = options.distance ?? "Cosine";
+  }
+  async upsert(request) {
+    if (request.documents.length === 0)
+      return;
+    const firstDocument = request.documents[0];
+    if (!firstDocument)
+      return;
+    const vectorSize = firstDocument.vector.length;
+    if (this.createCollectionIfMissing) {
+      await this.ensureCollection(request.collection, vectorSize);
+    }
+    const points = request.documents.map((document) => ({
+      id: document.id,
+      vector: document.vector,
+      payload: {
+        ...document.payload,
+        ...document.namespace ? { namespace: document.namespace } : {},
+        ...document.expiresAt ? { expiresAt: document.expiresAt.toISOString() } : {}
+      }
+    }));
+    await this.client.upsert(request.collection, {
+      wait: true,
+      points
+    });
+  }
+  async search(query) {
+    const results = await this.client.search(query.collection, {
+      vector: query.vector,
+      limit: query.topK,
+      filter: query.filter,
+      score_threshold: query.scoreThreshold,
+      with_payload: true,
+      with_vector: false
+    });
+    return results.map((item) => ({
+      id: String(item.id),
+      score: item.score,
+      payload: item.payload ?? undefined,
+      namespace: typeof item.payload === "object" && item.payload !== null ? item.payload.namespace : undefined
+    }));
+  }
+  async delete(request) {
+    await this.client.delete(request.collection, {
+      wait: true,
+      points: request.ids
+    });
+  }
+  async ensureCollection(collectionName, vectorSize) {
+    try {
+      await this.client.getCollection(collectionName);
+    } catch (_error) {
+      await this.client.createCollection(collectionName, {
+        vectors: {
+          size: vectorSize,
+          distance: this.distance
+        }
+      });
+    }
+  }
+}
+
+// src/impls/supabase-psql.ts
+import { Buffer as Buffer3 } from "node:buffer";
+import { sql as drizzleSql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+class SupabasePostgresProvider {
+  client;
+  db;
+  ownsClient;
+  createDrizzle;
+  constructor(options = {}) {
+    this.createDrizzle = options.createDrizzle ?? ((client) => drizzle(client));
+    if (options.db) {
+      if (!options.client) {
+        throw new Error("SupabasePostgresProvider requires a postgres client when db is provided.");
+      }
+      this.client = options.client;
+      this.db = options.db;
+      this.ownsClient = false;
+      return;
+    }
+    if (options.client) {
+      this.client = options.client;
+      this.ownsClient = false;
+    } else {
+      if (!options.connectionString) {
+        throw new Error("SupabasePostgresProvider requires either a connectionString or a client.");
+      }
+      this.client = postgres(options.connectionString, {
+        max: options.maxConnections,
+        prepare: false,
+        ssl: resolveSslMode(options.sslMode)
+      });
+      this.ownsClient = true;
+    }
+    this.db = this.createDrizzle(this.client);
+  }
+  async query(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    const result = await this.db.execute(query);
+    const rows = asRows(result);
+    return {
+      rows,
+      rowCount: rows.length
+    };
+  }
+  async execute(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    await this.db.execute(query);
+  }
+  async transaction(run) {
+    const transactionResult = this.client.begin(async (transactionClient) => {
+      const transactionalProvider = new SupabasePostgresProvider({
+        client: transactionClient,
+        db: this.createDrizzle(transactionClient),
+        createDrizzle: this.createDrizzle
+      });
+      return run(transactionalProvider);
+    });
+    return transactionResult;
+  }
+  async close() {
+    if (this.ownsClient) {
+      await this.client.end({ timeout: 5 });
+    }
+  }
+}
+function buildParameterizedSql(statement, params) {
+  const segments = [];
+  const pattern = /\$(\d+)/g;
+  let cursor = 0;
+  for (const match of statement.matchAll(pattern)) {
+    const token = match[0];
+    const indexPart = match[1];
+    const start = match.index;
+    if (indexPart == null || start == null)
+      continue;
+    const parameterIndex = Number(indexPart) - 1;
+    if (!Number.isInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= params.length) {
+      throw new Error(`SQL placeholder ${token} is out of bounds for ${params.length} parameter(s).`);
+    }
+    const staticSegment = statement.slice(cursor, start);
+    if (staticSegment.length > 0) {
+      segments.push(drizzleSql.raw(staticSegment));
+    }
+    const parameterValue = params[parameterIndex];
+    if (parameterValue === undefined) {
+      throw new Error(`SQL placeholder ${token} is missing a parameter value.`);
+    }
+    const normalizedValue = normalizeParam(parameterValue);
+    segments.push(drizzleSql`${normalizedValue}`);
+    cursor = start + token.length;
+  }
+  const tailSegment = statement.slice(cursor);
+  if (tailSegment.length > 0) {
+    segments.push(drizzleSql.raw(tailSegment));
+  }
+  if (segments.length === 0) {
+    return drizzleSql.raw("");
+  }
+  return drizzleSql.join(segments);
+}
+function normalizeParam(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer3.from(value);
+  }
+  if (isPlainObject(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function asRows(result) {
+  if (!Array.isArray(result)) {
+    return [];
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (value instanceof Uint8Array) {
+    return false;
+  }
+  return true;
+}
+function resolveSslMode(mode) {
+  switch (mode) {
+    case "allow":
+      return false;
+    case "prefer":
+      return "prefer";
+    case "require":
+    default:
+      return "require";
+  }
+}
+
+// src/impls/supabase-vector.ts
+class SupabaseVectorProvider {
+  database;
+  createTableIfMissing;
+  distanceMetric;
+  quotedSchema;
+  qualifiedTable;
+  collectionIndex;
+  namespaceIndex;
+  ensureTablePromise;
+  constructor(options) {
+    this.database = options.database ?? new SupabasePostgresProvider({
+      connectionString: options.connectionString,
+      maxConnections: options.maxConnections,
+      sslMode: options.sslMode
+    });
+    this.createTableIfMissing = options.createTableIfMissing ?? true;
+    this.distanceMetric = options.distanceMetric ?? "cosine";
+    const schema = sanitizeIdentifier(options.schema ?? "public", "schema");
+    const table = sanitizeIdentifier(options.table ?? "contractspec_vectors", "table");
+    this.quotedSchema = quoteIdentifier(schema);
+    this.qualifiedTable = `${this.quotedSchema}.${quoteIdentifier(table)}`;
+    this.collectionIndex = quoteIdentifier(`${table}_collection_idx`);
+    this.namespaceIndex = quoteIdentifier(`${table}_namespace_idx`);
+  }
+  async upsert(request) {
+    if (request.documents.length === 0) {
+      return;
+    }
+    if (this.createTableIfMissing) {
+      await this.ensureTable();
+    }
+    for (const document of request.documents) {
+      await this.database.execute(`INSERT INTO ${this.qualifiedTable}
+          (collection, id, embedding, payload, namespace, expires_at, updated_at)
+         VALUES ($1, $2, $3::vector, $4::jsonb, $5, $6, now())
+         ON CONFLICT (collection, id)
+         DO UPDATE SET
+           embedding = EXCLUDED.embedding,
+           payload = EXCLUDED.payload,
+           namespace = EXCLUDED.namespace,
+           expires_at = EXCLUDED.expires_at,
+           updated_at = now();`, [
+        request.collection,
+        document.id,
+        toVectorLiteral(document.vector),
+        document.payload ? JSON.stringify(document.payload) : null,
+        document.namespace ?? null,
+        document.expiresAt ?? null
+      ]);
+    }
+  }
+  async search(query) {
+    const operator = this.distanceOperator;
+    const results = await this.database.query(`SELECT
+         id,
+         payload,
+         namespace,
+         (embedding ${operator} $3::vector) AS distance
+       FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND ($2::text IS NULL OR namespace = $2)
+         AND (expires_at IS NULL OR expires_at > now())
+         AND ($4::jsonb IS NULL OR payload @> $4::jsonb)
+       ORDER BY embedding ${operator} $3::vector
+       LIMIT $5;`, [
+      query.collection,
+      query.namespace ?? null,
+      toVectorLiteral(query.vector),
+      query.filter ? JSON.stringify(query.filter) : null,
+      query.topK
+    ]);
+    const mapped = results.rows.map((row) => {
+      const distance = Number(row.distance);
+      return {
+        id: row.id,
+        score: distanceToScore(distance, this.distanceMetric),
+        payload: isRecord(row.payload) ? row.payload : undefined,
+        namespace: row.namespace ?? undefined
+      };
+    });
+    const scoreThreshold = query.scoreThreshold;
+    if (scoreThreshold == null) {
+      return mapped;
+    }
+    return mapped.filter((result) => result.score >= scoreThreshold);
+  }
+  async delete(request) {
+    if (request.ids.length === 0) {
+      return;
+    }
+    const params = [
+      request.collection,
+      request.ids,
+      request.namespace ?? null
+    ];
+    await this.database.execute(`DELETE FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND id = ANY($2::text[])
+         AND ($3::text IS NULL OR namespace = $3);`, params);
+  }
+  async ensureTable() {
+    if (!this.ensureTablePromise) {
+      this.ensureTablePromise = this.createTable();
+    }
+    await this.ensureTablePromise;
+  }
+  async createTable() {
+    await this.database.execute("CREATE EXTENSION IF NOT EXISTS vector;");
+    await this.database.execute(`CREATE SCHEMA IF NOT EXISTS ${this.quotedSchema};`);
+    await this.database.execute(`CREATE TABLE IF NOT EXISTS ${this.qualifiedTable} (
+         collection text NOT NULL,
+         id text NOT NULL,
+         embedding vector NOT NULL,
+         payload jsonb,
+         namespace text,
+         expires_at timestamptz,
+         created_at timestamptz NOT NULL DEFAULT now(),
+         updated_at timestamptz NOT NULL DEFAULT now(),
+         PRIMARY KEY (collection, id)
+       );`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.collectionIndex}
+         ON ${this.qualifiedTable} (collection);`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.namespaceIndex}
+         ON ${this.qualifiedTable} (namespace);`);
+  }
+  get distanceOperator() {
+    switch (this.distanceMetric) {
+      case "l2":
+        return "<->";
+      case "inner_product":
+        return "<#>";
+      case "cosine":
+      default:
+        return "<=>";
+    }
+  }
+}
+function sanitizeIdentifier(value, label) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new Error(`SupabaseVectorProvider ${label} "${value}" is invalid.`);
+  }
+  return value;
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function toVectorLiteral(vector) {
+  if (vector.length === 0) {
+    throw new Error("Supabase vectors must contain at least one dimension.");
+  }
+  for (const value of vector) {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Supabase vectors must be finite numbers. Found "${value}".`);
+    }
+  }
+  return `[${vector.join(",")}]`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function distanceToScore(distance, metric) {
+  switch (metric) {
+    case "inner_product":
+      return -distance;
+    case "l2":
+      return 1 / (1 + distance);
+    case "cosine":
+    default:
+      return 1 - distance;
+  }
+}
+
+// src/impls/stripe-payments.ts
+import Stripe from "stripe";
+var API_VERSION = "2026-01-28.clover";
+
+class StripePaymentsProvider {
+  stripe;
+  constructor(options) {
+    this.stripe = options.stripe ?? new Stripe(options.apiKey, {
+      apiVersion: API_VERSION
+    });
+  }
+  async createCustomer(input) {
+    const customer = await this.stripe.customers.create({
+      email: input.email,
+      name: input.name,
+      description: input.description,
+      metadata: input.metadata
+    });
+    return this.toCustomer(customer);
+  }
+  async getCustomer(customerId) {
+    const customer = await this.stripe.customers.retrieve(customerId);
+    if (customer.deleted)
+      return null;
+    return this.toCustomer(customer);
+  }
+  async createPaymentIntent(input) {
+    const intent = await this.stripe.paymentIntents.create({
+      amount: input.amount.amount,
+      currency: input.amount.currency,
+      customer: input.customerId,
+      description: input.description,
+      capture_method: input.captureMethod ?? "automatic",
+      confirmation_method: input.confirmationMethod ?? "automatic",
+      automatic_payment_methods: { enabled: true },
+      metadata: input.metadata,
+      return_url: input.returnUrl,
+      statement_descriptor: input.statementDescriptor
+    });
+    return this.toPaymentIntent(intent);
+  }
+  async capturePayment(paymentIntentId, input) {
+    const intent = await this.stripe.paymentIntents.capture(paymentIntentId, input?.amount ? { amount_to_capture: input.amount.amount } : undefined);
+    return this.toPaymentIntent(intent);
+  }
+  async cancelPaymentIntent(paymentIntentId) {
+    const intent = await this.stripe.paymentIntents.cancel(paymentIntentId);
+    return this.toPaymentIntent(intent);
+  }
+  async refundPayment(input) {
+    const refund = await this.stripe.refunds.create({
+      payment_intent: input.paymentIntentId,
+      amount: input.amount?.amount,
+      reason: mapRefundReason(input.reason),
+      metadata: input.metadata
+    });
+    const paymentIntentId = typeof refund.payment_intent === "string" ? refund.payment_intent : refund.payment_intent?.id ?? "";
+    return {
+      id: refund.id,
+      paymentIntentId,
+      amount: {
+        amount: refund.amount ?? 0,
+        currency: refund.currency?.toUpperCase() ?? "USD"
+      },
+      status: mapRefundStatus(refund.status),
+      reason: refund.reason ?? undefined,
+      metadata: this.toMetadata(refund.metadata),
+      createdAt: refund.created ? new Date(refund.created * 1000) : undefined
+    };
+  }
+  async listInvoices(query) {
+    const requestedStatus = query?.status?.[0];
+    const stripeStatus = requestedStatus && requestedStatus !== "deleted" ? requestedStatus : undefined;
+    const response = await this.stripe.invoices.list({
+      customer: query?.customerId,
+      status: stripeStatus,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((invoice) => this.toInvoice(invoice));
+  }
+  async listTransactions(query) {
+    const response = await this.stripe.charges.list({
+      customer: query?.customerId,
+      payment_intent: query?.paymentIntentId,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((charge) => ({
+      id: charge.id,
+      paymentIntentId: typeof charge.payment_intent === "string" ? charge.payment_intent : charge.payment_intent?.id,
+      amount: {
+        amount: charge.amount,
+        currency: charge.currency?.toUpperCase() ?? "USD"
+      },
+      type: "capture",
+      status: mapChargeStatus(charge.status),
+      description: charge.description ?? undefined,
+      createdAt: new Date(charge.created * 1000),
+      metadata: this.mergeMetadata(this.toMetadata(charge.metadata), {
+        balanceTransaction: typeof charge.balance_transaction === "string" ? charge.balance_transaction : undefined
+      })
+    }));
+  }
+  toCustomer(customer) {
+    const metadata = this.toMetadata(customer.metadata);
+    const updatedAtValue = metadata?.updatedAt;
+    return {
+      id: customer.id,
+      email: customer.email ?? undefined,
+      name: customer.name ?? undefined,
+      metadata,
+      createdAt: customer.created ? new Date(customer.created * 1000) : undefined,
+      updatedAt: updatedAtValue ? new Date(updatedAtValue) : undefined
+    };
+  }
+  toPaymentIntent(intent) {
+    const metadata = this.toMetadata(intent.metadata);
+    return {
+      id: intent.id,
+      amount: this.toMoney(intent.amount_received ?? intent.amount ?? 0, intent.currency),
+      status: mapPaymentIntentStatus(intent.status),
+      customerId: typeof intent.customer === "string" ? intent.customer : intent.customer?.id,
+      description: intent.description ?? undefined,
+      clientSecret: intent.client_secret ?? undefined,
+      metadata,
+      createdAt: new Date(intent.created * 1000),
+      updatedAt: intent.canceled_at != null ? new Date(intent.canceled_at * 1000) : new Date(intent.created * 1000)
+    };
+  }
+  toInvoice(invoice) {
+    const metadata = this.toMetadata(invoice.metadata);
+    return {
+      id: invoice.id,
+      number: invoice.number ?? undefined,
+      status: invoice.status ?? "draft",
+      amountDue: this.toMoney(invoice.amount_due ?? 0, invoice.currency),
+      amountPaid: this.toMoney(invoice.amount_paid ?? 0, invoice.currency),
+      customerId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id,
+      dueDate: invoice.due_date ? new Date(invoice.due_date * 1000) : undefined,
+      hostedInvoiceUrl: invoice.hosted_invoice_url ?? undefined,
+      metadata,
+      createdAt: invoice.created ? new Date(invoice.created * 1000) : undefined,
+      updatedAt: invoice.status_transitions?.finalized_at ? new Date(invoice.status_transitions.finalized_at * 1000) : undefined
+    };
+  }
+  toMoney(amount, currency) {
+    return {
+      amount,
+      currency: currency?.toUpperCase() ?? "USD"
+    };
+  }
+  toMetadata(metadata) {
+    if (!metadata)
+      return;
+    const entries = Object.entries(metadata).filter((entry) => typeof entry[1] === "string");
+    if (entries.length === 0)
+      return;
+    return Object.fromEntries(entries);
+  }
+  mergeMetadata(base, extras) {
+    const filteredExtras = Object.entries(extras).filter((entry) => typeof entry[1] === "string");
+    if (!base && filteredExtras.length === 0) {
+      return;
+    }
+    return {
+      ...base ?? {},
+      ...Object.fromEntries(filteredExtras)
+    };
+  }
+}
+function mapRefundReason(reason) {
+  if (!reason)
+    return;
+  const allowed = [
+    "duplicate",
+    "fraudulent",
+    "requested_by_customer"
+  ];
+  return allowed.includes(reason) ? reason : undefined;
+}
+function mapPaymentIntentStatus(status) {
+  switch (status) {
+    case "requires_payment_method":
+      return "requires_payment_method";
+    case "requires_confirmation":
+      return "requires_confirmation";
+    case "requires_action":
+    case "requires_capture":
+      return "requires_action";
+    case "processing":
+      return "processing";
+    case "succeeded":
+      return "succeeded";
+    case "canceled":
+      return "canceled";
+    default:
+      return "requires_payment_method";
+  }
+}
+function mapRefundStatus(status) {
+  switch (status) {
+    case "pending":
+    case "succeeded":
+    case "failed":
+    case "canceled":
+      return status;
+    default:
+      return "pending";
+  }
+}
+function mapChargeStatus(status) {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return "pending";
+    case "succeeded":
+      return "succeeded";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+
+// src/impls/postmark-email.ts
+import { ServerClient } from "postmark";
+
+class PostmarkEmailProvider {
+  client;
+  defaultFromEmail;
+  messageStream;
+  constructor(options) {
+    this.client = options.client ?? new ServerClient(options.serverToken, {
+      useHttps: true
+    });
+    this.defaultFromEmail = options.defaultFromEmail;
+    this.messageStream = options.messageStream;
+  }
+  async sendEmail(message) {
+    const request = {
+      From: formatAddress2(message.from) ?? this.defaultFromEmail,
+      To: message.to.map((addr) => formatAddress2(addr)).join(", "),
+      Cc: message.cc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
+      Bcc: message.bcc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
+      ReplyTo: message.replyTo ? formatAddress2(message.replyTo) : undefined,
+      Subject: message.subject,
+      TextBody: message.textBody,
+      HtmlBody: message.htmlBody,
+      Headers: message.headers ? Object.entries(message.headers).map(([name, value]) => ({
+        Name: name,
+        Value: value
+      })) : undefined,
+      MessageStream: this.messageStream,
+      Attachments: buildAttachments(message)
+    };
+    const response = await this.client.sendEmail(request);
+    return {
+      id: response.MessageID,
+      providerMessageId: response.MessageID,
+      queuedAt: new Date(response.SubmittedAt ?? new Date().toISOString())
+    };
+  }
+}
+function formatAddress2(address) {
+  if (address.name) {
+    return `"${address.name}" <${address.email}>`;
+  }
+  return address.email;
+}
+function buildAttachments(message) {
+  if (!message.attachments?.length)
+    return;
+  return message.attachments.filter((attachment) => attachment.data).map((attachment) => ({
+    Name: attachment.filename,
+    Content: Buffer.from(attachment.data ?? new Uint8Array).toString("base64"),
+    ContentType: attachment.contentType,
+    ContentID: null,
+    ContentLength: attachment.sizeBytes,
+    Disposition: "attachment"
+  }));
+}
+
+// src/impls/posthog-reader.ts
+class PosthogAnalyticsReader {
+  projectId;
+  client;
+  constructor(options) {
+    this.projectId = options.projectId;
+    this.client = options.client;
+  }
+  async queryHogQL(input) {
+    const projectId = resolveProjectId(undefined, this.projectId);
+    const response = await this.client.request({
+      method: "POST",
+      path: `/api/projects/${projectId}/query`,
+      body: {
+        query: {
+          kind: "HogQLQuery",
+          query: input.query,
+          values: input.values
+        }
+      }
+    });
+    return response.data;
+  }
+  async getEvents(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/events/`,
+      query: {
+        event: input.event ?? resolveSingleEvent(input.events),
+        events: resolveEventList(input.events),
+        distinct_id: input.distinctId,
+        order_by: input.orderBy,
+        limit: input.limit,
+        offset: input.offset,
+        properties: input.properties ? JSON.stringify(input.properties) : undefined,
+        ...buildEventDateQuery(input.dateRange)
+      }
+    });
+    return response.data;
+  }
+  async getPersons(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/persons/`,
+      query: {
+        cohort_id: input.cohortId,
+        search: input.search,
+        limit: input.limit,
+        offset: input.offset,
+        properties: input.properties ? JSON.stringify(input.properties) : undefined
+      }
+    });
+    return response.data;
+  }
+  async getInsights(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/insights/`,
+      query: {
+        insight: input.insightType,
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getInsightResult(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/insights/${input.insightId}/`
+    });
+    return response.data;
+  }
+  async getCohorts(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/cohorts/`,
+      query: {
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getFeatureFlags(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/feature_flags/`,
+      query: {
+        active: input.active,
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getAnnotations(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/annotations/`,
+      query: {
+        limit: input.limit,
+        offset: input.offset,
+        ...buildAnnotationDateQuery(input.dateRange)
+      }
+    });
+    return response.data;
+  }
+}
+function resolveProjectId(inputProjectId, defaultProjectId) {
+  const projectId = inputProjectId ?? defaultProjectId;
+  if (!projectId) {
+    throw new Error("PostHog projectId is required for API reads.");
+  }
+  return projectId;
+}
+function resolveSingleEvent(events) {
+  if (!events || events.length !== 1)
+    return;
+  return events[0];
+}
+function resolveEventList(events) {
+  if (!events || events.length <= 1)
+    return;
+  return events.join(",");
+}
+function buildEventDateQuery(range) {
+  const after = formatDate(range?.from);
+  const before = formatDate(range?.to);
+  return {
+    after,
+    before,
+    timezone: range?.timezone
+  };
+}
+function buildAnnotationDateQuery(range) {
+  const dateFrom = formatDate(range?.from);
+  const dateTo = formatDate(range?.to);
+  return {
+    date_from: dateFrom,
+    date_to: dateTo,
+    timezone: range?.timezone
+  };
+}
+function formatDate(value) {
+  if (!value)
+    return;
+  return typeof value === "string" ? value : value.toISOString();
+}
+
+// src/impls/posthog-utils.ts
+function normalizeHost(host) {
+  return host.replace(/\/$/, "");
+}
+function buildUrl(host, path, query) {
+  if (/^https?:\/\//.test(path)) {
+    return appendQuery(path, query);
+  }
+  const normalizedPath = path.replace(/^\/+/, "");
+  return appendQuery(`${host}/${normalizedPath}`, query);
+}
+function appendQuery(url, query) {
+  if (!query)
+    return url;
+  const params = new URLSearchParams;
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === undefined)
+      return;
+    params.set(key, String(value));
+  });
+  const suffix = params.toString();
+  return suffix ? `${url}?${suffix}` : url;
+}
+function parseJson(value) {
+  if (!value)
+    return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/impls/posthog.ts
+import { PostHog } from "posthog-node";
+var DEFAULT_POSTHOG_HOST = "https://app.posthog.com";
+
+class PosthogAnalyticsProvider {
+  host;
+  projectId;
+  projectApiKey;
+  personalApiKey;
+  mcpUrl;
+  fetchFn;
+  client;
+  reader;
+  constructor(options) {
+    this.host = normalizeHost(options.host ?? DEFAULT_POSTHOG_HOST);
+    this.projectId = options.projectId;
+    this.projectApiKey = options.projectApiKey;
+    this.personalApiKey = options.personalApiKey;
+    this.mcpUrl = options.mcpUrl;
+    this.fetchFn = options.fetch ?? fetch;
+    this.client = options.client ?? (options.projectApiKey ? new PostHog(options.projectApiKey, {
+      host: this.host,
+      requestTimeout: options.requestTimeoutMs ?? 1e4
+    }) : undefined);
+    this.reader = new PosthogAnalyticsReader({
+      projectId: this.projectId,
+      client: { request: this.request.bind(this) }
+    });
+  }
+  async capture(event) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for capture.");
+    }
+    await this.client.capture({
+      distinctId: event.distinctId,
+      event: event.event,
+      properties: event.properties,
+      timestamp: event.timestamp,
+      groups: event.groups
+    });
+  }
+  async identify(input) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for identify.");
+    }
+    await this.client.identify({
+      distinctId: input.distinctId,
+      properties: {
+        ...input.properties ? { $set: input.properties } : {},
+        ...input.setOnce ? { $set_once: input.setOnce } : {}
+      }
+    });
+  }
+  async queryHogQL(input) {
+    return this.reader.queryHogQL(input);
+  }
+  async getEvents(input) {
+    return this.reader.getEvents(input);
+  }
+  async getPersons(input) {
+    return this.reader.getPersons(input);
+  }
+  async getInsights(input) {
+    return this.reader.getInsights(input);
+  }
+  async getInsightResult(input) {
+    return this.reader.getInsightResult(input);
+  }
+  async getCohorts(input) {
+    return this.reader.getCohorts(input);
+  }
+  async getFeatureFlags(input) {
+    return this.reader.getFeatureFlags(input);
+  }
+  async getAnnotations(input) {
+    return this.reader.getAnnotations(input);
+  }
+  async request(request) {
+    if (!this.personalApiKey) {
+      throw new Error("PostHog personalApiKey is required for API requests.");
+    }
+    const url = buildUrl(this.host, request.path, request.query);
+    const response = await this.fetchFn(url, {
+      method: request.method,
+      headers: {
+        Authorization: `Bearer ${this.personalApiKey}`,
+        "Content-Type": "application/json",
+        ...request.headers ?? {}
+      },
+      body: request.body ? JSON.stringify(request.body) : undefined
+    });
+    const text = await response.text();
+    const data = parseJson(text);
+    return {
+      status: response.status,
+      data,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+  }
+  async callMcpTool(call) {
+    if (!this.mcpUrl) {
+      throw new Error("PostHog MCP URL is not configured.");
+    }
+    const response = await this.fetchFn(this.mcpUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: call.name,
+          arguments: call.arguments ?? {}
+        }
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`PostHog MCP error (${response.status}): ${body}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message ?? "PostHog MCP error");
+    }
+    return result.result ?? null;
+  }
+}
+
+// src/impls/twilio-sms.ts
+import Twilio from "twilio";
+
+class TwilioSmsProvider {
+  client;
+  fromNumber;
+  constructor(options) {
+    this.client = options.client ?? Twilio(options.accountSid, options.authToken);
+    this.fromNumber = options.fromNumber;
+  }
+  async sendSms(input) {
+    const message = await this.client.messages.create({
+      to: input.to,
+      from: input.from ?? this.fromNumber,
+      body: input.body
+    });
+    return {
+      id: message.sid,
+      to: message.to ?? input.to,
+      from: message.from ?? input.from ?? this.fromNumber ?? "",
+      body: message.body ?? input.body,
+      status: mapStatus(message.status),
+      sentAt: message.dateCreated ? new Date(message.dateCreated) : undefined,
+      deliveredAt: message.status === "delivered" && message.dateUpdated ? new Date(message.dateUpdated) : undefined,
+      price: message.price ? Number(message.price) : undefined,
+      priceCurrency: message.priceUnit ?? undefined,
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined
+    };
+  }
+  async getDeliveryStatus(messageId) {
+    const message = await this.client.messages(messageId).fetch();
+    return {
+      status: mapStatus(message.status),
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined,
+      updatedAt: message.dateUpdated ? new Date(message.dateUpdated) : new Date
+    };
+  }
+}
+function mapStatus(status) {
+  switch (status) {
+    case "queued":
+    case "accepted":
+    case "scheduled":
+      return "queued";
+    case "sending":
+    case "processing":
+      return "sending";
+    case "sent":
+      return "sent";
+    case "delivered":
+      return "delivered";
+    case "undelivered":
+      return "undelivered";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "queued";
+  }
+}
+
+// src/impls/powens-client.ts
+import { URL } from "node:url";
+var POWENS_BASE_URL = {
+  sandbox: "https://api-sandbox.powens.com/v2",
+  production: "https://api.powens.com/v2"
+};
+
+class PowensClientError extends Error {
+  status;
+  code;
+  requestId;
+  response;
+  constructor(message, status, code, requestId, response) {
+    super(message);
+    this.name = "PowensClientError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+    this.response = response;
+  }
+}
+
+class PowensClient {
+  clientId;
+  clientSecret;
+  apiKey;
+  fetchImpl;
+  logger;
+  defaultTimeoutMs;
+  token;
+  baseUrl;
+  constructor(options) {
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.logger = options.logger;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 15000;
+    this.baseUrl = options.baseUrl ?? POWENS_BASE_URL[options.environment] ?? POWENS_BASE_URL.production;
+  }
+  async listAccounts(params) {
+    const searchParams = {
+      cursor: params.cursor,
+      limit: params.limit,
+      include_balances: params.includeBalances,
+      institution_uuid: params.institutionUuid
+    };
+    const response = await this.request({
+      method: "GET",
+      path: `/users/${encodeURIComponent(params.userUuid)}/accounts`,
+      searchParams
+    });
+    return response;
+  }
+  async getAccount(accountUuid) {
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(accountUuid)}`
+    });
+  }
+  async listTransactions(params) {
+    const searchParams = {
+      cursor: params.cursor,
+      limit: params.limit,
+      from: params.from,
+      to: params.to,
+      include_pending: params.includePending
+    };
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(params.accountUuid)}/transactions`,
+      searchParams
+    });
+  }
+  async getBalances(accountUuid) {
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(accountUuid)}/balances`
+    });
+  }
+  async getConnectionStatus(connectionUuid) {
+    return this.request({
+      method: "GET",
+      path: `/connections/${encodeURIComponent(connectionUuid)}`
+    });
+  }
+  async request(options) {
+    const url = new URL(options.path, this.baseUrl);
+    if (options.searchParams) {
+      for (const [key, value] of Object.entries(options.searchParams)) {
+        if (value === undefined || value === null)
+          continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (!options.skipAuth) {
+      const token = await this.ensureAccessToken();
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? this.defaultTimeoutMs);
+    try {
+      const response = await this.fetchImpl(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+        signal: controller.signal
+      });
+      const requestId = response.headers.get("x-request-id") ?? undefined;
+      if (!response.ok) {
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {}
+        const errorObject = typeof errorBody === "object" && errorBody !== null ? errorBody : undefined;
+        const message = typeof errorObject?.message === "string" ? errorObject.message : `Powens API request failed with status ${response.status}`;
+        const code = typeof errorObject?.code === "string" ? errorObject.code : undefined;
+        throw new PowensClientError(message, response.status, code, requestId, errorBody);
+      }
+      if (response.status === 204) {
+        return;
+      }
+      try {
+        return await response.json();
+      } catch (error) {
+        this.logger?.error?.("[PowensClient] Failed to parse JSON response", error);
+        throw new PowensClientError("Failed to parse Powens response payload as JSON", response.status, undefined, requestId);
+      }
+    } catch (error) {
+      if (error instanceof PowensClientError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new PowensClientError(`Powens API request timed out after ${options.timeoutMs ?? this.defaultTimeoutMs}ms`, 408);
+      }
+      this.logger?.error?.("[PowensClient] Request failed", error);
+      throw new PowensClientError(error.message ?? "Powens API request failed", 500);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async ensureAccessToken() {
+    if (this.token && Date.now() < this.token.expiresAt - 5000) {
+      return this.token.accessToken;
+    }
+    this.token = await this.fetchAccessToken();
+    return this.token.accessToken;
+  }
+  async fetchAccessToken() {
+    const url = new URL("/oauth/token", this.baseUrl);
+    const basicAuth = Buffer.from(`${this.clientId}:${this.clientSecret}`, "utf-8").toString("base64");
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${basicAuth}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: new URLSearchParams({
+        grant_type: "client_credentials"
+      }).toString()
+    });
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {}
+      const errorObject = typeof errorBody === "object" && errorBody !== null ? errorBody : undefined;
+      const message = typeof errorObject?.error_description === "string" ? errorObject.error_description : "Failed to obtain Powens access token";
+      throw new PowensClientError(message, response.status, undefined, undefined, errorBody);
+    }
+    const payload = await response.json();
+    const expiresAt = Date.now() + payload.expires_in * 1000;
+    this.logger?.debug?.("[PowensClient] Received access token", {
+      expiresIn: payload.expires_in
+    });
+    return {
+      accessToken: payload.access_token,
+      expiresAt,
+      scope: payload.scope
+    };
+  }
+}
+
+// src/impls/powens-openbanking.ts
+class PowensOpenBankingProvider {
+  client;
+  logger;
+  constructor(options) {
+    this.client = new PowensClient(options);
+    this.logger = options.logger;
+  }
+  async listAccounts(params) {
+    if (!params.userId) {
+      throw new PowensClientError("Powens account listing requires the upstream userId mapped to Powens user UUID.", 400);
+    }
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const response = await this.client.listAccounts({
+        userUuid: params.userId,
+        cursor: params.cursor,
+        limit: params.pageSize,
+        includeBalances: params.includeBalances,
+        institutionUuid: params.institutionId
+      });
+      return {
+        accounts: response.accounts.map((account) => this.mapAccount(account, context)),
+        nextCursor: response.pagination?.nextCursor,
+        hasMore: response.pagination?.hasMore
+      };
+    } catch (error) {
+      this.handleError("listAccounts", error);
+    }
+  }
+  async getAccountDetails(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const account = await this.client.getAccount(params.accountId);
+      return this.mapAccountDetails(account, context);
+    } catch (error) {
+      this.handleError("getAccountDetails", error);
+    }
+  }
+  async listTransactions(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const response = await this.client.listTransactions({
+        accountUuid: params.accountId,
+        cursor: params.cursor,
+        limit: params.pageSize,
+        from: params.from,
+        to: params.to,
+        includePending: params.includePending
+      });
+      return {
+        transactions: response.transactions.map((transaction) => this.mapTransaction(transaction, context)),
+        nextCursor: response.pagination?.nextCursor,
+        hasMore: response.pagination?.hasMore
+      };
+    } catch (error) {
+      this.handleError("listTransactions", error);
+    }
+  }
+  async getBalances(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const balances = await this.client.getBalances(params.accountId);
+      return balances.filter((balance) => params.balanceTypes?.length ? params.balanceTypes.includes(String(balance.type)) : true).map((balance) => this.mapBalance(balance, context));
+    } catch (error) {
+      this.handleError("getBalances", error);
+    }
+  }
+  async getConnectionStatus(params) {
+    try {
+      const status = await this.client.getConnectionStatus(params.connectionId);
+      return {
+        connectionId: params.connectionId,
+        tenantId: params.tenantId,
+        status: this.mapConnectionStatus(status.status),
+        lastCheckedAt: status.lastAttemptAt,
+        errorCode: status.errorCode,
+        errorMessage: status.errorMessage,
+        details: status.metadata
+      };
+    } catch (error) {
+      this.handleError("getConnectionStatus", error);
+    }
+  }
+  mapAccount(account, context) {
+    return {
+      id: account.uuid,
+      externalId: account.reference ?? account.uuid,
+      tenantId: context.tenantId,
+      connectionId: context.connectionId,
+      userId: account.userUuid,
+      displayName: account.name,
+      institutionId: account.institution.id,
+      institutionName: account.institution.name,
+      institutionLogoUrl: account.institution.logoUrl,
+      accountType: account.type ?? "unknown",
+      iban: account.iban,
+      bic: account.bic,
+      currency: account.currency ?? "EUR",
+      accountNumberMasked: account.metadata?.account_number_masked,
+      ownership: this.mapOwnership(account.metadata?.ownership),
+      status: this.mapAccountStatus(account.status),
+      lastSyncedAt: account.metadata?.last_sync_at,
+      metadata: account.metadata
+    };
+  }
+  mapAccountDetails(account, context) {
+    return {
+      ...this.mapAccount(account, context),
+      productCode: account.metadata?.product_code,
+      openedAt: account.metadata?.opened_at,
+      closedAt: account.metadata?.closed_at,
+      availableBalance: account.availableBalance ?? undefined,
+      currentBalance: account.balance ?? undefined,
+      creditLimit: account.metadata?.credit_limit,
+      customFields: account.metadata
+    };
+  }
+  mapTransaction(transaction, context) {
+    return {
+      id: transaction.uuid,
+      externalId: transaction.uuid,
+      tenantId: context.tenantId,
+      accountId: transaction.accountUuid,
+      connectionId: context.connectionId,
+      amount: transaction.amount,
+      currency: transaction.currency,
+      direction: transaction.direction === "credit" ? "credit" : "debit",
+      description: transaction.description ?? transaction.rawLabel,
+      bookingDate: transaction.bookingDate,
+      valueDate: transaction.valueDate,
+      postedAt: transaction.bookingDate,
+      category: transaction.category,
+      rawCategory: transaction.rawLabel,
+      merchantName: transaction.merchantName,
+      merchantCategoryCode: transaction.merchantCategoryCode,
+      counterpartyName: transaction.counterpartyName,
+      counterpartyAccount: transaction.counterpartyAccount,
+      reference: transaction.metadata?.reference,
+      status: this.mapTransactionStatus(transaction.status),
+      metadata: transaction.metadata
+    };
+  }
+  mapBalance(balance, context) {
+    return {
+      accountId: balance.accountUuid,
+      connectionId: context.connectionId,
+      tenantId: context.tenantId,
+      type: balance.type ?? "current",
+      currency: balance.currency ?? "EUR",
+      amount: balance.amount,
+      lastUpdatedAt: balance.updatedAt,
+      metadata: balance.metadata
+    };
+  }
+  toContext(tenantId, connectionId) {
+    return { tenantId, connectionId };
+  }
+  mapOwnership(value) {
+    switch (value?.toLowerCase()) {
+      case "individual":
+      case "personal":
+        return "individual";
+      case "joint":
+        return "joint";
+      case "business":
+      case "corporate":
+        return "business";
+      default:
+        return "unknown";
+    }
+  }
+  mapAccountStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "active":
+      case "enabled":
+        return "active";
+      case "disabled":
+      case "inactive":
+        return "inactive";
+      case "closed":
+        return "closed";
+      case "suspended":
+        return "suspended";
+      default:
+        return "active";
+    }
+  }
+  mapTransactionStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "pending":
+      case "authorised":
+        return "pending";
+      case "booked":
+      case "posted":
+        return "booked";
+      case "cancelled":
+      case "rejected":
+        return "cancelled";
+      default:
+        return "booked";
+    }
+  }
+  mapConnectionStatus(status) {
+    switch (status) {
+      case "healthy":
+        return "healthy";
+      case "pending":
+        return "degraded";
+      case "error":
+        return "error";
+      case "revoked":
+        return "disconnected";
+      default:
+        return "degraded";
+    }
+  }
+  handleError(operation, error) {
+    if (error instanceof PowensClientError) {
+      this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed`, {
+        status: error.status,
+        code: error.code,
+        requestId: error.requestId,
+        message: error.message
+      });
+      throw error;
+    }
+    this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed with unexpected error`, error);
+    throw error instanceof Error ? error : new Error(`Powens operation "${operation}" failed`);
+  }
+}
+
+// src/impls/linear.ts
+import { LinearClient } from "@linear/sdk";
+var PRIORITY_MAP = {
+  urgent: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+  none: 0
+};
+
+class LinearProjectManagementProvider {
+  client;
+  defaults;
+  constructor(options) {
+    this.client = options.client ?? new LinearClient({ apiKey: options.apiKey });
+    this.defaults = {
+      teamId: options.teamId,
+      projectId: options.projectId,
+      assigneeId: options.assigneeId,
+      stateId: options.stateId,
+      labelIds: options.labelIds,
+      tagLabelMap: options.tagLabelMap
+    };
+  }
+  async createWorkItem(input) {
+    const teamId = this.defaults.teamId;
+    if (!teamId) {
+      throw new Error("Linear teamId is required to create work items.");
+    }
+    const payload = await this.client.createIssue({
+      teamId,
+      title: input.title,
+      description: input.description,
+      priority: mapPriority(input.priority),
+      estimate: input.estimate,
+      assigneeId: input.assigneeId ?? this.defaults.assigneeId,
+      projectId: input.projectId ?? this.defaults.projectId,
+      stateId: this.defaults.stateId,
+      labelIds: resolveLabelIds(this.defaults, input.tags)
+    });
+    const issue = await payload.issue;
+    const state = issue ? await issue.state : undefined;
+    return {
+      id: issue?.id ?? "",
+      title: issue?.title ?? input.title,
+      url: issue?.url ?? undefined,
+      status: state?.name ?? undefined,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: input.projectId ?? this.defaults.projectId,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
+  }
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
+    }
+    return created;
+  }
+}
+function mapPriority(priority) {
+  if (!priority)
+    return;
+  return PRIORITY_MAP[priority] ?? undefined;
+}
+function resolveLabelIds(defaults, tags) {
+  const labelIds = new Set;
+  (defaults.labelIds ?? []).forEach((id) => labelIds.add(id));
+  if (tags && defaults.tagLabelMap) {
+    tags.forEach((tag) => {
+      const mapped = defaults.tagLabelMap?.[tag];
+      if (mapped)
+        labelIds.add(mapped);
+    });
+  }
+  const merged = [...labelIds];
+  return merged.length > 0 ? merged : undefined;
+}
+
+// src/impls/jira.ts
+import { Buffer as Buffer4 } from "node:buffer";
+
+class JiraProjectManagementProvider {
+  siteUrl;
+  authHeader;
+  defaults;
+  fetchFn;
+  constructor(options) {
+    this.siteUrl = normalizeSiteUrl(options.siteUrl);
+    this.authHeader = buildAuthHeader(options.email, options.apiToken);
+    this.defaults = {
+      projectKey: options.projectKey,
+      issueType: options.issueType,
+      defaultLabels: options.defaultLabels,
+      issueTypeMap: options.issueTypeMap
+    };
+    this.fetchFn = options.fetch ?? fetch;
+  }
+  async createWorkItem(input) {
+    const projectKey = input.projectId ?? this.defaults.projectKey;
+    if (!projectKey) {
+      throw new Error("Jira projectKey is required to create work items.");
+    }
+    const issueType = resolveIssueType(input.type, this.defaults);
+    const description = buildJiraDescription(input.description);
+    const labels = mergeLabels(this.defaults.defaultLabels, input.tags);
+    const priority = mapPriority2(input.priority);
+    const payload = {
+      fields: {
+        project: { key: projectKey },
+        summary: input.title,
+        description,
+        issuetype: { name: issueType },
+        labels,
+        priority: priority ? { name: priority } : undefined,
+        assignee: input.assigneeId ? { accountId: input.assigneeId } : undefined,
+        duedate: input.dueDate ? input.dueDate.toISOString().slice(0, 10) : undefined
+      }
+    };
+    const response = await this.fetchFn(`${this.siteUrl}/rest/api/3/issue`, {
+      method: "POST",
+      headers: {
+        Authorization: this.authHeader,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Jira API error (${response.status}): ${body || response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      id: data.id ?? data.key ?? "",
+      title: input.title,
+      url: data.key ? `${this.siteUrl}/browse/${data.key}` : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: projectKey,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
+  }
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
+    }
+    return created;
+  }
+}
+function normalizeSiteUrl(siteUrl) {
+  return siteUrl.replace(/\/$/, "");
+}
+function buildAuthHeader(email, apiToken) {
+  const token = Buffer4.from(`${email}:${apiToken}`).toString("base64");
+  return `Basic ${token}`;
+}
+function resolveIssueType(type, defaults) {
+  if (type && defaults.issueTypeMap?.[type]) {
+    return defaults.issueTypeMap[type] ?? defaults.issueType ?? "Task";
+  }
+  return defaults.issueType ?? "Task";
+}
+function mapPriority2(priority) {
+  switch (priority) {
+    case "urgent":
+      return "Highest";
+    case "high":
+      return "High";
+    case "medium":
+      return "Medium";
+    case "low":
+      return "Low";
+    case "none":
+    default:
+      return;
+  }
+}
+function mergeLabels(defaults, tags) {
+  const merged = new Set;
+  (defaults ?? []).forEach((label) => merged.add(label));
+  (tags ?? []).forEach((tag) => merged.add(tag));
+  const result = [...merged];
+  return result.length > 0 ? result : undefined;
+}
+function buildJiraDescription(description) {
+  if (!description)
+    return;
+  const lines = description.split(/\r?\n/).filter((line) => line.trim());
+  const content = lines.map((line) => ({
+    type: "paragraph",
+    content: [{ type: "text", text: line }]
+  }));
+  if (content.length === 0)
+    return;
+  return { type: "doc", version: 1, content };
+}
+
+// src/impls/notion.ts
+import { Client } from "@notionhq/client";
+
+class NotionProjectManagementProvider {
+  client;
+  defaults;
+  constructor(options) {
+    this.client = options.client ?? new Client({ auth: options.apiKey });
+    this.defaults = {
+      databaseId: options.databaseId,
+      summaryParentPageId: options.summaryParentPageId,
+      titleProperty: options.titleProperty,
+      statusProperty: options.statusProperty,
+      priorityProperty: options.priorityProperty,
+      tagsProperty: options.tagsProperty,
+      dueDateProperty: options.dueDateProperty,
+      descriptionProperty: options.descriptionProperty
+    };
+  }
+  async createWorkItem(input) {
+    if (input.type === "summary" && this.defaults.summaryParentPageId) {
+      return this.createSummaryPage(input);
+    }
+    const databaseId = this.defaults.databaseId;
+    if (!databaseId) {
+      throw new Error("Notion databaseId is required to create work items.");
+    }
+    const titleProperty = this.defaults.titleProperty ?? "Name";
+    const properties = {
+      [titleProperty]: buildTitleProperty(input.title)
+    };
+    applySelect(properties, this.defaults.statusProperty, input.status);
+    applySelect(properties, this.defaults.priorityProperty, input.priority);
+    applyMultiSelect(properties, this.defaults.tagsProperty, input.tags);
+    applyDate(properties, this.defaults.dueDateProperty, input.dueDate);
+    applyRichText(properties, this.defaults.descriptionProperty, input.description);
+    const page = await this.client.pages.create({
+      parent: { type: "database_id", database_id: databaseId },
+      properties
+    });
+    return {
+      id: page.id,
+      title: input.title,
+      url: "url" in page ? page.url : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: databaseId,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
+  }
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
+    }
+    return created;
+  }
+  async createSummaryPage(input) {
+    const parentId = this.defaults.summaryParentPageId;
+    if (!parentId) {
+      throw new Error("Notion summaryParentPageId is required for summaries.");
+    }
+    const summaryProperties = {
+      title: buildTitleProperty(input.title)
+    };
+    const page = await this.client.pages.create({
+      parent: { type: "page_id", page_id: parentId },
+      properties: summaryProperties
+    });
+    if (input.description) {
+      const children = buildParagraphBlocks(input.description);
+      if (children.length > 0) {
+        await this.client.blocks.children.append({
+          block_id: page.id,
+          children
+        });
+      }
+    }
+    return {
+      id: page.id,
+      title: input.title,
+      url: "url" in page ? page.url : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: parentId,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
+  }
+}
+function buildTitleProperty(title) {
+  return {
+    title: [
+      {
+        type: "text",
+        text: { content: title }
+      }
+    ]
+  };
+}
+function buildRichText(text) {
+  return {
+    rich_text: [
+      {
+        type: "text",
+        text: { content: text }
+      }
+    ]
+  };
+}
+function applySelect(properties, property, value) {
+  if (!property || !value)
+    return;
+  const next = {
+    select: { name: value }
+  };
+  properties[property] = next;
+}
+function applyMultiSelect(properties, property, values) {
+  if (!property || !values || values.length === 0)
+    return;
+  const next = {
+    multi_select: values.map((value) => ({ name: value }))
+  };
+  properties[property] = next;
+}
+function applyDate(properties, property, value) {
+  if (!property || !value)
+    return;
+  const next = {
+    date: { start: value.toISOString() }
+  };
+  properties[property] = next;
+}
+function applyRichText(properties, property, value) {
+  if (!property || !value)
+    return;
+  properties[property] = buildRichText(value);
+}
+function buildParagraphBlocks(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim());
+  return lines.map((line) => ({
+    object: "block",
+    type: "paragraph",
+    paragraph: {
+      rich_text: [
+        {
+          type: "text",
+          text: { content: line }
+        }
+      ]
+    }
+  }));
+}
+
+// src/impls/tldv-meeting-recorder.ts
+var DEFAULT_BASE_URL4 = "https://pasta.tldv.io/v1alpha1";
+
+class TldvMeetingRecorderProvider {
+  apiKey;
+  baseUrl;
+  defaultPageSize;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL4;
+    this.defaultPageSize = options.pageSize;
+  }
+  async listMeetings(params) {
+    const page = params.cursor ? Number(params.cursor) : 1;
+    const limit = params.pageSize ?? this.defaultPageSize ?? 50;
+    const query = new URLSearchParams;
+    query.set("page", String(Number.isFinite(page) ? page : 1));
+    query.set("limit", String(limit));
+    if (params.query)
+      query.set("query", params.query);
+    if (params.from)
+      query.set("from", params.from);
+    if (params.to)
+      query.set("to", params.to);
+    if (params.organizerEmail)
+      query.set("organizer", params.organizerEmail);
+    if (params.participantEmail)
+      query.set("participant", params.participantEmail);
+    const data = await this.request(`/meetings?${query.toString()}`);
+    const nextPage = data.page < data.pages ? data.page + 1 : undefined;
+    return {
+      meetings: data.results.map((meeting) => this.mapMeeting(meeting, params)),
+      nextCursor: nextPage ? String(nextPage) : undefined,
+      hasMore: Boolean(nextPage)
+    };
+  }
+  async getMeeting(params) {
+    const meeting = await this.request(`/meetings/${encodeURIComponent(params.meetingId)}`);
+    return this.mapMeeting(meeting, params);
+  }
+  async getTranscript(params) {
+    const response = await this.request(`/meetings/${encodeURIComponent(params.meetingId)}/transcript`);
+    const segments = response.data.map((segment, index) => this.mapTranscriptSegment(segment, index));
+    return {
+      id: response.id,
+      meetingId: response.meetingId,
+      tenantId: params.tenantId,
+      connectionId: params.connectionId ?? "unknown",
+      externalId: response.id,
+      format: "segments",
+      text: segments.map((segment) => segment.text).join(`
+`),
+      segments,
+      metadata: {
+        providerMeetingId: response.meetingId
+      },
+      raw: response.data
+    };
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? JSON.parse(request.rawBody);
+    const body = payload;
+    return {
+      providerKey: "meeting-recorder.tldv",
+      eventType: body.event,
+      meetingId: body.data?.id ?? body.data?.meetingId,
+      receivedAt: body.executedAt,
+      payload
+    };
+  }
+  mapMeeting(meeting, params) {
+    const connectionId = params.connectionId ?? "unknown";
+    const invitees = meeting.invitees?.map((invitee) => this.mapInvitee(invitee)).filter(Boolean);
+    return {
+      id: meeting.id,
+      tenantId: params.tenantId,
+      connectionId,
+      externalId: meeting.id,
+      title: meeting.name,
+      organizer: this.mapInvitee(meeting.organizer, "organizer"),
+      invitees: invitees?.length ? invitees : undefined,
+      participants: invitees?.length ? invitees : undefined,
+      scheduledStartAt: meeting.happenedAt,
+      recordingStartAt: meeting.happenedAt,
+      durationSeconds: meeting.duration,
+      meetingUrl: meeting.url,
+      transcriptAvailable: true,
+      sourcePlatform: "tldv",
+      metadata: {
+        template: meeting.template,
+        extraProperties: meeting.extraProperties
+      }
+    };
+  }
+  mapInvitee(invitee, role = "attendee") {
+    if (!invitee)
+      return;
+    return {
+      name: invitee.name ?? undefined,
+      email: invitee.email ?? undefined,
+      role
+    };
+  }
+  mapTranscriptSegment(segment, index) {
+    return {
+      index,
+      speakerName: segment.speaker ?? undefined,
+      text: segment.text,
+      startTimeMs: parseSeconds2(segment.startTime),
+      endTimeMs: parseSeconds2(segment.endTime)
+    };
+  }
+  async request(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      const message = await safeReadError4(response);
+      throw new Error(`tl;dv API error (${response.status}): ${message}`);
+    }
+    return await response.json();
+  }
+}
+function parseSeconds2(value) {
+  if (value == null)
+    return;
+  const num = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(num))
+    return;
+  return num * 1000;
+}
+async function safeReadError4(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/provider-factory.ts
+import { Buffer as Buffer5 } from "node:buffer";
+var SECRET_CACHE = new Map;
+
+class IntegrationProviderFactory {
+  async createPaymentsProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "payments.stripe":
+        return new StripePaymentsProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Stripe API key is required")
+        });
+      default:
+        throw new Error(`Unsupported payments integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createEmailOutboundProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "email.postmark":
+        return new PostmarkEmailProvider({
+          serverToken: requireSecret(secrets, "serverToken", "Postmark server token is required"),
+          defaultFromEmail: context.config.fromEmail,
+          messageStream: context.config.messageStream
+        });
+      default:
+        throw new Error(`Unsupported email integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createSmsProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "sms.twilio":
+        return new TwilioSmsProvider({
+          accountSid: requireSecret(secrets, "accountSid", "Twilio account SID is required"),
+          authToken: requireSecret(secrets, "authToken", "Twilio auth token is required"),
+          fromNumber: context.config.fromNumber
+        });
+      default:
+        throw new Error(`Unsupported SMS integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createVectorStoreProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "vectordb.qdrant":
+        return new QdrantVectorProvider({
+          url: requireConfig(context, "apiUrl", "Qdrant apiUrl config is required"),
+          apiKey: secrets.apiKey
+        });
+      case "vectordb.supabase":
+        return new SupabaseVectorProvider({
+          connectionString: requireDatabaseUrl(secrets, "Supabase vector databaseUrl secret is required"),
+          schema: config?.schema,
+          table: config?.table,
+          createTableIfMissing: config?.createTableIfMissing,
+          distanceMetric: config?.distanceMetric,
+          maxConnections: config?.maxConnections,
+          sslMode: config?.sslMode
+        });
+      default:
+        throw new Error(`Unsupported vector store integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createAnalyticsProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "analytics.posthog":
+        return new PosthogAnalyticsProvider({
+          host: config?.host,
+          projectId: config?.projectId,
+          mcpUrl: config?.mcpUrl,
+          projectApiKey: secrets.projectApiKey,
+          personalApiKey: requireSecret(secrets, "personalApiKey", "PostHog personalApiKey is required")
+        });
+      default:
+        throw new Error(`Unsupported analytics integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createDatabaseProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "database.supabase":
+        return new SupabasePostgresProvider({
+          connectionString: requireDatabaseUrl(secrets, "Supabase database databaseUrl secret is required"),
+          maxConnections: config?.maxConnections,
+          sslMode: config?.sslMode
+        });
+      default:
+        throw new Error(`Unsupported database integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createObjectStorageProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "storage.s3":
+      case "storage.gcs":
+        return new GoogleCloudStorageProvider({
+          bucket: requireConfig(context, "bucket", "Storage bucket is required"),
+          clientOptions: secrets.type === "service_account" ? { credentials: secrets } : undefined
+        });
+      default:
+        throw new Error(`Unsupported storage integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createVoiceProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "ai-voice.elevenlabs":
+        return new ElevenLabsVoiceProvider({
+          apiKey: requireSecret(secrets, "apiKey", "ElevenLabs API key is required"),
+          defaultVoiceId: config?.defaultVoiceId
+        });
+      case "ai-voice.gradium":
+        return new GradiumVoiceProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Gradium API key is required"),
+          defaultVoiceId: config?.defaultVoiceId,
+          region: config?.region,
+          baseUrl: config?.baseUrl,
+          timeoutMs: config?.timeoutMs,
+          outputFormat: config?.outputFormat
+        });
+      case "ai-voice.fal":
+        return new FalVoiceProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Fal API key is required"),
+          modelId: config?.modelId,
+          defaultVoiceUrl: config?.defaultVoiceUrl,
+          defaultExaggeration: config?.defaultExaggeration,
+          defaultTemperature: config?.defaultTemperature,
+          defaultCfg: config?.defaultCfg,
+          pollIntervalMs: config?.pollIntervalMs
+        });
+      default:
+        throw new Error(`Unsupported voice integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createProjectManagementProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "project-management.linear":
+        return new LinearProjectManagementProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Linear API key is required"),
+          teamId: requireConfig(context, "teamId", "Linear teamId is required"),
+          projectId: config?.projectId,
+          assigneeId: config?.assigneeId,
+          stateId: config?.stateId,
+          labelIds: config?.labelIds,
+          tagLabelMap: config?.tagLabelMap
+        });
+      case "project-management.jira":
+        return new JiraProjectManagementProvider({
+          siteUrl: requireConfig(context, "siteUrl", "Jira siteUrl is required"),
+          email: requireSecret(secrets, "email", "Jira email is required"),
+          apiToken: requireSecret(secrets, "apiToken", "Jira API token is required"),
+          projectKey: config?.projectKey,
+          issueType: config?.issueType,
+          defaultLabels: config?.defaultLabels,
+          issueTypeMap: config?.issueTypeMap
+        });
+      case "project-management.notion":
+        return new NotionProjectManagementProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Notion API key is required"),
+          databaseId: config?.databaseId,
+          summaryParentPageId: config?.summaryParentPageId,
+          titleProperty: config?.titleProperty,
+          statusProperty: config?.statusProperty,
+          priorityProperty: config?.priorityProperty,
+          tagsProperty: config?.tagsProperty,
+          dueDateProperty: config?.dueDateProperty,
+          descriptionProperty: config?.descriptionProperty
+        });
+      default:
+        throw new Error(`Unsupported project management integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createMeetingRecorderProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "meeting-recorder.granola":
+        if (config?.transport === "mcp") {
+          return new GranolaMeetingRecorderProvider({
+            transport: "mcp",
+            mcpUrl: config?.mcpUrl,
+            mcpHeaders: config?.mcpHeaders,
+            mcpAccessToken: secrets.mcpAccessToken ?? secrets.apiKey,
+            pageSize: config?.pageSize
+          });
+        }
+        return new GranolaMeetingRecorderProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Granola API key is required"),
+          baseUrl: config?.baseUrl,
+          pageSize: config?.pageSize
+        });
+      case "meeting-recorder.tldv":
+        return new TldvMeetingRecorderProvider({
+          apiKey: requireSecret(secrets, "apiKey", "tl;dv API key is required"),
+          baseUrl: config?.baseUrl,
+          pageSize: config?.pageSize
+        });
+      case "meeting-recorder.fireflies":
+        return new FirefliesMeetingRecorderProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Fireflies API key is required"),
+          baseUrl: config?.baseUrl,
+          pageSize: config?.transcriptsPageSize ?? config?.pageSize,
+          webhookSecret: secrets.webhookSecret
+        });
+      case "meeting-recorder.fathom":
+        return new FathomMeetingRecorderProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Fathom API key is required"),
+          baseUrl: config?.baseUrl,
+          includeTranscript: config?.includeTranscript,
+          includeSummary: config?.includeSummary,
+          includeActionItems: config?.includeActionItems,
+          includeCrmMatches: config?.includeCrmMatches,
+          triggeredFor: config?.triggeredFor,
+          maxPages: config?.maxPages,
+          webhookSecret: secrets.webhookSecret
+        });
+      default:
+        throw new Error(`Unsupported meeting recorder integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createLlmProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "ai-llm.mistral":
+        return new MistralLLMProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
+          defaultModel: context.config.model
+        });
+      default:
+        throw new Error(`Unsupported LLM integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createEmbeddingProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    switch (context.spec.meta.key) {
+      case "ai-llm.mistral":
+        return new MistralEmbeddingProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
+          defaultModel: context.config.embeddingModel
+        });
+      default:
+        throw new Error(`Unsupported embeddings integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createOpenBankingProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "openbanking.powens": {
+        const environmentValue = requireConfig(context, "environment", "Powens environment (sandbox | production) must be specified in integration config.");
+        if (environmentValue !== "sandbox" && environmentValue !== "production") {
+          throw new Error(`Powens environment "${environmentValue}" is invalid. Expected "sandbox" or "production".`);
+        }
+        return new PowensOpenBankingProvider({
+          clientId: requireSecret(secrets, "clientId", "Powens clientId is required"),
+          clientSecret: requireSecret(secrets, "clientSecret", "Powens clientSecret is required"),
+          apiKey: secrets.apiKey,
+          environment: environmentValue,
+          baseUrl: config?.baseUrl
+        });
+      }
+      default:
+        throw new Error(`Unsupported open banking integration: ${context.spec.meta.key}`);
+    }
+  }
+  async loadSecrets(context) {
+    const cacheKey = context.connection.meta.id;
+    if (SECRET_CACHE.has(cacheKey)) {
+      const cached = SECRET_CACHE.get(cacheKey);
+      return cached ?? {};
+    }
+    const secret = await context.secretProvider.getSecret(context.secretReference);
+    const value = parseSecret(secret);
+    SECRET_CACHE.set(cacheKey, value);
+    return value;
+  }
+}
+function parseSecret(secret) {
+  const text = Buffer5.from(secret.data).toString("utf-8").trim();
+  if (!text)
+    return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { apiKey: text };
+  }
+}
+function requireSecret(secrets, key, message) {
+  const value = secrets[key];
+  if (value == null || value === "") {
+    throw new Error(message);
+  }
+  return value;
+}
+function requireDatabaseUrl(secrets, message) {
+  const value = secrets.databaseUrl ?? secrets.connectionString ?? secrets.postgresUrl ?? secrets.apiKey;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(message);
+  }
+  return value;
+}
+function requireConfig(context, key, message) {
+  const config = context.config;
+  const value = config?.[key];
+  if (value == null) {
+    throw new Error(message);
+  }
+  return value;
+}
+export {
+  TwilioSmsProvider,
+  TldvMeetingRecorderProvider,
+  SupabaseVectorProvider,
+  SupabasePostgresProvider,
+  StripePaymentsProvider,
+  QdrantVectorProvider,
+  PowensOpenBankingProvider,
+  PowensClientError,
+  PowensClient,
+  PostmarkEmailProvider,
+  PosthogAnalyticsReader,
+  PosthogAnalyticsProvider,
+  NotionProjectManagementProvider,
+  MistralLLMProvider,
+  MistralEmbeddingProvider,
+  LinearProjectManagementProvider,
+  JiraProjectManagementProvider,
+  IntegrationProviderFactory,
+  GranolaMeetingRecorderProvider,
+  GradiumVoiceProvider,
+  GoogleCloudStorageProvider,
+  GoogleCalendarProvider,
+  GmailOutboundProvider,
+  GmailInboundProvider,
+  FirefliesMeetingRecorderProvider,
+  FathomMeetingRecorderProvider,
+  FalVoiceProvider,
+  ElevenLabsVoiceProvider
+};