@contractspec/integration.providers-impls 2.10.0 → 3.0.0

package/dist/impls/messaging-github.d.ts

@@ -0,0 +1,17 @@
+import type { MessagingProvider, MessagingSendInput, MessagingSendResult, MessagingUpdateInput } from '../messaging';
+export interface GithubMessagingProviderOptions {
+    token: string;
+    defaultOwner?: string;
+    defaultRepo?: string;
+    apiBaseUrl?: string;
+}
+export declare class GithubMessagingProvider implements MessagingProvider {
+    private readonly token;
+    private readonly defaultOwner?;
+    private readonly defaultRepo?;
+    private readonly apiBaseUrl;
+    constructor(options: GithubMessagingProviderOptions);
+    sendMessage(input: MessagingSendInput): Promise<MessagingSendResult>;
+    updateMessage(messageId: string, input: MessagingUpdateInput): Promise<MessagingSendResult>;
+    private resolveTarget;
+}

package/dist/impls/messaging-github.js

@@ -0,0 +1,110 @@
+// @bun
+// src/impls/messaging-github.ts
+class GithubMessagingProvider {
+  token;
+  defaultOwner;
+  defaultRepo;
+  apiBaseUrl;
+  constructor(options) {
+    this.token = options.token;
+    this.defaultOwner = options.defaultOwner;
+    this.defaultRepo = options.defaultRepo;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.github.com";
+  }
+  async sendMessage(input) {
+    const target = this.resolveTarget(input);
+    const response = await fetch(`${this.apiBaseUrl}/repos/${target.owner}/${target.repo}/issues/${target.issueNumber}/comments`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        accept: "application/vnd.github+json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ body: input.text })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.id) {
+      throw new Error(`GitHub sendMessage failed: ${body.message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: String(body.id),
+      providerMessageId: body.node_id,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        url: body.html_url ?? "",
+        owner: target.owner,
+        repo: target.repo,
+        issueNumber: String(target.issueNumber)
+      }
+    };
+  }
+  async updateMessage(messageId, input) {
+    const owner = input.metadata?.owner ?? this.defaultOwner;
+    const repo = input.metadata?.repo ?? this.defaultRepo;
+    if (!owner || !repo) {
+      throw new Error("GitHub updateMessage requires owner and repo metadata.");
+    }
+    const response = await fetch(`${this.apiBaseUrl}/repos/${owner}/${repo}/issues/comments/${messageId}`, {
+      method: "PATCH",
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        accept: "application/vnd.github+json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ body: input.text })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.id) {
+      throw new Error(`GitHub updateMessage failed: ${body.message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: String(body.id),
+      providerMessageId: body.node_id,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        url: body.html_url ?? "",
+        owner,
+        repo
+      }
+    };
+  }
+  resolveTarget(input) {
+    const parsedRecipient = parseRecipient(input.recipientId);
+    const owner = parsedRecipient?.owner ?? this.defaultOwner;
+    const repo = parsedRecipient?.repo ?? this.defaultRepo;
+    const issueNumber = parsedRecipient?.issueNumber ?? parseIssueNumber(input.threadId);
+    if (!owner || !repo || issueNumber == null) {
+      throw new Error("GitHub sendMessage requires owner/repo and issueNumber (use recipientId like owner/repo#123 or provide defaults + threadId).");
+    }
+    return {
+      owner,
+      repo,
+      issueNumber
+    };
+  }
+}
+function parseRecipient(value) {
+  if (!value)
+    return null;
+  const match = value.trim().match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (!match)
+    return null;
+  const owner = match[1];
+  const repo = match[2];
+  const issueNumber = Number(match[3]);
+  if (!owner || !repo || !Number.isInteger(issueNumber)) {
+    return null;
+  }
+  return { owner, repo, issueNumber };
+}
+function parseIssueNumber(value) {
+  if (!value)
+    return null;
+  const numeric = Number(value);
+  return Number.isInteger(numeric) ? numeric : null;
+}
+export {
+  GithubMessagingProvider
+};

package/dist/impls/messaging-slack.d.ts

@@ -0,0 +1,14 @@
+import type { MessagingProvider, MessagingSendInput, MessagingSendResult, MessagingUpdateInput } from '../messaging';
+export interface SlackMessagingProviderOptions {
+    botToken: string;
+    defaultChannelId?: string;
+    apiBaseUrl?: string;
+}
+export declare class SlackMessagingProvider implements MessagingProvider {
+    private readonly botToken;
+    private readonly defaultChannelId?;
+    private readonly apiBaseUrl;
+    constructor(options: SlackMessagingProviderOptions);
+    sendMessage(input: MessagingSendInput): Promise<MessagingSendResult>;
+    updateMessage(messageId: string, input: MessagingUpdateInput): Promise<MessagingSendResult>;
+}

package/dist/impls/messaging-slack.js

@@ -0,0 +1,80 @@
+// @bun
+// src/impls/messaging-slack.ts
+class SlackMessagingProvider {
+  botToken;
+  defaultChannelId;
+  apiBaseUrl;
+  constructor(options) {
+    this.botToken = options.botToken;
+    this.defaultChannelId = options.defaultChannelId;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://slack.com/api";
+  }
+  async sendMessage(input) {
+    const channel = input.channelId ?? input.recipientId ?? this.defaultChannelId;
+    if (!channel) {
+      throw new Error("Slack sendMessage requires channelId, recipientId, or defaultChannelId.");
+    }
+    const payload = {
+      channel,
+      text: input.text,
+      mrkdwn: input.markdown ?? true,
+      thread_ts: input.threadId
+    };
+    const response = await fetch(`${this.apiBaseUrl}/chat.postMessage`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.botToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    const body = await response.json();
+    if (!response.ok || !body.ok || !body.ts) {
+      throw new Error(`Slack sendMessage failed: ${body.error ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: `slack:${body.channel ?? channel}:${body.ts}`,
+      providerMessageId: body.ts,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        channelId: body.channel ?? channel
+      }
+    };
+  }
+  async updateMessage(messageId, input) {
+    const channel = input.channelId ?? this.defaultChannelId;
+    if (!channel) {
+      throw new Error("Slack updateMessage requires channelId or defaultChannelId.");
+    }
+    const response = await fetch(`${this.apiBaseUrl}/chat.update`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.botToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        channel,
+        ts: messageId,
+        text: input.text,
+        mrkdwn: input.markdown ?? true
+      })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.ok || !body.ts) {
+      throw new Error(`Slack updateMessage failed: ${body.error ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: `slack:${body.channel ?? channel}:${body.ts}`,
+      providerMessageId: body.ts,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        channelId: body.channel ?? channel
+      }
+    };
+  }
+}
+export {
+  SlackMessagingProvider
+};

package/dist/impls/messaging-whatsapp-meta.d.ts

@@ -0,0 +1,13 @@
+import type { MessagingProvider, MessagingSendInput, MessagingSendResult } from '../messaging';
+export interface MetaWhatsappMessagingProviderOptions {
+    accessToken: string;
+    phoneNumberId: string;
+    apiVersion?: string;
+}
+export declare class MetaWhatsappMessagingProvider implements MessagingProvider {
+    private readonly accessToken;
+    private readonly phoneNumberId;
+    private readonly apiVersion;
+    constructor(options: MetaWhatsappMessagingProviderOptions);
+    sendMessage(input: MessagingSendInput): Promise<MessagingSendResult>;
+}

package/dist/impls/messaging-whatsapp-meta.js

@@ -0,0 +1,52 @@
+// @bun
+// src/impls/messaging-whatsapp-meta.ts
+class MetaWhatsappMessagingProvider {
+  accessToken;
+  phoneNumberId;
+  apiVersion;
+  constructor(options) {
+    this.accessToken = options.accessToken;
+    this.phoneNumberId = options.phoneNumberId;
+    this.apiVersion = options.apiVersion ?? "v22.0";
+  }
+  async sendMessage(input) {
+    const to = input.recipientId;
+    if (!to) {
+      throw new Error("Meta WhatsApp sendMessage requires recipientId.");
+    }
+    const response = await fetch(`https://graph.facebook.com/${this.apiVersion}/${this.phoneNumberId}/messages`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.accessToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        to,
+        type: "text",
+        text: {
+          body: input.text,
+          preview_url: false
+        }
+      })
+    });
+    const body = await response.json();
+    const messageId = body.messages?.[0]?.id;
+    if (!response.ok || !messageId) {
+      const errorCode = body.error?.code != null ? String(body.error.code) : "";
+      throw new Error(`Meta WhatsApp sendMessage failed: ${body.error?.message ?? `HTTP_${response.status}`}${errorCode ? ` (${errorCode})` : ""}`);
+    }
+    return {
+      id: messageId,
+      providerMessageId: messageId,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        phoneNumberId: this.phoneNumberId
+      }
+    };
+  }
+}
+export {
+  MetaWhatsappMessagingProvider
+};

package/dist/impls/messaging-whatsapp-twilio.d.ts

@@ -0,0 +1,13 @@
+import type { MessagingProvider, MessagingSendInput, MessagingSendResult } from '../messaging';
+export interface TwilioWhatsappMessagingProviderOptions {
+    accountSid: string;
+    authToken: string;
+    fromNumber?: string;
+}
+export declare class TwilioWhatsappMessagingProvider implements MessagingProvider {
+    private readonly accountSid;
+    private readonly authToken;
+    private readonly fromNumber?;
+    constructor(options: TwilioWhatsappMessagingProviderOptions);
+    sendMessage(input: MessagingSendInput): Promise<MessagingSendResult>;
+}

package/dist/impls/messaging-whatsapp-twilio.js

@@ -0,0 +1,82 @@
+// @bun
+// src/impls/messaging-whatsapp-twilio.ts
+import { Buffer } from "buffer";
+
+class TwilioWhatsappMessagingProvider {
+  accountSid;
+  authToken;
+  fromNumber;
+  constructor(options) {
+    this.accountSid = options.accountSid;
+    this.authToken = options.authToken;
+    this.fromNumber = options.fromNumber;
+  }
+  async sendMessage(input) {
+    const to = normalizeWhatsappAddress(input.recipientId);
+    const from = normalizeWhatsappAddress(input.channelId ?? this.fromNumber);
+    if (!to) {
+      throw new Error("Twilio WhatsApp sendMessage requires recipientId.");
+    }
+    if (!from) {
+      throw new Error("Twilio WhatsApp sendMessage requires channelId or configured fromNumber.");
+    }
+    const params = new URLSearchParams;
+    params.set("To", to);
+    params.set("From", from);
+    params.set("Body", input.text);
+    const auth = Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64");
+    const response = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${this.accountSid}/Messages.json`, {
+      method: "POST",
+      headers: {
+        authorization: `Basic ${auth}`,
+        "content-type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    const body = await response.json();
+    if (!response.ok || !body.sid) {
+      throw new Error(`Twilio WhatsApp sendMessage failed: ${body.error_message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: body.sid,
+      providerMessageId: body.sid,
+      status: mapTwilioStatus(body.status),
+      sentAt: new Date,
+      errorCode: body.error_code != null ? String(body.error_code) : undefined,
+      errorMessage: body.error_message ?? undefined,
+      metadata: {
+        from,
+        to
+      }
+    };
+  }
+}
+function normalizeWhatsappAddress(value) {
+  if (!value)
+    return null;
+  if (value.startsWith("whatsapp:"))
+    return value;
+  return `whatsapp:${value}`;
+}
+function mapTwilioStatus(status) {
+  switch (status) {
+    case "queued":
+    case "accepted":
+    case "scheduled":
+      return "queued";
+    case "sending":
+      return "sending";
+    case "delivered":
+      return "delivered";
+    case "failed":
+    case "undelivered":
+    case "canceled":
+      return "failed";
+    case "sent":
+    default:
+      return "sent";
+  }
+}
+export {
+  TwilioWhatsappMessagingProvider
+};

package/dist/impls/mistral-conversational.d.ts

@@ -0,0 +1,23 @@
+import { type MistralSttProviderOptions } from './mistral-stt';
+import type { ConversationalProvider, ConversationalSession, ConversationalSessionConfig, STTProvider, Voice } from '../voice';
+export interface MistralConversationalProviderOptions {
+    apiKey: string;
+    defaultModel?: string;
+    defaultVoiceId?: string;
+    serverURL?: string;
+    fetchImpl?: typeof fetch;
+    sttProvider?: STTProvider;
+    sttOptions?: Omit<MistralSttProviderOptions, 'apiKey' | 'fetchImpl'>;
+}
+export declare class MistralConversationalProvider implements ConversationalProvider {
+    private readonly apiKey;
+    private readonly defaultModel;
+    private readonly defaultVoiceId;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly sttProvider;
+    constructor(options: MistralConversationalProviderOptions);
+    startSession(config: ConversationalSessionConfig): Promise<ConversationalSession>;
+    listVoices(): Promise<Voice[]>;
+    private completeConversation;
+}