@contractspec/integration.providers-impls 3.7.6 → 3.8.2

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

@@ -0,0 +1,13 @@
+import type { MessagingProvider, MessagingSendInput, MessagingSendResult } from '../messaging';
+export interface TelegramMessagingProviderOptions {
+    botToken: string;
+    defaultChatId?: string;
+    apiBaseUrl?: string;
+}
+export declare class TelegramMessagingProvider implements MessagingProvider {
+    private readonly botToken;
+    private readonly defaultChatId?;
+    private readonly apiBaseUrl;
+    constructor(options: TelegramMessagingProviderOptions);
+    sendMessage(input: MessagingSendInput): Promise<MessagingSendResult>;
+}

package/dist/impls/messaging-telegram.js

@@ -0,0 +1,49 @@
+// @bun
+var __require = import.meta.require;
+
+// src/impls/messaging-telegram.ts
+class TelegramMessagingProvider {
+  botToken;
+  defaultChatId;
+  apiBaseUrl;
+  constructor(options) {
+    this.botToken = options.botToken;
+    this.defaultChatId = options.defaultChatId;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.telegram.org";
+  }
+  async sendMessage(input) {
+    const chatId = input.channelId ?? input.recipientId ?? this.defaultChatId ?? undefined;
+    if (!chatId) {
+      throw new Error("Telegram sendMessage requires channelId, recipientId, or defaultChatId.");
+    }
+    const messageThreadId = input.threadId && input.threadId !== chatId ? Number.parseInt(input.threadId, 10) : undefined;
+    const response = await fetch(`${this.apiBaseUrl}/bot${this.botToken}/sendMessage`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text: input.text,
+        message_thread_id: Number.isFinite(messageThreadId) ? messageThreadId : undefined
+      })
+    });
+    const body = await response.json();
+    const providerMessageId = body.result?.message_id;
+    if (!response.ok || !body.ok || providerMessageId == null) {
+      throw new Error(`Telegram sendMessage failed: ${body.description ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: `telegram:${chatId}:${providerMessageId}`,
+      providerMessageId: String(providerMessageId),
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        chatId: String(body.result?.chat?.id ?? chatId)
+      }
+    };
+  }
+}
+export {
+  TelegramMessagingProvider
+};

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

@@ -1,5 +1,5 @@
-import { type MistralSttProviderOptions } from './mistral-stt';
 import type { ConversationalProvider, ConversationalSession, ConversationalSessionConfig, STTProvider, Voice } from '../voice';
+import { type MistralSttProviderOptions } from './mistral-stt';
 export interface MistralConversationalProviderOptions {
     apiKey: string;
     defaultModel?: string;

package/dist/impls/mistral-conversational.js

@@ -45,6 +45,165 @@ class AsyncEventQueue {
   }
 }
 
+// src/impls/mistral-conversational.session.ts
+class MistralConversationSession {
+  events;
+  queue = new AsyncEventQueue;
+  turns = [];
+  history = [];
+  sessionId = crypto.randomUUID();
+  startedAt = Date.now();
+  sessionConfig;
+  defaultModel;
+  complete;
+  sttProvider;
+  pending = Promise.resolve();
+  closed = false;
+  closedSummary;
+  constructor(options) {
+    this.sessionConfig = options.sessionConfig;
+    this.defaultModel = options.defaultModel;
+    this.complete = options.complete;
+    this.sttProvider = options.sttProvider;
+    this.events = this.queue;
+    this.queue.push({
+      type: "session_started",
+      sessionId: this.sessionId
+    });
+  }
+  sendAudio(chunk) {
+    if (this.closed) {
+      return;
+    }
+    this.pending = this.pending.then(async () => {
+      const transcription = await this.sttProvider.transcribe({
+        audio: {
+          data: chunk,
+          format: this.sessionConfig.inputFormat ?? "pcm",
+          sampleRateHz: 16000
+        },
+        language: this.sessionConfig.language
+      });
+      const transcriptText = transcription.text.trim();
+      if (transcriptText.length > 0) {
+        await this.handleUserText(transcriptText);
+      }
+    }).catch((error) => {
+      this.emitError(error);
+    });
+  }
+  sendText(text) {
+    if (this.closed) {
+      return;
+    }
+    const normalized = text.trim();
+    if (normalized.length === 0) {
+      return;
+    }
+    this.pending = this.pending.then(() => this.handleUserText(normalized)).catch((error) => {
+      this.emitError(error);
+    });
+  }
+  interrupt() {
+    if (this.closed) {
+      return;
+    }
+    this.queue.push({
+      type: "error",
+      error: new Error("Interrupt is not supported for non-streaming sessions.")
+    });
+  }
+  async close() {
+    if (this.closedSummary) {
+      return this.closedSummary;
+    }
+    this.closed = true;
+    await this.pending;
+    const durationMs = Date.now() - this.startedAt;
+    const summary = {
+      sessionId: this.sessionId,
+      durationMs,
+      turns: this.turns.map((turn) => ({
+        role: turn.role === "assistant" ? "agent" : turn.role,
+        text: turn.text,
+        startMs: turn.startMs,
+        endMs: turn.endMs
+      })),
+      transcript: this.turns.map((turn) => `${turn.role}: ${turn.text}`).join(`
+`)
+    };
+    this.closedSummary = summary;
+    this.queue.push({
+      type: "session_ended",
+      reason: "closed_by_client",
+      durationMs
+    });
+    this.queue.close();
+    return summary;
+  }
+  async handleUserText(text) {
+    if (this.closed) {
+      return;
+    }
+    const userStart = Date.now();
+    this.queue.push({ type: "user_speech_started" });
+    this.queue.push({ type: "user_speech_ended", transcript: text });
+    this.queue.push({
+      type: "transcript",
+      role: "user",
+      text,
+      timestamp: userStart
+    });
+    this.turns.push({
+      role: "user",
+      text,
+      startMs: userStart,
+      endMs: Date.now()
+    });
+    this.history.push({ role: "user", content: text });
+    const assistantStart = Date.now();
+    const assistantText = await this.complete(this.history, {
+      ...this.sessionConfig,
+      llmModel: this.sessionConfig.llmModel ?? this.defaultModel
+    });
+    if (this.closed) {
+      return;
+    }
+    const normalizedAssistantText = assistantText.trim();
+    const finalAssistantText = normalizedAssistantText.length > 0 ? normalizedAssistantText : "I was unable to produce a response.";
+    this.queue.push({
+      type: "agent_speech_started",
+      text: finalAssistantText
+    });
+    this.queue.push({
+      type: "transcript",
+      role: "agent",
+      text: finalAssistantText,
+      timestamp: assistantStart
+    });
+    this.queue.push({ type: "agent_speech_ended" });
+    this.turns.push({
+      role: "assistant",
+      text: finalAssistantText,
+      startMs: assistantStart,
+      endMs: Date.now()
+    });
+    this.history.push({ role: "assistant", content: finalAssistantText });
+  }
+  emitError(error) {
+    if (this.closed) {
+      return;
+    }
+    this.queue.push({ type: "error", error: toError(error) });
+  }
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+
 // src/impls/mistral-stt.ts
 var DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 var DEFAULT_MODEL = "voxtral-mini-latest";
@@ -209,165 +368,6 @@ function secondsToMs(value) {
   return Math.round(value * 1000);
 }
 
-// src/impls/mistral-conversational.session.ts
-class MistralConversationSession {
-  events;
-  queue = new AsyncEventQueue;
-  turns = [];
-  history = [];
-  sessionId = crypto.randomUUID();
-  startedAt = Date.now();
-  sessionConfig;
-  defaultModel;
-  complete;
-  sttProvider;
-  pending = Promise.resolve();
-  closed = false;
-  closedSummary;
-  constructor(options) {
-    this.sessionConfig = options.sessionConfig;
-    this.defaultModel = options.defaultModel;
-    this.complete = options.complete;
-    this.sttProvider = options.sttProvider;
-    this.events = this.queue;
-    this.queue.push({
-      type: "session_started",
-      sessionId: this.sessionId
-    });
-  }
-  sendAudio(chunk) {
-    if (this.closed) {
-      return;
-    }
-    this.pending = this.pending.then(async () => {
-      const transcription = await this.sttProvider.transcribe({
-        audio: {
-          data: chunk,
-          format: this.sessionConfig.inputFormat ?? "pcm",
-          sampleRateHz: 16000
-        },
-        language: this.sessionConfig.language
-      });
-      const transcriptText = transcription.text.trim();
-      if (transcriptText.length > 0) {
-        await this.handleUserText(transcriptText);
-      }
-    }).catch((error) => {
-      this.emitError(error);
-    });
-  }
-  sendText(text) {
-    if (this.closed) {
-      return;
-    }
-    const normalized = text.trim();
-    if (normalized.length === 0) {
-      return;
-    }
-    this.pending = this.pending.then(() => this.handleUserText(normalized)).catch((error) => {
-      this.emitError(error);
-    });
-  }
-  interrupt() {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({
-      type: "error",
-      error: new Error("Interrupt is not supported for non-streaming sessions.")
-    });
-  }
-  async close() {
-    if (this.closedSummary) {
-      return this.closedSummary;
-    }
-    this.closed = true;
-    await this.pending;
-    const durationMs = Date.now() - this.startedAt;
-    const summary = {
-      sessionId: this.sessionId,
-      durationMs,
-      turns: this.turns.map((turn) => ({
-        role: turn.role === "assistant" ? "agent" : turn.role,
-        text: turn.text,
-        startMs: turn.startMs,
-        endMs: turn.endMs
-      })),
-      transcript: this.turns.map((turn) => `${turn.role}: ${turn.text}`).join(`
-`)
-    };
-    this.closedSummary = summary;
-    this.queue.push({
-      type: "session_ended",
-      reason: "closed_by_client",
-      durationMs
-    });
-    this.queue.close();
-    return summary;
-  }
-  async handleUserText(text) {
-    if (this.closed) {
-      return;
-    }
-    const userStart = Date.now();
-    this.queue.push({ type: "user_speech_started" });
-    this.queue.push({ type: "user_speech_ended", transcript: text });
-    this.queue.push({
-      type: "transcript",
-      role: "user",
-      text,
-      timestamp: userStart
-    });
-    this.turns.push({
-      role: "user",
-      text,
-      startMs: userStart,
-      endMs: Date.now()
-    });
-    this.history.push({ role: "user", content: text });
-    const assistantStart = Date.now();
-    const assistantText = await this.complete(this.history, {
-      ...this.sessionConfig,
-      llmModel: this.sessionConfig.llmModel ?? this.defaultModel
-    });
-    if (this.closed) {
-      return;
-    }
-    const normalizedAssistantText = assistantText.trim();
-    const finalAssistantText = normalizedAssistantText.length > 0 ? normalizedAssistantText : "I was unable to produce a response.";
-    this.queue.push({
-      type: "agent_speech_started",
-      text: finalAssistantText
-    });
-    this.queue.push({
-      type: "transcript",
-      role: "agent",
-      text: finalAssistantText,
-      timestamp: assistantStart
-    });
-    this.queue.push({ type: "agent_speech_ended" });
-    this.turns.push({
-      role: "assistant",
-      text: finalAssistantText,
-      startMs: assistantStart,
-      endMs: Date.now()
-    });
-    this.history.push({ role: "assistant", content: finalAssistantText });
-  }
-  emitError(error) {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({ type: "error", error: toError(error) });
-  }
-}
-function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
-}
-
 // src/impls/mistral-conversational.ts
 var DEFAULT_BASE_URL2 = "https://api.mistral.ai/v1";
 var DEFAULT_MODEL2 = "mistral-small-latest";

package/dist/impls/posthog-reader.d.ts

@@ -1,4 +1,4 @@
-import type { AnalyticsReader, AnalyticsQueryInput, AnalyticsQueryResult, AnalyticsRequest, AnalyticsResponse, AnalyticsEvent, AnalyticsPerson, AnalyticsInsight, AnalyticsCohort, AnalyticsFeatureFlag, AnalyticsAnnotation, GetEventsInput, GetPersonsInput, GetInsightsInput, GetInsightResultInput, GetCohortsInput, GetFeatureFlagsInput, GetAnnotationsInput, PaginatedResponse } from '../analytics';
+import type { AnalyticsAnnotation, AnalyticsCohort, AnalyticsEvent, AnalyticsFeatureFlag, AnalyticsInsight, AnalyticsPerson, AnalyticsQueryInput, AnalyticsQueryResult, AnalyticsReader, AnalyticsRequest, AnalyticsResponse, GetAnnotationsInput, GetCohortsInput, GetEventsInput, GetFeatureFlagsInput, GetInsightResultInput, GetInsightsInput, GetPersonsInput, PaginatedResponse } from '../analytics';
 export interface PosthogReaderClient {
     request<T = unknown>(request: AnalyticsRequest): Promise<AnalyticsResponse<T>>;
 }

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

@@ -1,21 +1,21 @@
 import type { IntegrationContext } from '@contractspec/integration.runtime/runtime';
-import type { IntegrationTransportType } from '@contractspec/lib.contracts-integrations/integrations/transport';
 import type { IntegrationAuthType } from '@contractspec/lib.contracts-integrations/integrations/auth';
-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 { IntegrationTransportType } from '@contractspec/lib.contracts-integrations/integrations/transport';
 import type { AnalyticsProvider } from '../analytics';
 import type { DatabaseProvider } from '../database';
-import type { ObjectStorageProvider } from '../storage';
-import type { ConversationalProvider, STTProvider, TTSProvider } from '../voice';
-import type { LLMProvider } from '../llm';
+import type { EmailOutboundProvider } from '../email';
 import type { EmbeddingProvider } from '../embedding';
+import type { HealthProvider } from '../health';
+import type { LLMProvider } from '../llm';
+import type { MeetingRecorderProvider } from '../meeting-recorder';
+import type { MessagingProvider } from '../messaging';
 import type { OpenBankingProvider } from '../openbanking';
+import type { PaymentsProvider } from '../payments';
 import type { ProjectManagementProvider } from '../project-management';
-import type { MeetingRecorderProvider } from '../meeting-recorder';
-import type { HealthProvider } from '../health';
+import type { SmsProvider } from '../sms';
+import type { ObjectStorageProvider } from '../storage';
+import type { VectorStoreProvider } from '../vector-store';
+import type { ConversationalProvider, STTProvider, TTSProvider } from '../voice';
 import type { ComposioFallbackResolver } from './composio-fallback-resolver';
 /**
  * Resolved transport, auth, and version context for a provider invocation.