@contractspec/integration.providers-impls 1.56.1 → 1.58.0

package/dist/node/impls/gmail-inbound.js

@@ -0,0 +1,227 @@
+// 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");
+}
+export {
+  GmailInboundProvider
+};

package/dist/node/impls/gmail-outbound.js

@@ -0,0 +1,139 @@
+// src/impls/gmail-outbound.ts
+import { google } from "googleapis";
+
+class GmailOutboundProvider {
+  gmail;
+  userId;
+  auth;
+  constructor(options) {
+    this.auth = options.auth;
+    this.gmail = options.gmail ?? google.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;
+}
+export {
+  GmailOutboundProvider
+};

package/dist/node/impls/google-calendar.js

@@ -0,0 +1,191 @@
+// src/impls/google-calendar.ts
+import { google } from "googleapis";
+
+class GoogleCalendarProvider {
+  calendar;
+  defaultCalendarId;
+  auth;
+  constructor(options) {
+    this.auth = options.auth;
+    this.calendar = options.calendar ?? google.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;
+}
+export {
+  GoogleCalendarProvider
+};

package/dist/node/impls/gradium-voice.js

@@ -0,0 +1,90 @@
+// src/impls/gradium-voice.ts
+import { Gradium } from "@confiture-ai/gradium-sdk-js";
+var FORMAT_MAP = {
+  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_MAP[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;
+  }
+}
+export {
+  GradiumVoiceProvider
+};