@contractspec/lib.contracts 1.44.0

package/dist/integrations/providers/impls/gmail-inbound.js

@@ -0,0 +1,200 @@
+import { google } from "googleapis";
+
+//#region src/integrations/providers/impls/gmail-inbound.ts
+var GmailInboundProvider = class {
+	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] : void 0,
+			includeSpamTrash: this.includeSpamTrash,
+			auth: this.auth
+		});
+		return (await Promise.all((response.data.threads ?? []).map(async (thread) => {
+			if (!thread.id) return null;
+			return this.getThread(thread.id);
+		}))).filter((thread) => thread !== null);
+	}
+	async getThread(threadId) {
+		const thread = (await this.gmail.users.threads.get({
+			id: threadId,
+			userId: this.userId,
+			format: "full",
+			auth: this.auth
+		})).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 ?? /* @__PURE__ */ 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 } : void 0
+		};
+	}
+	async listMessagesSince(query) {
+		const after = query.since ? Math.floor(query.since.getTime() / 1e3) : void 0;
+		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] : void 0,
+			q: q.join(" "),
+			includeSpamTrash: this.includeSpamTrash,
+			auth: this.auth
+		});
+		return {
+			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);
+			}))).filter((message) => message !== null),
+			nextPageToken: response.data.nextPageToken ?? void 0
+		};
+	}
+	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)) : /* @__PURE__ */ 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 ?? void 0,
+			sentAt: timestamp,
+			receivedAt: timestamp,
+			textBody: text ?? void 0,
+			htmlBody: html ?? void 0,
+			attachments,
+			headers: Object.fromEntries(headers.map((header) => [header.name ?? "", header.value ?? ""])),
+			metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+		};
+	}
+};
+function headerValue(headers, name) {
+	const value = headers.find((candidate) => candidate.name?.toLowerCase() === name.toLowerCase())?.value;
+	return typeof value === "string" ? value : void 0;
+}
+function parseAddress(header) {
+	const addresses = parseAddressList(header);
+	if (addresses.length === 0) return null;
+	return addresses[0] ?? null;
+}
+function inferFallbackAddress(field, messageId) {
+	return { email: `${field}-${messageId ? messageId.replace(/[^\w]/g, "").slice(-8) || "unknown" : "unknown"}@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 = /* @__PURE__ */ 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 ?? void 0
+		});
+		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");
+}
+
+//#endregion
+export { GmailInboundProvider };

package/dist/integrations/providers/impls/gmail-outbound.d.ts

@@ -0,0 +1,18 @@
+import { EmailOutboundMessage, EmailOutboundProvider, EmailOutboundResult } from "../email.js";
+import { gmail_v1 } from "googleapis";
+
+//#region src/integrations/providers/impls/gmail-outbound.d.ts
+interface GmailOutboundProviderOptions {
+  auth: gmail_v1.Options['auth'];
+  userId?: string;
+  gmail?: gmail_v1.Gmail;
+}
+declare class GmailOutboundProvider implements EmailOutboundProvider {
+  private readonly gmail;
+  private readonly userId;
+  private readonly auth;
+  constructor(options: GmailOutboundProviderOptions);
+  sendEmail(message: EmailOutboundMessage): Promise<EmailOutboundResult>;
+}
+//#endregion
+export { GmailOutboundProvider, GmailOutboundProviderOptions };

package/dist/integrations/providers/impls/gmail-outbound.js

@@ -0,0 +1,105 @@
+import { google } from "googleapis";
+
+//#region src/integrations/providers/impls/gmail-outbound.ts
+var GmailOutboundProvider = class {
+	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
+		});
+		return {
+			id: response.data.id ?? "",
+			providerMessageId: response.data.id ?? void 0,
+			queuedAt: /* @__PURE__ */ 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\n--${boundaryMain}\r\n`;
+		body += buildAlternativePart(hasText, hasHtml, boundaryAlt, message);
+		attachments.forEach((attachment) => {
+			body += buildAttachmentPart(boundaryMain, attachment);
+		});
+		body += `\r\n--${boundaryMain}--`;
+	} else if (hasText && hasHtml) {
+		headers.push(`Content-Type: multipart/alternative; boundary="${boundaryAlt}"`);
+		body += `\r\n--${boundaryAlt}\r\n`;
+		body += buildTextPart("text/plain; charset=\"utf-8\"", message.textBody ?? "");
+		body += `\r\n--${boundaryAlt}\r\n`;
+		body += buildTextPart("text/html; charset=\"utf-8\"", message.htmlBody ?? "");
+		body += `\r\n--${boundaryAlt}--`;
+	} else if (hasHtml) {
+		headers.push("Content-Type: text/html; charset=\"utf-8\"");
+		body += `\r\n\r\n${message.htmlBody}`;
+	} else {
+		headers.push("Content-Type: text/plain; charset=\"utf-8\"");
+		body += `\r\n\r\n${message.textBody ?? ""}`;
+	}
+	const mime = `${headers.join("\r\n")}${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\n`;
+	content += "\r\n";
+	if (hasText) {
+		content += `--${boundary}\r\n`;
+		content += buildTextPart("text/plain; charset=\"utf-8\"", message.textBody ?? "");
+	}
+	if (hasHtml) {
+		content += `\r\n--${boundary}\r\n`;
+		content += buildTextPart("text/html; charset=\"utf-8\"", message.htmlBody ?? "");
+	}
+	content += `\r\n--${boundary}--`;
+	return content;
+}
+function buildTextPart(contentType, content) {
+	return `Content-Type: ${contentType}\r\nContent-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\n--${boundary}\r\nContent-Type: ${attachment.contentType}; name="${attachment.filename}"\r\nContent-Transfer-Encoding: base64\r
+Content-Disposition: attachment; filename="${attachment.filename}"\r\n\r\n` + encoded;
+}
+function formatAddress(address) {
+	if (address.name) return `"${address.name}" <${address.email}>`;
+	return address.email;
+}
+
+//#endregion
+export { GmailOutboundProvider };

package/dist/integrations/providers/impls/google-calendar.d.ts

@@ -0,0 +1,23 @@
+import { CalendarEvent, CalendarEventInput, CalendarEventUpdateInput, CalendarListEventsQuery, CalendarListEventsResult, CalendarProvider } from "../calendar.js";
+import { calendar_v3 } from "googleapis";
+
+//#region src/integrations/providers/impls/google-calendar.d.ts
+interface GoogleCalendarProviderOptions {
+  auth: calendar_v3.Options['auth'];
+  calendar?: calendar_v3.Calendar;
+  calendarId?: string;
+}
+declare class GoogleCalendarProvider implements CalendarProvider {
+  private readonly calendar;
+  private readonly defaultCalendarId;
+  private readonly auth;
+  constructor(options: GoogleCalendarProviderOptions);
+  listEvents(query: CalendarListEventsQuery): Promise<CalendarListEventsResult>;
+  createEvent(input: CalendarEventInput): Promise<CalendarEvent>;
+  updateEvent(calendarId: string, eventId: string, input: CalendarEventUpdateInput): Promise<CalendarEvent>;
+  deleteEvent(calendarId: string, eventId: string): Promise<void>;
+  private fromGoogleEvent;
+  private toGoogleEvent;
+}
+//#endregion
+export { GoogleCalendarProvider, GoogleCalendarProviderOptions };

package/dist/integrations/providers/impls/google-calendar.js

@@ -0,0 +1,154 @@
+import { google } from "googleapis";
+
+//#region src/integrations/providers/impls/google-calendar.ts
+var GoogleCalendarProvider = class {
+	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
+		});
+		return {
+			events: response.data.items?.map((item) => this.fromGoogleEvent(query.calendarId ?? this.defaultCalendarId, item)) ?? [],
+			nextPageToken: response.data.nextPageToken ?? void 0
+		};
+	}
+	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 : void 0,
+			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 : void 0,
+			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 ?? void 0,
+			optional: attendee.optional ?? void 0,
+			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 ?? void 0,
+			location: event.location ?? void 0,
+			start,
+			end,
+			allDay: event.start?.date ? true : void 0,
+			attendees,
+			reminders,
+			conferenceLink: event.hangoutLink ?? event.conferenceData?.entryPoints?.find((entry) => entry.uri)?.uri ?? void 0,
+			metadata,
+			createdAt: event.created ? new Date(event.created) : void 0,
+			updatedAt: event.updated ? new Date(event.updated) : void 0
+		};
+	}
+	toGoogleEvent(input) {
+		const event = {};
+		if ("title" in input && input.title) event.summary = input.title;
+		if (input.description !== void 0) event.description = input.description;
+		if (input.location !== void 0) 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 /* @__PURE__ */ new Date();
+	if (time.dateTime) return new Date(time.dateTime);
+	if (time.date) return /* @__PURE__ */ new Date(`${time.date}T00:00:00`);
+	return /* @__PURE__ */ 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 void 0;
+	return [
+		"needsAction",
+		"declined",
+		"tentative",
+		"accepted"
+	].includes(status) ? status : void 0;
+}
+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 : void 0;
+}
+
+//#endregion
+export { GoogleCalendarProvider };

package/dist/integrations/providers/impls/index.d.ts

@@ -0,0 +1,15 @@
+import { ElevenLabsVoiceProvider, ElevenLabsVoiceProviderOptions } from "./elevenlabs-voice.js";
+import { GoogleCloudStorageProvider, GoogleCloudStorageProviderOptions } from "./gcs-storage.js";
+import { GmailInboundProvider, GmailInboundProviderOptions } from "./gmail-inbound.js";
+import { GmailOutboundProvider, GmailOutboundProviderOptions } from "./gmail-outbound.js";
+import { GoogleCalendarProvider, GoogleCalendarProviderOptions } from "./google-calendar.js";
+import { MistralLLMProvider, MistralLLMProviderOptions } from "./mistral-llm.js";
+import { MistralEmbeddingProvider, MistralEmbeddingProviderOptions } from "./mistral-embedding.js";
+import { QdrantVectorProvider, QdrantVectorProviderOptions } from "./qdrant-vector.js";
+import { StripePaymentsProvider, StripePaymentsProviderOptions } from "./stripe-payments.js";
+import { PostmarkEmailProvider, PostmarkEmailProviderOptions } from "./postmark-email.js";
+import { TwilioSmsProvider, TwilioSmsProviderOptions } from "./twilio-sms.js";
+import { PowensAccount, PowensAccountListResponse, PowensBalance, PowensClient, PowensClientError, PowensClientOptions, PowensConnectionStatusResponse, PowensEnvironment, PowensTransaction, PowensTransactionListResponse } from "./powens-client.js";
+import { PowensOpenBankingProvider, PowensOpenBankingProviderOptions } from "./powens-openbanking.js";
+import { IntegrationProviderFactory } from "./provider-factory.js";
+export { ElevenLabsVoiceProvider, ElevenLabsVoiceProviderOptions, GmailInboundProvider, GmailInboundProviderOptions, GmailOutboundProvider, GmailOutboundProviderOptions, GoogleCalendarProvider, GoogleCalendarProviderOptions, GoogleCloudStorageProvider, GoogleCloudStorageProviderOptions, IntegrationProviderFactory, MistralEmbeddingProvider, MistralEmbeddingProviderOptions, MistralLLMProvider, MistralLLMProviderOptions, PostmarkEmailProvider, PostmarkEmailProviderOptions, PowensAccount, PowensAccountListResponse, PowensBalance, PowensClient, PowensClientError, PowensClientOptions, PowensConnectionStatusResponse, PowensEnvironment, PowensOpenBankingProvider, PowensOpenBankingProviderOptions, PowensTransaction, PowensTransactionListResponse, QdrantVectorProvider, QdrantVectorProviderOptions, StripePaymentsProvider, StripePaymentsProviderOptions, TwilioSmsProvider, TwilioSmsProviderOptions };

package/dist/integrations/providers/impls/index.js

@@ -0,0 +1,16 @@
+import { ElevenLabsVoiceProvider } from "./elevenlabs-voice.js";
+import { GoogleCloudStorageProvider } from "./gcs-storage.js";
+import { GmailInboundProvider } from "./gmail-inbound.js";
+import { GmailOutboundProvider } from "./gmail-outbound.js";
+import { GoogleCalendarProvider } from "./google-calendar.js";
+import { MistralLLMProvider } from "./mistral-llm.js";
+import { MistralEmbeddingProvider } from "./mistral-embedding.js";
+import { QdrantVectorProvider } from "./qdrant-vector.js";
+import { StripePaymentsProvider } from "./stripe-payments.js";
+import { PostmarkEmailProvider } from "./postmark-email.js";
+import { TwilioSmsProvider } from "./twilio-sms.js";
+import { PowensClient, PowensClientError } from "./powens-client.js";
+import { PowensOpenBankingProvider } from "./powens-openbanking.js";
+import { IntegrationProviderFactory } from "./provider-factory.js";
+
+export { ElevenLabsVoiceProvider, GmailInboundProvider, GmailOutboundProvider, GoogleCalendarProvider, GoogleCloudStorageProvider, IntegrationProviderFactory, MistralEmbeddingProvider, MistralLLMProvider, PostmarkEmailProvider, PowensClient, PowensClientError, PowensOpenBankingProvider, QdrantVectorProvider, StripePaymentsProvider, TwilioSmsProvider };

package/dist/integrations/providers/impls/mistral-embedding.d.ts

@@ -0,0 +1,23 @@
+import { EmbeddingDocument, EmbeddingProvider, EmbeddingResult } from "../embedding.js";
+import { Mistral } from "@mistralai/mistralai";
+
+//#region src/integrations/providers/impls/mistral-embedding.d.ts
+interface MistralEmbeddingProviderOptions {
+  apiKey: string;
+  defaultModel?: string;
+  serverURL?: string;
+  client?: Mistral;
+}
+declare class MistralEmbeddingProvider implements EmbeddingProvider {
+  private readonly client;
+  private readonly defaultModel;
+  constructor(options: MistralEmbeddingProviderOptions);
+  embedDocuments(documents: EmbeddingDocument[], options?: {
+    model?: string;
+  }): Promise<EmbeddingResult[]>;
+  embedQuery(query: string, options?: {
+    model?: string;
+  }): Promise<EmbeddingResult>;
+}
+//#endregion
+export { MistralEmbeddingProvider, MistralEmbeddingProviderOptions };

package/dist/integrations/providers/impls/mistral-embedding.js

@@ -0,0 +1,41 @@
+import { Mistral } from "@mistralai/mistralai";
+
+//#region src/integrations/providers/impls/mistral-embedding.ts
+var MistralEmbeddingProvider = class {
+	client;
+	defaultModel;
+	constructor(options) {
+		if (!options.apiKey) throw new Error("MistralEmbeddingProvider requires an apiKey");
+		this.client = options.client ?? new Mistral({
+			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)])) : void 0
+		}));
+	}
+	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;
+	}
+};
+
+//#endregion
+export { MistralEmbeddingProvider };

package/dist/integrations/providers/impls/mistral-llm.d.ts

@@ -0,0 +1,31 @@
+import { LLMChatOptions, LLMMessage, LLMProvider, LLMResponse, LLMStreamChunk } from "../llm.js";
+import { Mistral } from "@mistralai/mistralai";
+
+//#region src/integrations/providers/impls/mistral-llm.d.ts
+interface MistralLLMProviderOptions {
+  apiKey: string;
+  defaultModel?: string;
+  serverURL?: string;
+  client?: Mistral;
+  userAgentSuffix?: string;
+}
+declare class MistralLLMProvider implements LLMProvider {
+  private readonly client;
+  private readonly defaultModel;
+  constructor(options: MistralLLMProviderOptions);
+  chat(messages: LLMMessage[], options?: LLMChatOptions): Promise<LLMResponse>;
+  stream(messages: LLMMessage[], options?: LLMChatOptions): AsyncIterable<LLMStreamChunk>;
+  countTokens(_messages: LLMMessage[]): Promise<{
+    promptTokens: number;
+  }>;
+  private buildChatRequest;
+  private buildLLMResponse;
+  private fromUsage;
+  private fromAssistantMessage;
+  private fromMistralToolCall;
+  private toMistralMessage;
+  private extractText;
+  private extractToolCalls;
+}
+//#endregion
+export { MistralLLMProvider, MistralLLMProviderOptions };