@contractspec/integration.providers-impls 2.9.0 → 3.0.0

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

@@ -0,0 +1,17 @@
+import type { STTProvider, STTTranscriptionInput, STTTranscriptionResult } from '../voice';
+export interface MistralSttProviderOptions {
+    apiKey: string;
+    defaultModel?: string;
+    defaultLanguage?: string;
+    serverURL?: string;
+    fetchImpl?: typeof fetch;
+}
+export declare class MistralSttProvider implements STTProvider {
+    private readonly apiKey;
+    private readonly defaultModel;
+    private readonly defaultLanguage?;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(options: MistralSttProviderOptions);
+    transcribe(input: STTTranscriptionInput): Promise<STTTranscriptionResult>;
+}

package/dist/impls/mistral-stt.js

@@ -0,0 +1,167 @@
+// @bun
+// src/impls/mistral-stt.ts
+var DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
+var DEFAULT_MODEL = "voxtral-mini-latest";
+var AUDIO_MIME_BY_FORMAT = {
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  pcm: "audio/pcm",
+  opus: "audio/opus"
+};
+
+class MistralSttProvider {
+  apiKey;
+  defaultModel;
+  defaultLanguage;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralSttProvider requires an apiKey");
+    }
+    this.apiKey = options.apiKey;
+    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL;
+    this.defaultLanguage = options.defaultLanguage;
+    this.baseUrl = normalizeBaseUrl(options.serverURL ?? DEFAULT_BASE_URL);
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async transcribe(input) {
+    const formData = new FormData;
+    const model = input.model ?? this.defaultModel;
+    const mimeType = AUDIO_MIME_BY_FORMAT[input.audio.format] ?? "audio/wav";
+    const fileName = `audio.${input.audio.format}`;
+    const audioBytes = new Uint8Array(input.audio.data);
+    const blob = new Blob([audioBytes], { type: mimeType });
+    formData.append("file", blob, fileName);
+    formData.append("model", model);
+    formData.append("response_format", "verbose_json");
+    const language = input.language ?? this.defaultLanguage;
+    if (language) {
+      formData.append("language", language);
+    }
+    const response = await this.fetchImpl(`${this.baseUrl}/audio/transcriptions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Mistral transcription request failed (${response.status}): ${body}`);
+    }
+    const payload = await response.json();
+    return toTranscriptionResult(payload, input);
+  }
+}
+function toTranscriptionResult(payload, input) {
+  const record = asRecord(payload);
+  const text = readString(record, "text") ?? "";
+  const language = readString(record, "language") ?? input.language ?? "unknown";
+  const segments = parseSegments(record);
+  if (segments.length === 0 && text.length > 0) {
+    segments.push({
+      text,
+      startMs: 0,
+      endMs: input.audio.durationMs ?? 0
+    });
+  }
+  const durationMs = input.audio.durationMs ?? segments.reduce((max, segment) => Math.max(max, segment.endMs), 0);
+  const topLevelWords = parseWordTimings(record.words);
+  const flattenedWords = segments.flatMap((segment) => segment.wordTimings ?? []);
+  const wordTimings = topLevelWords.length > 0 ? topLevelWords : flattenedWords.length > 0 ? flattenedWords : undefined;
+  const speakers = dedupeSpeakers(segments);
+  return {
+    text,
+    segments,
+    language,
+    durationMs,
+    speakers: speakers.length > 0 ? speakers : undefined,
+    wordTimings
+  };
+}
+function parseSegments(record) {
+  if (!Array.isArray(record.segments)) {
+    return [];
+  }
+  const parsed = [];
+  for (const entry of record.segments) {
+    const segmentRecord = asRecord(entry);
+    const text = readString(segmentRecord, "text");
+    if (!text) {
+      continue;
+    }
+    const startSeconds = readNumber(segmentRecord, "start") ?? 0;
+    const endSeconds = readNumber(segmentRecord, "end") ?? startSeconds;
+    parsed.push({
+      text,
+      startMs: secondsToMs(startSeconds),
+      endMs: secondsToMs(endSeconds),
+      speakerId: readString(segmentRecord, "speaker") ?? undefined,
+      confidence: readNumber(segmentRecord, "confidence"),
+      wordTimings: parseWordTimings(segmentRecord.words)
+    });
+  }
+  return parsed;
+}
+function parseWordTimings(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const words = [];
+  for (const entry of value) {
+    const wordRecord = asRecord(entry);
+    const word = readString(wordRecord, "word");
+    const startSeconds = readNumber(wordRecord, "start");
+    const endSeconds = readNumber(wordRecord, "end");
+    if (!word || startSeconds == null || endSeconds == null) {
+      continue;
+    }
+    words.push({
+      word,
+      startMs: secondsToMs(startSeconds),
+      endMs: secondsToMs(endSeconds),
+      confidence: readNumber(wordRecord, "confidence")
+    });
+  }
+  return words;
+}
+function dedupeSpeakers(segments) {
+  const seen = new Set;
+  const speakers = [];
+  for (const segment of segments) {
+    if (!segment.speakerId || seen.has(segment.speakerId)) {
+      continue;
+    }
+    seen.add(segment.speakerId);
+    speakers.push({
+      id: segment.speakerId,
+      name: segment.speakerName
+    });
+  }
+  return speakers;
+}
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function asRecord(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function readString(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+function readNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" ? value : undefined;
+}
+function secondsToMs(value) {
+  return Math.round(value * 1000);
+}
+export {
+  MistralSttProvider
+};

package/dist/impls/provider-factory.d.ts

@@ -2,29 +2,35 @@ import type { IntegrationContext } from '@contractspec/integration.runtime/runti
 import type { PaymentsProvider } from '../payments';
 import type { EmailOutboundProvider } from '../email';
 import type { SmsProvider } from '../sms';
+import type { MessagingProvider } from '../messaging';
 import type { VectorStoreProvider } from '../vector-store';
 import type { AnalyticsProvider } from '../analytics';
 import type { DatabaseProvider } from '../database';
 import type { ObjectStorageProvider } from '../storage';
-import type { TTSProvider } from '../voice';
+import type { ConversationalProvider, STTProvider, TTSProvider } from '../voice';
 import type { LLMProvider } from '../llm';
 import type { EmbeddingProvider } from '../embedding';
 import type { OpenBankingProvider } from '../openbanking';
 import type { ProjectManagementProvider } from '../project-management';
 import type { MeetingRecorderProvider } from '../meeting-recorder';
+import type { HealthProvider } from '../health';
 export declare class IntegrationProviderFactory {
     createPaymentsProvider(context: IntegrationContext): Promise<PaymentsProvider>;
     createEmailOutboundProvider(context: IntegrationContext): Promise<EmailOutboundProvider>;
     createSmsProvider(context: IntegrationContext): Promise<SmsProvider>;
+    createMessagingProvider(context: IntegrationContext): Promise<MessagingProvider>;
     createVectorStoreProvider(context: IntegrationContext): Promise<VectorStoreProvider>;
     createAnalyticsProvider(context: IntegrationContext): Promise<AnalyticsProvider>;
     createDatabaseProvider(context: IntegrationContext): Promise<DatabaseProvider>;
     createObjectStorageProvider(context: IntegrationContext): Promise<ObjectStorageProvider>;
     createVoiceProvider(context: IntegrationContext): Promise<TTSProvider>;
+    createSttProvider(context: IntegrationContext): Promise<STTProvider>;
+    createConversationalProvider(context: IntegrationContext): Promise<ConversationalProvider>;
     createProjectManagementProvider(context: IntegrationContext): Promise<ProjectManagementProvider>;
     createMeetingRecorderProvider(context: IntegrationContext): Promise<MeetingRecorderProvider>;
     createLlmProvider(context: IntegrationContext): Promise<LLMProvider>;
     createEmbeddingProvider(context: IntegrationContext): Promise<EmbeddingProvider>;
     createOpenBankingProvider(context: IntegrationContext): Promise<OpenBankingProvider>;
+    createHealthProvider(context: IntegrationContext): Promise<HealthProvider>;
     private loadSecrets;
 }