@contractspec/integration.providers-impls 3.7.5 → 3.7.7

package/dist/node/impls/index.js

@@ -204,79 +204,6 @@ class ComposioMcpProvider {
   }
 }
 
-// src/impls/composio-sdk.ts
-class ComposioSdkProvider {
-  config;
-  client;
-  constructor(config) {
-    this.config = config;
-  }
-  async executeTool(toolName, args) {
-    const client = await this.getClient();
-    const userId = args._userId ?? "default";
-    try {
-      const entity = await client.getEntity(userId);
-      const result = await entity.execute(toolName, args);
-      return { success: true, data: result };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async searchTools(query) {
-    const client = await this.getClient();
-    try {
-      const tools = await client.actions.list({ query, limit: 20 });
-      return tools.map((t) => ({
-        name: t.name,
-        description: t.description ?? "",
-        toolkit: t.appName ?? "",
-        parameters: t.parameters ?? {}
-      }));
-    } catch {
-      return [];
-    }
-  }
-  async getConnectedAccounts(userId) {
-    const client = await this.getClient();
-    try {
-      const entity = await client.getEntity(userId);
-      const connections = await entity.getConnections();
-      return connections.map((c) => ({
-        id: c.id,
-        appName: c.appName,
-        status: c.status
-      }));
-    } catch {
-      return [];
-    }
-  }
-  async getMcpConfig(userId) {
-    const client = await this.getClient();
-    try {
-      const entity = await client.getEntity(userId);
-      return {
-        url: entity.getMcpUrl(),
-        headers: entity.getMcpHeaders()
-      };
-    } catch {
-      return;
-    }
-  }
-  async getClient() {
-    if (this.client)
-      return this.client;
-    const { Composio } = await import("@composio/core");
-    this.client = new Composio({
-      apiKey: this.config.apiKey,
-      ...this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}
-    });
-    return this.client;
-  }
-}
-
 // src/impls/composio-proxies.ts
 function composioToolName(toolkit, action) {
   return `${toolkit.toUpperCase()}_${action.toUpperCase()}`;
@@ -578,6 +505,79 @@ class ComposioGenericProxy {
   }
 }
 
+// src/impls/composio-sdk.ts
+class ComposioSdkProvider {
+  config;
+  client;
+  constructor(config) {
+    this.config = config;
+  }
+  async executeTool(toolName, args) {
+    const client = await this.getClient();
+    const userId = args._userId ?? "default";
+    try {
+      const entity = await client.getEntity(userId);
+      const result = await entity.execute(toolName, args);
+      return { success: true, data: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async searchTools(query) {
+    const client = await this.getClient();
+    try {
+      const tools = await client.actions.list({ query, limit: 20 });
+      return tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        toolkit: t.appName ?? "",
+        parameters: t.parameters ?? {}
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getConnectedAccounts(userId) {
+    const client = await this.getClient();
+    try {
+      const entity = await client.getEntity(userId);
+      const connections = await entity.getConnections();
+      return connections.map((c) => ({
+        id: c.id,
+        appName: c.appName,
+        status: c.status
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getMcpConfig(userId) {
+    const client = await this.getClient();
+    try {
+      const entity = await client.getEntity(userId);
+      return {
+        url: entity.getMcpUrl(),
+        headers: entity.getMcpHeaders()
+      };
+    } catch {
+      return;
+    }
+  }
+  async getClient() {
+    if (this.client)
+      return this.client;
+    const { Composio } = await import("@composio/core");
+    this.client = new Composio({
+      apiKey: this.config.apiKey,
+      ...this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}
+    });
+    return this.client;
+  }
+}
+
 // src/impls/composio-fallback-resolver.ts
 class ComposioFallbackResolver {
   mcpProvider;
@@ -3942,476 +3942,519 @@ function asString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 
-// src/impls/mistral-llm.ts
-import { Mistral } from "@mistralai/mistralai";
+// src/impls/jira.ts
+import { Buffer as Buffer3 } from "node:buffer";
 
-class MistralLLMProvider {
-  client;
-  defaultModel;
+class JiraProjectManagementProvider {
+  siteUrl;
+  authHeader;
+  defaults;
+  fetchFn;
   constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("MistralLLMProvider requires an apiKey");
+    this.siteUrl = normalizeSiteUrl(options.siteUrl);
+    this.authHeader = buildAuthHeader(options.email, options.apiToken);
+    this.defaults = {
+      projectKey: options.projectKey,
+      issueType: options.issueType,
+      defaultLabels: options.defaultLabels,
+      issueTypeMap: options.issueTypeMap
+    };
+    this.fetchFn = options.fetch ?? fetch;
+  }
+  async createWorkItem(input) {
+    const projectKey = input.projectId ?? this.defaults.projectKey;
+    if (!projectKey) {
+      throw new Error("Jira projectKey is required to create work items.");
     }
-    this.client = options.client ?? new Mistral({
-      apiKey: options.apiKey,
-      serverURL: options.serverURL,
-      userAgent: options.userAgentSuffix ? `${options.userAgentSuffix}` : undefined
+    const issueType = resolveIssueType(input.type, this.defaults);
+    const description = buildJiraDescription(input.description);
+    const labels = mergeLabels(this.defaults.defaultLabels, input.tags);
+    const priority = mapPriority(input.priority);
+    const payload = {
+      fields: {
+        project: { key: projectKey },
+        summary: input.title,
+        description,
+        issuetype: { name: issueType },
+        labels,
+        priority: priority ? { name: priority } : undefined,
+        assignee: input.assigneeId ? { accountId: input.assigneeId } : undefined,
+        duedate: input.dueDate ? input.dueDate.toISOString().slice(0, 10) : undefined
+      }
+    };
+    const response = await this.fetchFn(`${this.siteUrl}/rest/api/3/issue`, {
+      method: "POST",
+      headers: {
+        Authorization: this.authHeader,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(payload)
     });
-    this.defaultModel = options.defaultModel ?? "mistral-large-latest";
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Jira API error (${response.status}): ${body || response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      id: data.id ?? data.key ?? "",
+      title: input.title,
+      url: data.key ? `${this.siteUrl}/browse/${data.key}` : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: projectKey,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
   }
-  async chat(messages, options = {}) {
-    const request = this.buildChatRequest(messages, options);
-    const response = await this.client.chat.complete(request);
-    return this.buildLLMResponse(response);
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
+    }
+    return created;
   }
-  async* stream(messages, options = {}) {
-    const request = this.buildChatRequest(messages, options);
-    request.stream = true;
-    const stream = await this.client.chat.stream(request);
-    const aggregatedParts = [];
-    const aggregatedToolCalls = [];
-    let usage;
-    let finishReason;
-    for await (const event of stream) {
-      for (const choice of event.data.choices) {
-        const delta = choice.delta;
-        if (typeof delta.content === "string") {
-          if (delta.content.length > 0) {
-            aggregatedParts.push({ type: "text", text: delta.content });
-            yield {
-              type: "message_delta",
-              delta: { type: "text", text: delta.content },
-              index: choice.index
-            };
-          }
-        } else if (Array.isArray(delta.content)) {
-          for (const chunk of delta.content) {
-            if (chunk.type === "text" && "text" in chunk) {
-              aggregatedParts.push({ type: "text", text: chunk.text });
-              yield {
-                type: "message_delta",
-                delta: { type: "text", text: chunk.text },
-                index: choice.index
-              };
-            }
-          }
-        }
-        if (delta.toolCalls) {
-          let localIndex = 0;
-          for (const call of delta.toolCalls) {
-            const toolCall = this.fromMistralToolCall(call, localIndex);
-            aggregatedToolCalls.push(toolCall);
-            yield {
-              type: "tool_call",
-              call: toolCall,
-              index: choice.index
-            };
-            localIndex += 1;
-          }
-        }
-        if (choice.finishReason && choice.finishReason !== "null") {
-          finishReason = choice.finishReason;
-        }
-      }
-      if (event.data.usage) {
-        const usageEntry = this.fromUsage(event.data.usage);
-        if (usageEntry) {
-          usage = usageEntry;
-          yield { type: "usage", usage: usageEntry };
-        }
-      }
-    }
-    const message = {
-      role: "assistant",
-      content: aggregatedParts.length ? aggregatedParts : [{ type: "text", text: "" }]
-    };
-    if (aggregatedToolCalls.length > 0) {
-      message.content = [
-        ...aggregatedToolCalls,
-        ...aggregatedParts.length ? aggregatedParts : []
-      ];
-    }
-    yield {
-      type: "end",
-      response: {
-        message,
-        usage,
-        finishReason: mapFinishReason(finishReason)
-      }
-    };
-  }
-  async countTokens(_messages) {
-    throw new Error("Mistral API does not currently support token counting");
-  }
-  buildChatRequest(messages, options) {
-    const model = options.model ?? this.defaultModel;
-    const mappedMessages = messages.map((message) => this.toMistralMessage(message));
-    const request = {
-      model,
-      messages: mappedMessages
-    };
-    if (options.temperature != null) {
-      request.temperature = options.temperature;
-    }
-    if (options.topP != null) {
-      request.topP = options.topP;
-    }
-    if (options.maxOutputTokens != null) {
-      request.maxTokens = options.maxOutputTokens;
-    }
-    if (options.stopSequences?.length) {
-      request.stop = options.stopSequences.length === 1 ? options.stopSequences[0] : options.stopSequences;
-    }
-    if (options.tools?.length) {
-      request.tools = options.tools.map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: typeof tool.inputSchema === "object" && tool.inputSchema !== null ? tool.inputSchema : {}
-        }
-      }));
-    }
-    if (options.responseFormat === "json") {
-      request.responseFormat = { type: "json_object" };
-    }
-    return request;
-  }
-  buildLLMResponse(response) {
-    const firstChoice = response.choices[0];
-    if (!firstChoice) {
-      return {
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "" }]
-        },
-        usage: this.fromUsage(response.usage),
-        raw: response
-      };
-    }
-    const message = this.fromAssistantMessage(firstChoice.message);
-    return {
-      message,
-      usage: this.fromUsage(response.usage),
-      finishReason: mapFinishReason(firstChoice.finishReason),
-      raw: response
-    };
+}
+function normalizeSiteUrl(siteUrl) {
+  return siteUrl.replace(/\/$/, "");
+}
+function buildAuthHeader(email, apiToken) {
+  const token = Buffer3.from(`${email}:${apiToken}`).toString("base64");
+  return `Basic ${token}`;
+}
+function resolveIssueType(type, defaults) {
+  if (type && defaults.issueTypeMap?.[type]) {
+    return defaults.issueTypeMap[type] ?? defaults.issueType ?? "Task";
   }
-  fromUsage(usage) {
-    if (!usage)
+  return defaults.issueType ?? "Task";
+}
+function mapPriority(priority) {
+  switch (priority) {
+    case "urgent":
+      return "Highest";
+    case "high":
+      return "High";
+    case "medium":
+      return "Medium";
+    case "low":
+      return "Low";
+    case "none":
+    default:
       return;
-    return {
-      promptTokens: usage.promptTokens ?? 0,
-      completionTokens: usage.completionTokens ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
   }
-  fromAssistantMessage(message) {
-    const parts = [];
-    if (typeof message.content === "string") {
-      parts.push({ type: "text", text: message.content });
-    } else if (Array.isArray(message.content)) {
-      message.content.forEach((chunk) => {
-        if (chunk.type === "text" && "text" in chunk) {
-          parts.push({ type: "text", text: chunk.text });
-        }
-      });
-    }
-    const toolCalls = message.toolCalls?.map((call, index) => this.fromMistralToolCall(call, index)) ?? [];
-    if (toolCalls.length > 0) {
-      parts.splice(0, 0, ...toolCalls);
-    }
-    if (parts.length === 0) {
-      parts.push({ type: "text", text: "" });
-    }
-    return {
-      role: "assistant",
-      content: parts
+}
+function mergeLabels(defaults, tags) {
+  const merged = new Set;
+  (defaults ?? []).forEach((label) => merged.add(label));
+  (tags ?? []).forEach((tag) => merged.add(tag));
+  const result = [...merged];
+  return result.length > 0 ? result : undefined;
+}
+function buildJiraDescription(description) {
+  if (!description)
+    return;
+  const lines = description.split(/\r?\n/).filter((line) => line.trim());
+  const content = lines.map((line) => ({
+    type: "paragraph",
+    content: [{ type: "text", text: line }]
+  }));
+  if (content.length === 0)
+    return;
+  return { type: "doc", version: 1, content };
+}
+
+// src/impls/linear.ts
+import { LinearClient } from "@linear/sdk";
+var PRIORITY_MAP = {
+  urgent: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+  none: 0
+};
+
+class LinearProjectManagementProvider {
+  client;
+  defaults;
+  constructor(options) {
+    this.client = options.client ?? new LinearClient({ apiKey: options.apiKey });
+    this.defaults = {
+      teamId: options.teamId,
+      projectId: options.projectId,
+      assigneeId: options.assigneeId,
+      stateId: options.stateId,
+      labelIds: options.labelIds,
+      tagLabelMap: options.tagLabelMap
     };
   }
-  fromMistralToolCall(call, index) {
-    const args = typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments);
+  async createWorkItem(input) {
+    const teamId = this.defaults.teamId;
+    if (!teamId) {
+      throw new Error("Linear teamId is required to create work items.");
+    }
+    const payload = await this.client.createIssue({
+      teamId,
+      title: input.title,
+      description: input.description,
+      priority: mapPriority2(input.priority),
+      estimate: input.estimate,
+      assigneeId: input.assigneeId ?? this.defaults.assigneeId,
+      projectId: input.projectId ?? this.defaults.projectId,
+      stateId: this.defaults.stateId,
+      labelIds: resolveLabelIds(this.defaults, input.tags)
+    });
+    const issue = await payload.issue;
+    const state = issue ? await issue.state : undefined;
     return {
-      type: "tool-call",
-      id: call.id ?? `tool-call-${index}`,
-      name: call.function.name,
-      arguments: args
+      id: issue?.id ?? "",
+      title: issue?.title ?? input.title,
+      url: issue?.url ?? undefined,
+      status: state?.name ?? undefined,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: input.projectId ?? this.defaults.projectId,
+      externalId: input.externalId,
+      metadata: input.metadata
     };
   }
-  toMistralMessage(message) {
-    const textContent = this.extractText(message.content);
-    const toolCalls = this.extractToolCalls(message);
-    switch (message.role) {
-      case "system":
-        return {
-          role: "system",
-          content: textContent ?? ""
-        };
-      case "user":
-        return {
-          role: "user",
-          content: textContent ?? ""
-        };
-      case "assistant":
-        return {
-          role: "assistant",
-          content: toolCalls.length > 0 ? null : textContent ?? "",
-          toolCalls: toolCalls.length > 0 ? toolCalls : undefined
-        };
-      case "tool":
-        return {
-          role: "tool",
-          content: textContent ?? "",
-          toolCallId: message.toolCallId ?? toolCalls[0]?.id
-        };
-      default:
-        return {
-          role: "user",
-          content: textContent ?? ""
-        };
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
     }
-  }
-  extractText(parts) {
-    const textParts = parts.filter((part) => part.type === "text").map((part) => part.text);
-    if (textParts.length === 0)
-      return null;
-    return textParts.join("");
-  }
-  extractToolCalls(message) {
-    const toolCallParts = message.content.filter((part) => part.type === "tool-call");
-    return toolCallParts.map((call, index) => ({
-      id: call.id ?? `call_${index}`,
-      type: "function",
-      index,
-      function: {
-        name: call.name,
-        arguments: call.arguments
-      }
-    }));
+    return created;
   }
 }
-function mapFinishReason(reason) {
-  if (!reason)
+function mapPriority2(priority) {
+  if (!priority)
     return;
-  const normalized = reason.toLowerCase();
-  switch (normalized) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_call":
-    case "tool_calls":
-      return "tool_call";
-    case "content_filter":
-      return "content_filter";
-    default:
-      return;
+  return PRIORITY_MAP[priority] ?? undefined;
+}
+function resolveLabelIds(defaults, tags) {
+  const labelIds = new Set;
+  (defaults.labelIds ?? []).forEach((id) => labelIds.add(id));
+  if (tags && defaults.tagLabelMap) {
+    tags.forEach((tag) => {
+      const mapped = defaults.tagLabelMap?.[tag];
+      if (mapped)
+        labelIds.add(mapped);
+    });
   }
+  const merged = [...labelIds];
+  return merged.length > 0 ? merged : undefined;
 }
 
-// src/impls/mistral-embedding.ts
-import { Mistral as Mistral2 } from "@mistralai/mistralai";
-
-class MistralEmbeddingProvider {
-  client;
-  defaultModel;
+// src/impls/messaging-github.ts
+class GithubMessagingProvider {
+  token;
+  defaultOwner;
+  defaultRepo;
+  apiBaseUrl;
   constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("MistralEmbeddingProvider requires an apiKey");
-    }
-    this.client = options.client ?? new Mistral2({
-      apiKey: options.apiKey,
-      serverURL: options.serverURL
+    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 })
     });
-    this.defaultModel = options.defaultModel ?? "mistral-embed";
+    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 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)
+  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 })
     });
-    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)])) : undefined
-    }));
+    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
+      }
+    };
   }
-  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");
+  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 result;
+    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;
+}
 
-// src/impls/mistral-stt.ts
-var DEFAULT_BASE_URL4 = "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;
+// src/impls/messaging-slack.ts
+class SlackMessagingProvider {
+  botToken;
+  defaultChannelId;
+  apiBaseUrl;
   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_URL4);
-    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.botToken = options.botToken;
+    this.defaultChannelId = options.defaultChannelId;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://slack.com/api";
   }
-  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);
+  async sendMessage(input) {
+    const channel = input.channelId ?? input.recipientId ?? this.defaultChannelId;
+    if (!channel) {
+      throw new Error("Slack sendMessage requires channelId, recipientId, or defaultChannelId.");
     }
-    const response = await this.fetchImpl(`${this.baseUrl}/audio/transcriptions`, {
+    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.apiKey}`
+        authorization: `Bearer ${this.botToken}`,
+        "content-type": "application/json"
       },
-      body: formData
+      body: JSON.stringify(payload)
     });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Mistral transcription request failed (${response.status}): ${body}`);
+    const body = await response.json();
+    if (!response.ok || !body.ok || !body.ts) {
+      throw new Error(`Slack sendMessage failed: ${body.error ?? `HTTP_${response.status}`}`);
     }
-    const payload = await response.json();
-    return toTranscriptionResult(payload, input);
+    return {
+      id: `slack:${body.channel ?? channel}:${body.ts}`,
+      providerMessageId: body.ts,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        channelId: body.channel ?? channel
+      }
+    };
   }
-}
-function toTranscriptionResult(payload, input) {
-  const record = asRecord2(payload);
-  const text = readString3(record, "text") ?? "";
-  const language = readString3(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
+  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
+      }
+    };
   }
-  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 [];
+
+// 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";
   }
-  const parsed = [];
-  for (const entry of record.segments) {
-    const segmentRecord = asRecord2(entry);
-    const text = readString3(segmentRecord, "text");
-    if (!text) {
-      continue;
+  async sendMessage(input) {
+    const to = input.recipientId;
+    if (!to) {
+      throw new Error("Meta WhatsApp sendMessage requires recipientId.");
     }
-    const startSeconds = readNumber2(segmentRecord, "start") ?? 0;
-    const endSeconds = readNumber2(segmentRecord, "end") ?? startSeconds;
-    parsed.push({
-      text,
-      startMs: secondsToMs(startSeconds),
-      endMs: secondsToMs(endSeconds),
-      speakerId: readString3(segmentRecord, "speaker") ?? undefined,
-      confidence: readNumber2(segmentRecord, "confidence"),
-      wordTimings: parseWordTimings(segmentRecord.words)
+    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
+      }
+    };
   }
-  return parsed;
 }
-function parseWordTimings(value) {
-  if (!Array.isArray(value)) {
-    return [];
+
+// src/impls/messaging-whatsapp-twilio.ts
+import { Buffer as Buffer4 } from "node:buffer";
+
+class TwilioWhatsappMessagingProvider {
+  accountSid;
+  authToken;
+  fromNumber;
+  constructor(options) {
+    this.accountSid = options.accountSid;
+    this.authToken = options.authToken;
+    this.fromNumber = options.fromNumber;
   }
-  const words = [];
-  for (const entry of value) {
-    const wordRecord = asRecord2(entry);
-    const word = readString3(wordRecord, "word");
-    const startSeconds = readNumber2(wordRecord, "start");
-    const endSeconds = readNumber2(wordRecord, "end");
-    if (!word || startSeconds == null || endSeconds == null) {
-      continue;
+  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.");
     }
-    words.push({
-      word,
-      startMs: secondsToMs(startSeconds),
-      endMs: secondsToMs(endSeconds),
-      confidence: readNumber2(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;
+    if (!from) {
+      throw new Error("Twilio WhatsApp sendMessage requires channelId or configured fromNumber.");
     }
-    seen.add(segment.speakerId);
-    speakers.push({
-      id: segment.speakerId,
-      name: segment.speakerName
+    const params = new URLSearchParams;
+    params.set("To", to);
+    params.set("From", from);
+    params.set("Body", input.text);
+    const auth = Buffer4.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
+      }
+    };
   }
-  return speakers;
 }
-function normalizeBaseUrl(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-function asRecord2(value) {
-  if (value && typeof value === "object") {
+function normalizeWhatsappAddress(value) {
+  if (!value)
+    return null;
+  if (value.startsWith("whatsapp:"))
     return value;
-  }
-  return {};
-}
-function readString3(record, key) {
-  const value = record[key];
-  return typeof value === "string" ? value : undefined;
-}
-function readNumber2(record, key) {
-  const value = record[key];
-  return typeof value === "number" ? value : undefined;
+  return `whatsapp:${value}`;
 }
-function secondsToMs(value) {
-  return Math.round(value * 1000);
+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";
+  }
 }
 
 // src/impls/mistral-conversational.session.ts
@@ -4487,876 +4530,825 @@ class MistralConversationSession {
       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_URL5 = "https://api.mistral.ai/v1";
-var DEFAULT_MODEL2 = "mistral-small-latest";
-var DEFAULT_VOICE = "default";
-
-class MistralConversationalProvider {
-  apiKey;
-  defaultModel;
-  defaultVoiceId;
-  baseUrl;
-  fetchImpl;
-  sttProvider;
-  constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("MistralConversationalProvider requires an apiKey");
-    }
-    this.apiKey = options.apiKey;
-    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL2;
-    this.defaultVoiceId = options.defaultVoiceId ?? DEFAULT_VOICE;
-    this.baseUrl = normalizeBaseUrl2(options.serverURL ?? DEFAULT_BASE_URL5);
-    this.fetchImpl = options.fetchImpl ?? fetch;
-    this.sttProvider = options.sttProvider ?? new MistralSttProvider({
-      apiKey: options.apiKey,
-      defaultModel: options.sttOptions?.defaultModel,
-      defaultLanguage: options.sttOptions?.defaultLanguage,
-      serverURL: options.sttOptions?.serverURL ?? options.serverURL,
-      fetchImpl: this.fetchImpl
-    });
-  }
-  async startSession(config) {
-    return new MistralConversationSession({
-      sessionConfig: {
-        ...config,
-        voiceId: config.voiceId || this.defaultVoiceId
-      },
-      defaultModel: this.defaultModel,
-      complete: (history, sessionConfig) => this.completeConversation(history, sessionConfig),
-      sttProvider: this.sttProvider
-    });
-  }
-  async listVoices() {
-    return [
-      {
-        id: this.defaultVoiceId,
-        name: "Mistral Default Voice",
-        description: "Default conversational voice profile.",
-        capabilities: ["conversational"]
-      }
-    ];
-  }
-  async completeConversation(history, sessionConfig) {
-    const model = sessionConfig.llmModel ?? this.defaultModel;
-    const messages = [];
-    if (sessionConfig.systemPrompt) {
-      messages.push({ role: "system", content: sessionConfig.systemPrompt });
-    }
-    for (const item of history) {
-      messages.push({ role: item.role, content: item.content });
-    }
-    const response = await this.fetchImpl(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model,
-        messages
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Mistral conversational request failed (${response.status}): ${body}`);
-    }
-    const payload = await response.json();
-    return readAssistantText(payload);
-  }
-}
-function normalizeBaseUrl2(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-function readAssistantText(payload) {
-  const record = asRecord3(payload);
-  const choices = Array.isArray(record.choices) ? record.choices : [];
-  const firstChoice = asRecord3(choices[0]);
-  const message = asRecord3(firstChoice.message);
-  if (typeof message.content === "string") {
-    return message.content;
-  }
-  if (Array.isArray(message.content)) {
-    const textParts = message.content.map((part) => {
-      const entry = asRecord3(part);
-      const text = entry.text;
-      return typeof text === "string" ? text : "";
-    }).filter((text) => text.length > 0);
-    return textParts.join("");
-  }
-  return "";
-}
-function asRecord3(value) {
-  if (value && typeof value === "object") {
-    return value;
-  }
-  return {};
-}
-
-// src/impls/qdrant-vector.ts
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-class QdrantVectorProvider {
-  client;
-  createCollectionIfMissing;
-  distance;
-  constructor(options) {
-    this.client = options.client ?? new QdrantClient({
-      url: options.url,
-      apiKey: options.apiKey,
-      ...options.clientParams
+    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.createCollectionIfMissing = options.createCollectionIfMissing ?? true;
-    this.distance = options.distance ?? "Cosine";
+    this.queue.close();
+    return summary;
   }
-  async upsert(request) {
-    if (request.documents.length === 0)
+  async handleUserText(text) {
+    if (this.closed) {
       return;
-    const firstDocument = request.documents[0];
-    if (!firstDocument)
+    }
+    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 vectorSize = firstDocument.vector.length;
-    if (this.createCollectionIfMissing) {
-      await this.ensureCollection(request.collection, vectorSize);
     }
-    const points = request.documents.map((document) => ({
-      id: document.id,
-      vector: document.vector,
-      payload: {
-        ...document.payload,
-        ...document.namespace ? { namespace: document.namespace } : {},
-        ...document.expiresAt ? { expiresAt: document.expiresAt.toISOString() } : {}
-      }
-    }));
-    await this.client.upsert(request.collection, {
-      wait: true,
-      points
+    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
     });
-  }
-  async search(query) {
-    const results = await this.client.search(query.collection, {
-      vector: query.vector,
-      limit: query.topK,
-      filter: query.filter,
-      score_threshold: query.scoreThreshold,
-      with_payload: true,
-      with_vector: false
+    this.queue.push({
+      type: "transcript",
+      role: "agent",
+      text: finalAssistantText,
+      timestamp: assistantStart
     });
-    return results.map((item) => ({
-      id: String(item.id),
-      score: item.score,
-      payload: item.payload ?? undefined,
-      namespace: typeof item.payload === "object" && item.payload !== null ? item.payload.namespace : undefined
-    }));
-  }
-  async delete(request) {
-    await this.client.delete(request.collection, {
-      wait: true,
-      points: request.ids
+    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 });
   }
-  async ensureCollection(collectionName, vectorSize) {
-    try {
-      await this.client.getCollection(collectionName);
-    } catch (_error) {
-      await this.client.createCollection(collectionName, {
-        vectors: {
-          size: vectorSize,
-          distance: this.distance
-        }
-      });
+  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/supabase-psql.ts
-import { Buffer as Buffer3 } from "node:buffer";
-import { sql as drizzleSql } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
+// src/impls/mistral-stt.ts
+var DEFAULT_BASE_URL4 = "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 SupabasePostgresProvider {
-  client;
-  db;
-  ownsClient;
-  createDrizzle;
-  constructor(options = {}) {
-    this.createDrizzle = options.createDrizzle ?? ((client) => drizzle(client));
-    if (options.db) {
-      if (!options.client) {
-        throw new Error("SupabasePostgresProvider requires a postgres client when db is provided.");
-      }
-      this.client = options.client;
-      this.db = options.db;
-      this.ownsClient = false;
-      return;
-    }
-    if (options.client) {
-      this.client = options.client;
-      this.ownsClient = false;
-    } else {
-      if (!options.connectionString) {
-        throw new Error("SupabasePostgresProvider requires either a connectionString or a client.");
-      }
-      this.client = postgres(options.connectionString, {
-        max: options.maxConnections,
-        prepare: false,
-        ssl: resolveSslMode(options.sslMode)
-      });
-      this.ownsClient = true;
+class MistralSttProvider {
+  apiKey;
+  defaultModel;
+  defaultLanguage;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralSttProvider requires an apiKey");
     }
-    this.db = this.createDrizzle(this.client);
-  }
-  async query(statement, params = []) {
-    const query = buildParameterizedSql(statement, params);
-    const result = await this.db.execute(query);
-    const rows = asRows(result);
-    return {
-      rows,
-      rowCount: rows.length
-    };
+    this.apiKey = options.apiKey;
+    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL;
+    this.defaultLanguage = options.defaultLanguage;
+    this.baseUrl = normalizeBaseUrl(options.serverURL ?? DEFAULT_BASE_URL4);
+    this.fetchImpl = options.fetchImpl ?? fetch;
   }
-  async execute(statement, params = []) {
-    const query = buildParameterizedSql(statement, params);
-    await this.db.execute(query);
+  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);
   }
-  async transaction(run) {
-    const transactionResult = this.client.begin(async (transactionClient) => {
-      const transactionalProvider = new SupabasePostgresProvider({
-        client: transactionClient,
-        db: this.createDrizzle(transactionClient),
-        createDrizzle: this.createDrizzle
-      });
-      return run(transactionalProvider);
+}
+function toTranscriptionResult(payload, input) {
+  const record = asRecord2(payload);
+  const text = readString3(record, "text") ?? "";
+  const language = readString3(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
     });
-    return transactionResult;
   }
-  async close() {
-    if (this.ownsClient) {
-      await this.client.end({ timeout: 5 });
+  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 = asRecord2(entry);
+    const text = readString3(segmentRecord, "text");
+    if (!text) {
+      continue;
     }
+    const startSeconds = readNumber2(segmentRecord, "start") ?? 0;
+    const endSeconds = readNumber2(segmentRecord, "end") ?? startSeconds;
+    parsed.push({
+      text,
+      startMs: secondsToMs(startSeconds),
+      endMs: secondsToMs(endSeconds),
+      speakerId: readString3(segmentRecord, "speaker") ?? undefined,
+      confidence: readNumber2(segmentRecord, "confidence"),
+      wordTimings: parseWordTimings(segmentRecord.words)
+    });
   }
+  return parsed;
 }
-function buildParameterizedSql(statement, params) {
-  const segments = [];
-  const pattern = /\$(\d+)/g;
-  let cursor = 0;
-  for (const match of statement.matchAll(pattern)) {
-    const token = match[0];
-    const indexPart = match[1];
-    const start = match.index;
-    if (indexPart == null || start == null)
+function parseWordTimings(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const words = [];
+  for (const entry of value) {
+    const wordRecord = asRecord2(entry);
+    const word = readString3(wordRecord, "word");
+    const startSeconds = readNumber2(wordRecord, "start");
+    const endSeconds = readNumber2(wordRecord, "end");
+    if (!word || startSeconds == null || endSeconds == null) {
       continue;
-    const parameterIndex = Number(indexPart) - 1;
-    if (!Number.isInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= params.length) {
-      throw new Error(`SQL placeholder ${token} is out of bounds for ${params.length} parameter(s).`);
-    }
-    const staticSegment = statement.slice(cursor, start);
-    if (staticSegment.length > 0) {
-      segments.push(drizzleSql.raw(staticSegment));
-    }
-    const parameterValue = params[parameterIndex];
-    if (parameterValue === undefined) {
-      throw new Error(`SQL placeholder ${token} is missing a parameter value.`);
     }
-    const normalizedValue = normalizeParam(parameterValue);
-    segments.push(drizzleSql`${normalizedValue}`);
-    cursor = start + token.length;
-  }
-  const tailSegment = statement.slice(cursor);
-  if (tailSegment.length > 0) {
-    segments.push(drizzleSql.raw(tailSegment));
-  }
-  if (segments.length === 0) {
-    return drizzleSql.raw("");
+    words.push({
+      word,
+      startMs: secondsToMs(startSeconds),
+      endMs: secondsToMs(endSeconds),
+      confidence: readNumber2(wordRecord, "confidence")
+    });
   }
-  return drizzleSql.join(segments);
+  return words;
 }
-function normalizeParam(value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value instanceof Uint8Array) {
-    return Buffer3.from(value);
-  }
-  if (isPlainObject(value)) {
-    return JSON.stringify(value);
+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 value;
+  return speakers;
 }
-function asRows(result) {
-  if (!Array.isArray(result)) {
-    return [];
-  }
-  return result;
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-function isPlainObject(value) {
-  if (value == null || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
-  }
-  if (value instanceof Date) {
-    return false;
-  }
-  if (value instanceof Uint8Array) {
-    return false;
+function asRecord2(value) {
+  if (value && typeof value === "object") {
+    return value;
   }
-  return true;
+  return {};
 }
-function resolveSslMode(mode) {
-  switch (mode) {
-    case "allow":
-      return false;
-    case "prefer":
-      return "prefer";
-    case "require":
-    default:
-      return "require";
-  }
+function readString3(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+function readNumber2(record, key) {
+  const value = record[key];
+  return typeof value === "number" ? value : undefined;
+}
+function secondsToMs(value) {
+  return Math.round(value * 1000);
 }
 
-// src/impls/supabase-vector.ts
-class SupabaseVectorProvider {
-  database;
-  createTableIfMissing;
-  distanceMetric;
-  quotedSchema;
-  qualifiedTable;
-  collectionIndex;
-  namespaceIndex;
-  ensureTablePromise;
+// src/impls/mistral-conversational.ts
+var DEFAULT_BASE_URL5 = "https://api.mistral.ai/v1";
+var DEFAULT_MODEL2 = "mistral-small-latest";
+var DEFAULT_VOICE = "default";
+
+class MistralConversationalProvider {
+  apiKey;
+  defaultModel;
+  defaultVoiceId;
+  baseUrl;
+  fetchImpl;
+  sttProvider;
   constructor(options) {
-    this.database = options.database ?? new SupabasePostgresProvider({
-      connectionString: options.connectionString,
-      maxConnections: options.maxConnections,
-      sslMode: options.sslMode
-    });
-    this.createTableIfMissing = options.createTableIfMissing ?? true;
-    this.distanceMetric = options.distanceMetric ?? "cosine";
-    const schema = sanitizeIdentifier(options.schema ?? "public", "schema");
-    const table = sanitizeIdentifier(options.table ?? "contractspec_vectors", "table");
-    this.quotedSchema = quoteIdentifier(schema);
-    this.qualifiedTable = `${this.quotedSchema}.${quoteIdentifier(table)}`;
-    this.collectionIndex = quoteIdentifier(`${table}_collection_idx`);
-    this.namespaceIndex = quoteIdentifier(`${table}_namespace_idx`);
-  }
-  async upsert(request) {
-    if (request.documents.length === 0) {
-      return;
-    }
-    if (this.createTableIfMissing) {
-      await this.ensureTable();
-    }
-    for (const document of request.documents) {
-      await this.database.execute(`INSERT INTO ${this.qualifiedTable}
-          (collection, id, embedding, payload, namespace, expires_at, updated_at)
-         VALUES ($1, $2, $3::vector, $4::jsonb, $5, $6, now())
-         ON CONFLICT (collection, id)
-         DO UPDATE SET
-           embedding = EXCLUDED.embedding,
-           payload = EXCLUDED.payload,
-           namespace = EXCLUDED.namespace,
-           expires_at = EXCLUDED.expires_at,
-           updated_at = now();`, [
-        request.collection,
-        document.id,
-        toVectorLiteral(document.vector),
-        document.payload ? JSON.stringify(document.payload) : null,
-        document.namespace ?? null,
-        document.expiresAt ?? null
-      ]);
+    if (!options.apiKey) {
+      throw new Error("MistralConversationalProvider requires an apiKey");
     }
+    this.apiKey = options.apiKey;
+    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL2;
+    this.defaultVoiceId = options.defaultVoiceId ?? DEFAULT_VOICE;
+    this.baseUrl = normalizeBaseUrl2(options.serverURL ?? DEFAULT_BASE_URL5);
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.sttProvider = options.sttProvider ?? new MistralSttProvider({
+      apiKey: options.apiKey,
+      defaultModel: options.sttOptions?.defaultModel,
+      defaultLanguage: options.sttOptions?.defaultLanguage,
+      serverURL: options.sttOptions?.serverURL ?? options.serverURL,
+      fetchImpl: this.fetchImpl
+    });
   }
-  async search(query) {
-    const operator = this.distanceOperator;
-    const results = await this.database.query(`SELECT
-         id,
-         payload,
-         namespace,
-         (embedding ${operator} $3::vector) AS distance
-       FROM ${this.qualifiedTable}
-       WHERE collection = $1
-         AND ($2::text IS NULL OR namespace = $2)
-         AND (expires_at IS NULL OR expires_at > now())
-         AND ($4::jsonb IS NULL OR payload @> $4::jsonb)
-       ORDER BY embedding ${operator} $3::vector
-       LIMIT $5;`, [
-      query.collection,
-      query.namespace ?? null,
-      toVectorLiteral(query.vector),
-      query.filter ? JSON.stringify(query.filter) : null,
-      query.topK
-    ]);
-    const mapped = results.rows.map((row) => {
-      const distance = Number(row.distance);
-      return {
-        id: row.id,
-        score: distanceToScore(distance, this.distanceMetric),
-        payload: isRecord(row.payload) ? row.payload : undefined,
-        namespace: row.namespace ?? undefined
-      };
+  async startSession(config) {
+    return new MistralConversationSession({
+      sessionConfig: {
+        ...config,
+        voiceId: config.voiceId || this.defaultVoiceId
+      },
+      defaultModel: this.defaultModel,
+      complete: (history, sessionConfig) => this.completeConversation(history, sessionConfig),
+      sttProvider: this.sttProvider
     });
-    const scoreThreshold = query.scoreThreshold;
-    if (scoreThreshold == null) {
-      return mapped;
-    }
-    return mapped.filter((result) => result.score >= scoreThreshold);
   }
-  async delete(request) {
-    if (request.ids.length === 0) {
-      return;
-    }
-    const params = [
-      request.collection,
-      request.ids,
-      request.namespace ?? null
+  async listVoices() {
+    return [
+      {
+        id: this.defaultVoiceId,
+        name: "Mistral Default Voice",
+        description: "Default conversational voice profile.",
+        capabilities: ["conversational"]
+      }
     ];
-    await this.database.execute(`DELETE FROM ${this.qualifiedTable}
-       WHERE collection = $1
-         AND id = ANY($2::text[])
-         AND ($3::text IS NULL OR namespace = $3);`, params);
   }
-  async ensureTable() {
-    if (!this.ensureTablePromise) {
-      this.ensureTablePromise = this.createTable();
+  async completeConversation(history, sessionConfig) {
+    const model = sessionConfig.llmModel ?? this.defaultModel;
+    const messages = [];
+    if (sessionConfig.systemPrompt) {
+      messages.push({ role: "system", content: sessionConfig.systemPrompt });
     }
-    await this.ensureTablePromise;
-  }
-  async createTable() {
-    await this.database.execute("CREATE EXTENSION IF NOT EXISTS vector;");
-    await this.database.execute(`CREATE SCHEMA IF NOT EXISTS ${this.quotedSchema};`);
-    await this.database.execute(`CREATE TABLE IF NOT EXISTS ${this.qualifiedTable} (
-         collection text NOT NULL,
-         id text NOT NULL,
-         embedding vector NOT NULL,
-         payload jsonb,
-         namespace text,
-         expires_at timestamptz,
-         created_at timestamptz NOT NULL DEFAULT now(),
-         updated_at timestamptz NOT NULL DEFAULT now(),
-         PRIMARY KEY (collection, id)
-       );`);
-    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.collectionIndex}
-         ON ${this.qualifiedTable} (collection);`);
-    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.namespaceIndex}
-         ON ${this.qualifiedTable} (namespace);`);
-  }
-  get distanceOperator() {
-    switch (this.distanceMetric) {
-      case "l2":
-        return "<->";
-      case "inner_product":
-        return "<#>";
-      case "cosine":
-      default:
-        return "<=>";
+    for (const item of history) {
+      messages.push({ role: item.role, content: item.content });
     }
+    const response = await this.fetchImpl(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model,
+        messages
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Mistral conversational request failed (${response.status}): ${body}`);
+    }
+    const payload = await response.json();
+    return readAssistantText(payload);
   }
 }
-function sanitizeIdentifier(value, label) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
-    throw new Error(`SupabaseVectorProvider ${label} "${value}" is invalid.`);
-  }
-  return value;
-}
-function quoteIdentifier(value) {
-  return `"${value.replaceAll('"', '""')}"`;
+function normalizeBaseUrl2(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-function toVectorLiteral(vector) {
-  if (vector.length === 0) {
-    throw new Error("Supabase vectors must contain at least one dimension.");
+function readAssistantText(payload) {
+  const record = asRecord3(payload);
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  const firstChoice = asRecord3(choices[0]);
+  const message = asRecord3(firstChoice.message);
+  if (typeof message.content === "string") {
+    return message.content;
   }
-  for (const value of vector) {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Supabase vectors must be finite numbers. Found "${value}".`);
-    }
+  if (Array.isArray(message.content)) {
+    const textParts = message.content.map((part) => {
+      const entry = asRecord3(part);
+      const text = entry.text;
+      return typeof text === "string" ? text : "";
+    }).filter((text) => text.length > 0);
+    return textParts.join("");
   }
-  return `[${vector.join(",")}]`;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return "";
 }
-function distanceToScore(distance, metric) {
-  switch (metric) {
-    case "inner_product":
-      return -distance;
-    case "l2":
-      return 1 / (1 + distance);
-    case "cosine":
-    default:
-      return 1 - distance;
+function asRecord3(value) {
+  if (value && typeof value === "object") {
+    return value;
   }
+  return {};
 }
 
-// src/impls/stripe-payments.ts
-import Stripe from "stripe";
-var API_VERSION = "2026-02-25.clover";
+// src/impls/mistral-embedding.ts
+import { Mistral } from "@mistralai/mistralai";
 
-class StripePaymentsProvider {
-  stripe;
+class MistralEmbeddingProvider {
+  client;
+  defaultModel;
   constructor(options) {
-    this.stripe = options.stripe ?? new Stripe(options.apiKey, {
-      apiVersion: API_VERSION
+    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 createCustomer(input) {
-    const customer = await this.stripe.customers.create({
-      email: input.email,
-      name: input.name,
-      description: input.description,
-      metadata: input.metadata
+  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 this.toCustomer(customer);
+    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)])) : undefined
+    }));
   }
-  async getCustomer(customerId) {
-    const customer = await this.stripe.customers.retrieve(customerId);
-    if (customer.deleted)
-      return null;
-    return this.toCustomer(customer);
+  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;
   }
-  async createPaymentIntent(input) {
-    const intent = await this.stripe.paymentIntents.create({
-      amount: input.amount.amount,
-      currency: input.amount.currency,
-      customer: input.customerId,
-      description: input.description,
-      capture_method: input.captureMethod ?? "automatic",
-      confirmation_method: input.confirmationMethod ?? "automatic",
-      automatic_payment_methods: { enabled: true },
-      metadata: input.metadata,
-      return_url: input.returnUrl,
-      statement_descriptor: input.statementDescriptor
+}
+
+// src/impls/mistral-llm.ts
+import { Mistral as Mistral2 } from "@mistralai/mistralai";
+
+class MistralLLMProvider {
+  client;
+  defaultModel;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralLLMProvider requires an apiKey");
+    }
+    this.client = options.client ?? new Mistral2({
+      apiKey: options.apiKey,
+      serverURL: options.serverURL,
+      userAgent: options.userAgentSuffix ? `${options.userAgentSuffix}` : undefined
     });
-    return this.toPaymentIntent(intent);
-  }
-  async capturePayment(paymentIntentId, input) {
-    const intent = await this.stripe.paymentIntents.capture(paymentIntentId, input?.amount ? { amount_to_capture: input.amount.amount } : undefined);
-    return this.toPaymentIntent(intent);
+    this.defaultModel = options.defaultModel ?? "mistral-large-latest";
   }
-  async cancelPaymentIntent(paymentIntentId) {
-    const intent = await this.stripe.paymentIntents.cancel(paymentIntentId);
-    return this.toPaymentIntent(intent);
+  async chat(messages, options = {}) {
+    const request = this.buildChatRequest(messages, options);
+    const response = await this.client.chat.complete(request);
+    return this.buildLLMResponse(response);
   }
-  async refundPayment(input) {
-    const refund = await this.stripe.refunds.create({
-      payment_intent: input.paymentIntentId,
-      amount: input.amount?.amount,
-      reason: mapRefundReason(input.reason),
-      metadata: input.metadata
-    });
-    const paymentIntentId = typeof refund.payment_intent === "string" ? refund.payment_intent : refund.payment_intent?.id ?? "";
-    return {
-      id: refund.id,
-      paymentIntentId,
-      amount: {
-        amount: refund.amount ?? 0,
-        currency: refund.currency?.toUpperCase() ?? "USD"
-      },
-      status: mapRefundStatus(refund.status),
-      reason: refund.reason ?? undefined,
-      metadata: this.toMetadata(refund.metadata),
-      createdAt: refund.created ? new Date(refund.created * 1000) : undefined
+  async* stream(messages, options = {}) {
+    const request = this.buildChatRequest(messages, options);
+    request.stream = true;
+    const stream = await this.client.chat.stream(request);
+    const aggregatedParts = [];
+    const aggregatedToolCalls = [];
+    let usage;
+    let finishReason;
+    for await (const event of stream) {
+      for (const choice of event.data.choices) {
+        const delta = choice.delta;
+        if (typeof delta.content === "string") {
+          if (delta.content.length > 0) {
+            aggregatedParts.push({ type: "text", text: delta.content });
+            yield {
+              type: "message_delta",
+              delta: { type: "text", text: delta.content },
+              index: choice.index
+            };
+          }
+        } else if (Array.isArray(delta.content)) {
+          for (const chunk of delta.content) {
+            if (chunk.type === "text" && "text" in chunk) {
+              aggregatedParts.push({ type: "text", text: chunk.text });
+              yield {
+                type: "message_delta",
+                delta: { type: "text", text: chunk.text },
+                index: choice.index
+              };
+            }
+          }
+        }
+        if (delta.toolCalls) {
+          let localIndex = 0;
+          for (const call of delta.toolCalls) {
+            const toolCall = this.fromMistralToolCall(call, localIndex);
+            aggregatedToolCalls.push(toolCall);
+            yield {
+              type: "tool_call",
+              call: toolCall,
+              index: choice.index
+            };
+            localIndex += 1;
+          }
+        }
+        if (choice.finishReason && choice.finishReason !== "null") {
+          finishReason = choice.finishReason;
+        }
+      }
+      if (event.data.usage) {
+        const usageEntry = this.fromUsage(event.data.usage);
+        if (usageEntry) {
+          usage = usageEntry;
+          yield { type: "usage", usage: usageEntry };
+        }
+      }
+    }
+    const message = {
+      role: "assistant",
+      content: aggregatedParts.length ? aggregatedParts : [{ type: "text", text: "" }]
+    };
+    if (aggregatedToolCalls.length > 0) {
+      message.content = [
+        ...aggregatedToolCalls,
+        ...aggregatedParts.length ? aggregatedParts : []
+      ];
+    }
+    yield {
+      type: "end",
+      response: {
+        message,
+        usage,
+        finishReason: mapFinishReason(finishReason)
+      }
     };
   }
-  async listInvoices(query) {
-    const requestedStatus = query?.status?.[0];
-    const stripeStatus = requestedStatus && requestedStatus !== "deleted" ? requestedStatus : undefined;
-    const response = await this.stripe.invoices.list({
-      customer: query?.customerId,
-      status: stripeStatus,
-      limit: query?.limit,
-      starting_after: query?.startingAfter
-    });
-    return response.data.map((invoice) => this.toInvoice(invoice));
+  async countTokens(_messages) {
+    throw new Error("Mistral API does not currently support token counting");
   }
-  async listTransactions(query) {
-    const response = await this.stripe.charges.list({
-      customer: query?.customerId,
-      payment_intent: query?.paymentIntentId,
-      limit: query?.limit,
-      starting_after: query?.startingAfter
-    });
-    return response.data.map((charge) => ({
-      id: charge.id,
-      paymentIntentId: typeof charge.payment_intent === "string" ? charge.payment_intent : charge.payment_intent?.id,
-      amount: {
-        amount: charge.amount,
-        currency: charge.currency?.toUpperCase() ?? "USD"
-      },
-      type: "capture",
-      status: mapChargeStatus(charge.status),
-      description: charge.description ?? undefined,
-      createdAt: new Date(charge.created * 1000),
-      metadata: this.mergeMetadata(this.toMetadata(charge.metadata), {
-        balanceTransaction: typeof charge.balance_transaction === "string" ? charge.balance_transaction : undefined
-      })
-    }));
+  buildChatRequest(messages, options) {
+    const model = options.model ?? this.defaultModel;
+    const mappedMessages = messages.map((message) => this.toMistralMessage(message));
+    const request = {
+      model,
+      messages: mappedMessages
+    };
+    if (options.temperature != null) {
+      request.temperature = options.temperature;
+    }
+    if (options.topP != null) {
+      request.topP = options.topP;
+    }
+    if (options.maxOutputTokens != null) {
+      request.maxTokens = options.maxOutputTokens;
+    }
+    if (options.stopSequences?.length) {
+      request.stop = options.stopSequences.length === 1 ? options.stopSequences[0] : options.stopSequences;
+    }
+    if (options.tools?.length) {
+      request.tools = options.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: typeof tool.inputSchema === "object" && tool.inputSchema !== null ? tool.inputSchema : {}
+        }
+      }));
+    }
+    if (options.responseFormat === "json") {
+      request.responseFormat = { type: "json_object" };
+    }
+    return request;
   }
-  toCustomer(customer) {
-    const metadata = this.toMetadata(customer.metadata);
-    const updatedAtValue = metadata?.updatedAt;
+  buildLLMResponse(response) {
+    const firstChoice = response.choices[0];
+    if (!firstChoice) {
+      return {
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "" }]
+        },
+        usage: this.fromUsage(response.usage),
+        raw: response
+      };
+    }
+    const message = this.fromAssistantMessage(firstChoice.message);
     return {
-      id: customer.id,
-      email: customer.email ?? undefined,
-      name: customer.name ?? undefined,
-      metadata,
-      createdAt: customer.created ? new Date(customer.created * 1000) : undefined,
-      updatedAt: updatedAtValue ? new Date(updatedAtValue) : undefined
+      message,
+      usage: this.fromUsage(response.usage),
+      finishReason: mapFinishReason(firstChoice.finishReason),
+      raw: response
     };
   }
-  toPaymentIntent(intent) {
-    const metadata = this.toMetadata(intent.metadata);
+  fromUsage(usage) {
+    if (!usage)
+      return;
     return {
-      id: intent.id,
-      amount: this.toMoney(intent.amount_received ?? intent.amount ?? 0, intent.currency),
-      status: mapPaymentIntentStatus(intent.status),
-      customerId: typeof intent.customer === "string" ? intent.customer : intent.customer?.id,
-      description: intent.description ?? undefined,
-      clientSecret: intent.client_secret ?? undefined,
-      metadata,
-      createdAt: new Date(intent.created * 1000),
-      updatedAt: intent.canceled_at != null ? new Date(intent.canceled_at * 1000) : new Date(intent.created * 1000)
+      promptTokens: usage.promptTokens ?? 0,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0
     };
   }
-  toInvoice(invoice) {
-    const metadata = this.toMetadata(invoice.metadata);
+  fromAssistantMessage(message) {
+    const parts = [];
+    if (typeof message.content === "string") {
+      parts.push({ type: "text", text: message.content });
+    } else if (Array.isArray(message.content)) {
+      message.content.forEach((chunk) => {
+        if (chunk.type === "text" && "text" in chunk) {
+          parts.push({ type: "text", text: chunk.text });
+        }
+      });
+    }
+    const toolCalls = message.toolCalls?.map((call, index) => this.fromMistralToolCall(call, index)) ?? [];
+    if (toolCalls.length > 0) {
+      parts.splice(0, 0, ...toolCalls);
+    }
+    if (parts.length === 0) {
+      parts.push({ type: "text", text: "" });
+    }
     return {
-      id: invoice.id,
-      number: invoice.number ?? undefined,
-      status: invoice.status ?? "draft",
-      amountDue: this.toMoney(invoice.amount_due ?? 0, invoice.currency),
-      amountPaid: this.toMoney(invoice.amount_paid ?? 0, invoice.currency),
-      customerId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id,
-      dueDate: invoice.due_date ? new Date(invoice.due_date * 1000) : undefined,
-      hostedInvoiceUrl: invoice.hosted_invoice_url ?? undefined,
-      metadata,
-      createdAt: invoice.created ? new Date(invoice.created * 1000) : undefined,
-      updatedAt: invoice.status_transitions?.finalized_at ? new Date(invoice.status_transitions.finalized_at * 1000) : undefined
+      role: "assistant",
+      content: parts
     };
   }
-  toMoney(amount, currency) {
+  fromMistralToolCall(call, index) {
+    const args = typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments);
     return {
-      amount,
-      currency: currency?.toUpperCase() ?? "USD"
+      type: "tool-call",
+      id: call.id ?? `tool-call-${index}`,
+      name: call.function.name,
+      arguments: args
     };
   }
-  toMetadata(metadata) {
-    if (!metadata)
-      return;
-    const entries = Object.entries(metadata).filter((entry) => typeof entry[1] === "string");
-    if (entries.length === 0)
-      return;
-    return Object.fromEntries(entries);
-  }
-  mergeMetadata(base, extras) {
-    const filteredExtras = Object.entries(extras).filter((entry) => typeof entry[1] === "string");
-    if (!base && filteredExtras.length === 0) {
-      return;
+  toMistralMessage(message) {
+    const textContent = this.extractText(message.content);
+    const toolCalls = this.extractToolCalls(message);
+    switch (message.role) {
+      case "system":
+        return {
+          role: "system",
+          content: textContent ?? ""
+        };
+      case "user":
+        return {
+          role: "user",
+          content: textContent ?? ""
+        };
+      case "assistant":
+        return {
+          role: "assistant",
+          content: toolCalls.length > 0 ? null : textContent ?? "",
+          toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+        };
+      case "tool":
+        return {
+          role: "tool",
+          content: textContent ?? "",
+          toolCallId: message.toolCallId ?? toolCalls[0]?.id
+        };
+      default:
+        return {
+          role: "user",
+          content: textContent ?? ""
+        };
     }
-    return {
-      ...base ?? {},
-      ...Object.fromEntries(filteredExtras)
-    };
+  }
+  extractText(parts) {
+    const textParts = parts.filter((part) => part.type === "text").map((part) => part.text);
+    if (textParts.length === 0)
+      return null;
+    return textParts.join("");
+  }
+  extractToolCalls(message) {
+    const toolCallParts = message.content.filter((part) => part.type === "tool-call");
+    return toolCallParts.map((call, index) => ({
+      id: call.id ?? `call_${index}`,
+      type: "function",
+      index,
+      function: {
+        name: call.name,
+        arguments: call.arguments
+      }
+    }));
   }
 }
-function mapRefundReason(reason) {
+function mapFinishReason(reason) {
   if (!reason)
     return;
-  const allowed = [
-    "duplicate",
-    "fraudulent",
-    "requested_by_customer"
-  ];
-  return allowed.includes(reason) ? reason : undefined;
-}
-function mapPaymentIntentStatus(status) {
-  switch (status) {
-    case "requires_payment_method":
-      return "requires_payment_method";
-    case "requires_confirmation":
-      return "requires_confirmation";
-    case "requires_action":
-    case "requires_capture":
-      return "requires_action";
-    case "processing":
-      return "processing";
-    case "succeeded":
-      return "succeeded";
-    case "canceled":
-      return "canceled";
-    default:
-      return "requires_payment_method";
-  }
-}
-function mapRefundStatus(status) {
-  switch (status) {
-    case "pending":
-    case "succeeded":
-    case "failed":
-    case "canceled":
-      return status;
-    default:
-      return "pending";
-  }
-}
-function mapChargeStatus(status) {
-  switch (status) {
-    case "pending":
-    case "processing":
-      return "pending";
-    case "succeeded":
-      return "succeeded";
-    case "failed":
-    case "canceled":
-      return "failed";
+  const normalized = reason.toLowerCase();
+  switch (normalized) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_call":
+    case "tool_calls":
+      return "tool_call";
+    case "content_filter":
+      return "content_filter";
     default:
-      return "pending";
+      return;
   }
 }
 
-// src/impls/postmark-email.ts
-import { ServerClient } from "postmark";
+// src/impls/notion.ts
+import { Client } from "@notionhq/client";
 
-class PostmarkEmailProvider {
+class NotionProjectManagementProvider {
   client;
-  defaultFromEmail;
-  messageStream;
+  defaults;
   constructor(options) {
-    this.client = options.client ?? new ServerClient(options.serverToken, {
-      useHttps: true
+    this.client = options.client ?? new Client({ auth: options.apiKey });
+    this.defaults = {
+      databaseId: options.databaseId,
+      summaryParentPageId: options.summaryParentPageId,
+      titleProperty: options.titleProperty,
+      statusProperty: options.statusProperty,
+      priorityProperty: options.priorityProperty,
+      tagsProperty: options.tagsProperty,
+      dueDateProperty: options.dueDateProperty,
+      descriptionProperty: options.descriptionProperty
+    };
+  }
+  async createWorkItem(input) {
+    if (input.type === "summary" && this.defaults.summaryParentPageId) {
+      return this.createSummaryPage(input);
+    }
+    const databaseId = this.defaults.databaseId;
+    if (!databaseId) {
+      throw new Error("Notion databaseId is required to create work items.");
+    }
+    const titleProperty = this.defaults.titleProperty ?? "Name";
+    const properties = {
+      [titleProperty]: buildTitleProperty(input.title)
+    };
+    applySelect(properties, this.defaults.statusProperty, input.status);
+    applySelect(properties, this.defaults.priorityProperty, input.priority);
+    applyMultiSelect(properties, this.defaults.tagsProperty, input.tags);
+    applyDate(properties, this.defaults.dueDateProperty, input.dueDate);
+    applyRichText(properties, this.defaults.descriptionProperty, input.description);
+    const page = await this.client.pages.create({
+      parent: { type: "database_id", database_id: databaseId },
+      properties
     });
-    this.defaultFromEmail = options.defaultFromEmail;
-    this.messageStream = options.messageStream;
+    return {
+      id: page.id,
+      title: input.title,
+      url: "url" in page ? page.url : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: databaseId,
+      externalId: input.externalId,
+      metadata: input.metadata
+    };
   }
-  async sendEmail(message) {
-    const request = {
-      From: formatAddress2(message.from) ?? this.defaultFromEmail,
-      To: message.to.map((addr) => formatAddress2(addr)).join(", "),
-      Cc: message.cc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
-      Bcc: message.bcc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
-      ReplyTo: message.replyTo ? formatAddress2(message.replyTo) : undefined,
-      Subject: message.subject,
-      TextBody: message.textBody,
-      HtmlBody: message.htmlBody,
-      Headers: message.headers ? Object.entries(message.headers).map(([name, value]) => ({
-        Name: name,
-        Value: value
-      })) : undefined,
-      MessageStream: this.messageStream,
-      Attachments: buildAttachments(message)
+  async createWorkItems(items) {
+    const created = [];
+    for (const item of items) {
+      created.push(await this.createWorkItem(item));
+    }
+    return created;
+  }
+  async createSummaryPage(input) {
+    const parentId = this.defaults.summaryParentPageId;
+    if (!parentId) {
+      throw new Error("Notion summaryParentPageId is required for summaries.");
+    }
+    const summaryProperties = {
+      title: buildTitleProperty(input.title)
     };
-    const response = await this.client.sendEmail(request);
+    const page = await this.client.pages.create({
+      parent: { type: "page_id", page_id: parentId },
+      properties: summaryProperties
+    });
+    if (input.description) {
+      const children = buildParagraphBlocks(input.description);
+      if (children.length > 0) {
+        await this.client.blocks.children.append({
+          block_id: page.id,
+          children
+        });
+      }
+    }
     return {
-      id: response.MessageID,
-      providerMessageId: response.MessageID,
-      queuedAt: new Date(response.SubmittedAt ?? new Date().toISOString())
+      id: page.id,
+      title: input.title,
+      url: "url" in page ? page.url : undefined,
+      status: input.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: parentId,
+      externalId: input.externalId,
+      metadata: input.metadata
     };
   }
 }
-function formatAddress2(address) {
-  if (address.name) {
-    return `"${address.name}" <${address.email}>`;
-  }
-  return address.email;
+function buildTitleProperty(title) {
+  return {
+    title: [
+      {
+        type: "text",
+        text: { content: title }
+      }
+    ]
+  };
 }
-function buildAttachments(message) {
-  if (!message.attachments?.length)
+function buildRichText(text) {
+  return {
+    rich_text: [
+      {
+        type: "text",
+        text: { content: text }
+      }
+    ]
+  };
+}
+function applySelect(properties, property, value) {
+  if (!property || !value)
     return;
-  return message.attachments.filter((attachment) => attachment.data).map((attachment) => ({
-    Name: attachment.filename,
-    Content: Buffer.from(attachment.data ?? new Uint8Array).toString("base64"),
-    ContentType: attachment.contentType,
-    ContentID: null,
-    ContentLength: attachment.sizeBytes,
-    Disposition: "attachment"
+  const next = {
+    select: { name: value }
+  };
+  properties[property] = next;
+}
+function applyMultiSelect(properties, property, values) {
+  if (!property || !values || values.length === 0)
+    return;
+  const next = {
+    multi_select: values.map((value) => ({ name: value }))
+  };
+  properties[property] = next;
+}
+function applyDate(properties, property, value) {
+  if (!property || !value)
+    return;
+  const next = {
+    date: { start: value.toISOString() }
+  };
+  properties[property] = next;
+}
+function applyRichText(properties, property, value) {
+  if (!property || !value)
+    return;
+  properties[property] = buildRichText(value);
+}
+function buildParagraphBlocks(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim());
+  return lines.map((line) => ({
+    object: "block",
+    type: "paragraph",
+    paragraph: {
+      rich_text: [
+        {
+          type: "text",
+          text: { content: line }
+        }
+      ]
+    }
   }));
 }
 
@@ -5447,612 +5439,295 @@ class PosthogAnalyticsReader {
         offset: input.offset
       }
     });
-    return response.data;
-  }
-  async getFeatureFlags(input) {
-    const projectId = resolveProjectId(input.projectId, this.projectId);
-    const response = await this.client.request({
-      method: "GET",
-      path: `/api/projects/${projectId}/feature_flags/`,
-      query: {
-        active: input.active,
-        limit: input.limit,
-        offset: input.offset
-      }
-    });
-    return response.data;
-  }
-  async getAnnotations(input) {
-    const projectId = resolveProjectId(input.projectId, this.projectId);
-    const response = await this.client.request({
-      method: "GET",
-      path: `/api/projects/${projectId}/annotations/`,
-      query: {
-        limit: input.limit,
-        offset: input.offset,
-        ...buildAnnotationDateQuery(input.dateRange)
-      }
-    });
-    return response.data;
-  }
-}
-function resolveProjectId(inputProjectId, defaultProjectId) {
-  const projectId = inputProjectId ?? defaultProjectId;
-  if (!projectId) {
-    throw new Error("PostHog projectId is required for API reads.");
-  }
-  return projectId;
-}
-function resolveSingleEvent(events) {
-  if (!events || events.length !== 1)
-    return;
-  return events[0];
-}
-function resolveEventList(events) {
-  if (!events || events.length <= 1)
-    return;
-  return events.join(",");
-}
-function buildEventDateQuery(range) {
-  const after = formatDate(range?.from);
-  const before = formatDate(range?.to);
-  return {
-    after,
-    before,
-    timezone: range?.timezone
-  };
-}
-function buildAnnotationDateQuery(range) {
-  const dateFrom = formatDate(range?.from);
-  const dateTo = formatDate(range?.to);
-  return {
-    date_from: dateFrom,
-    date_to: dateTo,
-    timezone: range?.timezone
-  };
-}
-function formatDate(value) {
-  if (!value)
-    return;
-  return typeof value === "string" ? value : value.toISOString();
-}
-
-// src/impls/posthog-utils.ts
-function normalizeHost(host) {
-  return host.replace(/\/$/, "");
-}
-function buildUrl(host, path, query) {
-  if (/^https?:\/\//.test(path)) {
-    return appendQuery(path, query);
-  }
-  const normalizedPath = path.replace(/^\/+/, "");
-  return appendQuery(`${host}/${normalizedPath}`, query);
-}
-function appendQuery(url, query) {
-  if (!query)
-    return url;
-  const params = new URLSearchParams;
-  Object.entries(query).forEach(([key, value]) => {
-    if (value === undefined)
-      return;
-    params.set(key, String(value));
-  });
-  const suffix = params.toString();
-  return suffix ? `${url}?${suffix}` : url;
-}
-function parseJson(value) {
-  if (!value)
-    return {};
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-
-// src/impls/posthog.ts
-import { PostHog } from "posthog-node";
-var DEFAULT_POSTHOG_HOST = "https://app.posthog.com";
-
-class PosthogAnalyticsProvider {
-  host;
-  projectId;
-  projectApiKey;
-  personalApiKey;
-  mcpUrl;
-  fetchFn;
-  client;
-  reader;
-  constructor(options) {
-    this.host = normalizeHost(options.host ?? DEFAULT_POSTHOG_HOST);
-    this.projectId = options.projectId;
-    this.projectApiKey = options.projectApiKey;
-    this.personalApiKey = options.personalApiKey;
-    this.mcpUrl = options.mcpUrl;
-    this.fetchFn = options.fetch ?? fetch;
-    this.client = options.client ?? (options.projectApiKey ? new PostHog(options.projectApiKey, {
-      host: this.host,
-      requestTimeout: options.requestTimeoutMs ?? 1e4
-    }) : undefined);
-    this.reader = new PosthogAnalyticsReader({
-      projectId: this.projectId,
-      client: { request: this.request.bind(this) }
-    });
-  }
-  async capture(event) {
-    if (!this.client) {
-      throw new Error("PostHog projectApiKey is required for capture.");
-    }
-    await this.client.capture({
-      distinctId: event.distinctId,
-      event: event.event,
-      properties: event.properties,
-      timestamp: event.timestamp,
-      groups: event.groups
-    });
-  }
-  async identify(input) {
-    if (!this.client) {
-      throw new Error("PostHog projectApiKey is required for identify.");
-    }
-    await this.client.identify({
-      distinctId: input.distinctId,
-      properties: {
-        ...input.properties ? { $set: input.properties } : {},
-        ...input.setOnce ? { $set_once: input.setOnce } : {}
-      }
-    });
-  }
-  async queryHogQL(input) {
-    return this.reader.queryHogQL(input);
-  }
-  async getEvents(input) {
-    return this.reader.getEvents(input);
-  }
-  async getPersons(input) {
-    return this.reader.getPersons(input);
-  }
-  async getInsights(input) {
-    return this.reader.getInsights(input);
-  }
-  async getInsightResult(input) {
-    return this.reader.getInsightResult(input);
-  }
-  async getCohorts(input) {
-    return this.reader.getCohorts(input);
-  }
-  async getFeatureFlags(input) {
-    return this.reader.getFeatureFlags(input);
-  }
-  async getAnnotations(input) {
-    return this.reader.getAnnotations(input);
-  }
-  async request(request) {
-    if (!this.personalApiKey) {
-      throw new Error("PostHog personalApiKey is required for API requests.");
-    }
-    const url = buildUrl(this.host, request.path, request.query);
-    const response = await this.fetchFn(url, {
-      method: request.method,
-      headers: {
-        Authorization: `Bearer ${this.personalApiKey}`,
-        "Content-Type": "application/json",
-        ...request.headers ?? {}
-      },
-      body: request.body ? JSON.stringify(request.body) : undefined
-    });
-    const text = await response.text();
-    const data = parseJson(text);
-    return {
-      status: response.status,
-      data,
-      headers: Object.fromEntries(response.headers.entries())
-    };
-  }
-  async callMcpTool(call) {
-    if (!this.mcpUrl) {
-      throw new Error("PostHog MCP URL is not configured.");
-    }
-    const response = await this.fetchFn(this.mcpUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "tools/call",
-        params: {
-          name: call.name,
-          arguments: call.arguments ?? {}
-        }
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`PostHog MCP error (${response.status}): ${body}`);
-    }
-    const result = await response.json();
-    if (result.error) {
-      throw new Error(result.error.message ?? "PostHog MCP error");
-    }
-    return result.result ?? null;
-  }
-}
-
-// src/impls/twilio-sms.ts
-import Twilio from "twilio";
-
-class TwilioSmsProvider {
-  client;
-  fromNumber;
-  constructor(options) {
-    this.client = options.client ?? Twilio(options.accountSid, options.authToken);
-    this.fromNumber = options.fromNumber;
-  }
-  async sendSms(input) {
-    const message = await this.client.messages.create({
-      to: input.to,
-      from: input.from ?? this.fromNumber,
-      body: input.body
+    return response.data;
+  }
+  async getFeatureFlags(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/feature_flags/`,
+      query: {
+        active: input.active,
+        limit: input.limit,
+        offset: input.offset
+      }
     });
-    return {
-      id: message.sid,
-      to: message.to ?? input.to,
-      from: message.from ?? input.from ?? this.fromNumber ?? "",
-      body: message.body ?? input.body,
-      status: mapStatus(message.status),
-      sentAt: message.dateCreated ? new Date(message.dateCreated) : undefined,
-      deliveredAt: message.status === "delivered" && message.dateUpdated ? new Date(message.dateUpdated) : undefined,
-      price: message.price ? Number(message.price) : undefined,
-      priceCurrency: message.priceUnit ?? undefined,
-      errorCode: message.errorCode ? String(message.errorCode) : undefined,
-      errorMessage: message.errorMessage ?? undefined
-    };
+    return response.data;
   }
-  async getDeliveryStatus(messageId) {
-    const message = await this.client.messages(messageId).fetch();
-    return {
-      status: mapStatus(message.status),
-      errorCode: message.errorCode ? String(message.errorCode) : undefined,
-      errorMessage: message.errorMessage ?? undefined,
-      updatedAt: message.dateUpdated ? new Date(message.dateUpdated) : new Date
-    };
+  async getAnnotations(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/annotations/`,
+      query: {
+        limit: input.limit,
+        offset: input.offset,
+        ...buildAnnotationDateQuery(input.dateRange)
+      }
+    });
+    return response.data;
   }
 }
-function mapStatus(status) {
-  switch (status) {
-    case "queued":
-    case "accepted":
-    case "scheduled":
-      return "queued";
-    case "sending":
-    case "processing":
-      return "sending";
-    case "sent":
-      return "sent";
-    case "delivered":
-      return "delivered";
-    case "undelivered":
-      return "undelivered";
-    case "failed":
-    case "canceled":
-      return "failed";
-    default:
-      return "queued";
+function resolveProjectId(inputProjectId, defaultProjectId) {
+  const projectId = inputProjectId ?? defaultProjectId;
+  if (!projectId) {
+    throw new Error("PostHog projectId is required for API reads.");
   }
+  return projectId;
+}
+function resolveSingleEvent(events) {
+  if (!events || events.length !== 1)
+    return;
+  return events[0];
+}
+function resolveEventList(events) {
+  if (!events || events.length <= 1)
+    return;
+  return events.join(",");
+}
+function buildEventDateQuery(range) {
+  const after = formatDate(range?.from);
+  const before = formatDate(range?.to);
+  return {
+    after,
+    before,
+    timezone: range?.timezone
+  };
+}
+function buildAnnotationDateQuery(range) {
+  const dateFrom = formatDate(range?.from);
+  const dateTo = formatDate(range?.to);
+  return {
+    date_from: dateFrom,
+    date_to: dateTo,
+    timezone: range?.timezone
+  };
+}
+function formatDate(value) {
+  if (!value)
+    return;
+  return typeof value === "string" ? value : value.toISOString();
 }
 
-// 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
-      }
-    };
+// src/impls/posthog-utils.ts
+function normalizeHost(host) {
+  return host.replace(/\/$/, "");
+}
+function buildUrl(host, path, query) {
+  if (/^https?:\/\//.test(path)) {
+    return appendQuery(path, query);
   }
-  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
-      }
-    };
+  const normalizedPath = path.replace(/^\/+/, "");
+  return appendQuery(`${host}/${normalizedPath}`, query);
+}
+function appendQuery(url, query) {
+  if (!query)
+    return url;
+  const params = new URLSearchParams;
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === undefined)
+      return;
+    params.set(key, String(value));
+  });
+  const suffix = params.toString();
+  return suffix ? `${url}?${suffix}` : url;
+}
+function parseJson(value) {
+  if (!value)
+    return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
   }
 }
 
-// src/impls/messaging-github.ts
-class GithubMessagingProvider {
-  token;
-  defaultOwner;
-  defaultRepo;
-  apiBaseUrl;
+// src/impls/posthog.ts
+import { PostHog } from "posthog-node";
+var DEFAULT_POSTHOG_HOST = "https://app.posthog.com";
+
+class PosthogAnalyticsProvider {
+  host;
+  projectId;
+  projectApiKey;
+  personalApiKey;
+  mcpUrl;
+  fetchFn;
+  client;
+  reader;
   constructor(options) {
-    this.token = options.token;
-    this.defaultOwner = options.defaultOwner;
-    this.defaultRepo = options.defaultRepo;
-    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.github.com";
+    this.host = normalizeHost(options.host ?? DEFAULT_POSTHOG_HOST);
+    this.projectId = options.projectId;
+    this.projectApiKey = options.projectApiKey;
+    this.personalApiKey = options.personalApiKey;
+    this.mcpUrl = options.mcpUrl;
+    this.fetchFn = options.fetch ?? fetch;
+    this.client = options.client ?? (options.projectApiKey ? new PostHog(options.projectApiKey, {
+      host: this.host,
+      requestTimeout: options.requestTimeoutMs ?? 1e4
+    }) : undefined);
+    this.reader = new PosthogAnalyticsReader({
+      projectId: this.projectId,
+      client: { request: this.request.bind(this) }
+    });
   }
-  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 })
+  async capture(event) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for capture.");
+    }
+    await this.client.capture({
+      distinctId: event.distinctId,
+      event: event.event,
+      properties: event.properties,
+      timestamp: event.timestamp,
+      groups: event.groups
     });
-    const body = await response.json();
-    if (!response.ok || !body.id) {
-      throw new Error(`GitHub sendMessage failed: ${body.message ?? `HTTP_${response.status}`}`);
+  }
+  async identify(input) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for identify.");
     }
-    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)
+    await this.client.identify({
+      distinctId: input.distinctId,
+      properties: {
+        ...input.properties ? { $set: input.properties } : {},
+        ...input.setOnce ? { $set_once: input.setOnce } : {}
       }
-    };
+    });
   }
-  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.");
+  async queryHogQL(input) {
+    return this.reader.queryHogQL(input);
+  }
+  async getEvents(input) {
+    return this.reader.getEvents(input);
+  }
+  async getPersons(input) {
+    return this.reader.getPersons(input);
+  }
+  async getInsights(input) {
+    return this.reader.getInsights(input);
+  }
+  async getInsightResult(input) {
+    return this.reader.getInsightResult(input);
+  }
+  async getCohorts(input) {
+    return this.reader.getCohorts(input);
+  }
+  async getFeatureFlags(input) {
+    return this.reader.getFeatureFlags(input);
+  }
+  async getAnnotations(input) {
+    return this.reader.getAnnotations(input);
+  }
+  async request(request) {
+    if (!this.personalApiKey) {
+      throw new Error("PostHog personalApiKey is required for API requests.");
     }
-    const response = await fetch(`${this.apiBaseUrl}/repos/${owner}/${repo}/issues/comments/${messageId}`, {
-      method: "PATCH",
+    const url = buildUrl(this.host, request.path, request.query);
+    const response = await this.fetchFn(url, {
+      method: request.method,
       headers: {
-        authorization: `Bearer ${this.token}`,
-        accept: "application/vnd.github+json",
-        "content-type": "application/json"
+        Authorization: `Bearer ${this.personalApiKey}`,
+        "Content-Type": "application/json",
+        ...request.headers ?? {}
       },
-      body: JSON.stringify({ body: input.text })
+      body: request.body ? JSON.stringify(request.body) : undefined
     });
-    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).");
-    }
+    const text = await response.text();
+    const data = parseJson(text);
     return {
-      owner,
-      repo,
-      issueNumber
+      status: response.status,
+      data,
+      headers: Object.fromEntries(response.headers.entries())
     };
   }
-}
-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;
-}
-
-// 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.");
+  async callMcpTool(call) {
+    if (!this.mcpUrl) {
+      throw new Error("PostHog MCP URL is not configured.");
     }
-    const response = await fetch(`https://graph.facebook.com/${this.apiVersion}/${this.phoneNumberId}/messages`, {
+    const response = await this.fetchFn(this.mcpUrl, {
       method: "POST",
       headers: {
-        authorization: `Bearer ${this.accessToken}`,
-        "content-type": "application/json"
+        "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        messaging_product: "whatsapp",
-        to,
-        type: "text",
-        text: {
-          body: input.text,
-          preview_url: false
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: call.name,
+          arguments: call.arguments ?? {}
         }
       })
     });
-    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})` : ""}`);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`PostHog MCP error (${response.status}): ${body}`);
     }
-    return {
-      id: messageId,
-      providerMessageId: messageId,
-      status: "sent",
-      sentAt: new Date,
-      metadata: {
-        phoneNumberId: this.phoneNumberId
-      }
-    };
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message ?? "PostHog MCP error");
+    }
+    return result.result ?? null;
   }
 }
 
-// src/impls/messaging-whatsapp-twilio.ts
-import { Buffer as Buffer4 } from "node:buffer";
+// src/impls/postmark-email.ts
+import { ServerClient } from "postmark";
 
-class TwilioWhatsappMessagingProvider {
-  accountSid;
-  authToken;
-  fromNumber;
+class PostmarkEmailProvider {
+  client;
+  defaultFromEmail;
+  messageStream;
   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 = Buffer4.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()
+    this.client = options.client ?? new ServerClient(options.serverToken, {
+      useHttps: true
     });
-    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
-      }
+    this.defaultFromEmail = options.defaultFromEmail;
+    this.messageStream = options.messageStream;
+  }
+  async sendEmail(message) {
+    const request = {
+      From: formatAddress2(message.from) ?? this.defaultFromEmail,
+      To: message.to.map((addr) => formatAddress2(addr)).join(", "),
+      Cc: message.cc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
+      Bcc: message.bcc?.map((addr) => formatAddress2(addr)).join(", ") || undefined,
+      ReplyTo: message.replyTo ? formatAddress2(message.replyTo) : undefined,
+      Subject: message.subject,
+      TextBody: message.textBody,
+      HtmlBody: message.htmlBody,
+      Headers: message.headers ? Object.entries(message.headers).map(([name, value]) => ({
+        Name: name,
+        Value: value
+      })) : undefined,
+      MessageStream: this.messageStream,
+      Attachments: buildAttachments(message)
+    };
+    const response = await this.client.sendEmail(request);
+    return {
+      id: response.MessageID,
+      providerMessageId: response.MessageID,
+      queuedAt: new Date(response.SubmittedAt ?? new Date().toISOString())
     };
   }
 }
-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";
+function formatAddress2(address) {
+  if (address.name) {
+    return `"${address.name}" <${address.email}>`;
   }
+  return address.email;
+}
+function buildAttachments(message) {
+  if (!message.attachments?.length)
+    return;
+  return message.attachments.filter((attachment) => attachment.data).map((attachment) => ({
+    Name: attachment.filename,
+    Content: Buffer.from(attachment.data ?? new Uint8Array).toString("base64"),
+    ContentType: attachment.contentType,
+    ContentID: null,
+    ContentLength: attachment.sizeBytes,
+    Disposition: "attachment"
+  }));
 }
 
 // src/impls/powens-client.ts
@@ -6464,380 +6139,642 @@ class PowensOpenBankingProvider {
         return "degraded";
     }
   }
-  handleError(operation, error) {
-    if (error instanceof PowensClientError) {
-      this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed`, {
-        status: error.status,
-        code: error.code,
-        requestId: error.requestId,
-        message: error.message
-      });
-      throw error;
-    }
-    this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed with unexpected error`, error);
-    throw error instanceof Error ? error : new Error(`Powens operation "${operation}" failed`);
+  handleError(operation, error) {
+    if (error instanceof PowensClientError) {
+      this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed`, {
+        status: error.status,
+        code: error.code,
+        requestId: error.requestId,
+        message: error.message
+      });
+      throw error;
+    }
+    this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed with unexpected error`, error);
+    throw error instanceof Error ? error : new Error(`Powens operation "${operation}" failed`);
+  }
+}
+
+// src/impls/qdrant-vector.ts
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+class QdrantVectorProvider {
+  client;
+  createCollectionIfMissing;
+  distance;
+  constructor(options) {
+    this.client = options.client ?? new QdrantClient({
+      url: options.url,
+      apiKey: options.apiKey,
+      ...options.clientParams
+    });
+    this.createCollectionIfMissing = options.createCollectionIfMissing ?? true;
+    this.distance = options.distance ?? "Cosine";
+  }
+  async upsert(request) {
+    if (request.documents.length === 0)
+      return;
+    const firstDocument = request.documents[0];
+    if (!firstDocument)
+      return;
+    const vectorSize = firstDocument.vector.length;
+    if (this.createCollectionIfMissing) {
+      await this.ensureCollection(request.collection, vectorSize);
+    }
+    const points = request.documents.map((document) => ({
+      id: document.id,
+      vector: document.vector,
+      payload: {
+        ...document.payload,
+        ...document.namespace ? { namespace: document.namespace } : {},
+        ...document.expiresAt ? { expiresAt: document.expiresAt.toISOString() } : {}
+      }
+    }));
+    await this.client.upsert(request.collection, {
+      wait: true,
+      points
+    });
+  }
+  async search(query) {
+    const results = await this.client.search(query.collection, {
+      vector: query.vector,
+      limit: query.topK,
+      filter: query.filter,
+      score_threshold: query.scoreThreshold,
+      with_payload: true,
+      with_vector: false
+    });
+    return results.map((item) => ({
+      id: String(item.id),
+      score: item.score,
+      payload: item.payload ?? undefined,
+      namespace: typeof item.payload === "object" && item.payload !== null ? item.payload.namespace : undefined
+    }));
+  }
+  async delete(request) {
+    await this.client.delete(request.collection, {
+      wait: true,
+      points: request.ids
+    });
+  }
+  async ensureCollection(collectionName, vectorSize) {
+    try {
+      await this.client.getCollection(collectionName);
+    } catch (_error) {
+      await this.client.createCollection(collectionName, {
+        vectors: {
+          size: vectorSize,
+          distance: this.distance
+        }
+      });
+    }
+  }
+}
+
+// src/impls/stripe-payments.ts
+import Stripe from "stripe";
+var API_VERSION = "2026-02-25.clover";
+
+class StripePaymentsProvider {
+  stripe;
+  constructor(options) {
+    this.stripe = options.stripe ?? new Stripe(options.apiKey, {
+      apiVersion: API_VERSION
+    });
+  }
+  async createCustomer(input) {
+    const customer = await this.stripe.customers.create({
+      email: input.email,
+      name: input.name,
+      description: input.description,
+      metadata: input.metadata
+    });
+    return this.toCustomer(customer);
+  }
+  async getCustomer(customerId) {
+    const customer = await this.stripe.customers.retrieve(customerId);
+    if (customer.deleted)
+      return null;
+    return this.toCustomer(customer);
+  }
+  async createPaymentIntent(input) {
+    const intent = await this.stripe.paymentIntents.create({
+      amount: input.amount.amount,
+      currency: input.amount.currency,
+      customer: input.customerId,
+      description: input.description,
+      capture_method: input.captureMethod ?? "automatic",
+      confirmation_method: input.confirmationMethod ?? "automatic",
+      automatic_payment_methods: { enabled: true },
+      metadata: input.metadata,
+      return_url: input.returnUrl,
+      statement_descriptor: input.statementDescriptor
+    });
+    return this.toPaymentIntent(intent);
+  }
+  async capturePayment(paymentIntentId, input) {
+    const intent = await this.stripe.paymentIntents.capture(paymentIntentId, input?.amount ? { amount_to_capture: input.amount.amount } : undefined);
+    return this.toPaymentIntent(intent);
+  }
+  async cancelPaymentIntent(paymentIntentId) {
+    const intent = await this.stripe.paymentIntents.cancel(paymentIntentId);
+    return this.toPaymentIntent(intent);
+  }
+  async refundPayment(input) {
+    const refund = await this.stripe.refunds.create({
+      payment_intent: input.paymentIntentId,
+      amount: input.amount?.amount,
+      reason: mapRefundReason(input.reason),
+      metadata: input.metadata
+    });
+    const paymentIntentId = typeof refund.payment_intent === "string" ? refund.payment_intent : refund.payment_intent?.id ?? "";
+    return {
+      id: refund.id,
+      paymentIntentId,
+      amount: {
+        amount: refund.amount ?? 0,
+        currency: refund.currency?.toUpperCase() ?? "USD"
+      },
+      status: mapRefundStatus(refund.status),
+      reason: refund.reason ?? undefined,
+      metadata: this.toMetadata(refund.metadata),
+      createdAt: refund.created ? new Date(refund.created * 1000) : undefined
+    };
+  }
+  async listInvoices(query) {
+    const requestedStatus = query?.status?.[0];
+    const stripeStatus = requestedStatus && requestedStatus !== "deleted" ? requestedStatus : undefined;
+    const response = await this.stripe.invoices.list({
+      customer: query?.customerId,
+      status: stripeStatus,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((invoice) => this.toInvoice(invoice));
+  }
+  async listTransactions(query) {
+    const response = await this.stripe.charges.list({
+      customer: query?.customerId,
+      payment_intent: query?.paymentIntentId,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((charge) => ({
+      id: charge.id,
+      paymentIntentId: typeof charge.payment_intent === "string" ? charge.payment_intent : charge.payment_intent?.id,
+      amount: {
+        amount: charge.amount,
+        currency: charge.currency?.toUpperCase() ?? "USD"
+      },
+      type: "capture",
+      status: mapChargeStatus(charge.status),
+      description: charge.description ?? undefined,
+      createdAt: new Date(charge.created * 1000),
+      metadata: this.mergeMetadata(this.toMetadata(charge.metadata), {
+        balanceTransaction: typeof charge.balance_transaction === "string" ? charge.balance_transaction : undefined
+      })
+    }));
+  }
+  toCustomer(customer) {
+    const metadata = this.toMetadata(customer.metadata);
+    const updatedAtValue = metadata?.updatedAt;
+    return {
+      id: customer.id,
+      email: customer.email ?? undefined,
+      name: customer.name ?? undefined,
+      metadata,
+      createdAt: customer.created ? new Date(customer.created * 1000) : undefined,
+      updatedAt: updatedAtValue ? new Date(updatedAtValue) : undefined
+    };
+  }
+  toPaymentIntent(intent) {
+    const metadata = this.toMetadata(intent.metadata);
+    return {
+      id: intent.id,
+      amount: this.toMoney(intent.amount_received ?? intent.amount ?? 0, intent.currency),
+      status: mapPaymentIntentStatus(intent.status),
+      customerId: typeof intent.customer === "string" ? intent.customer : intent.customer?.id,
+      description: intent.description ?? undefined,
+      clientSecret: intent.client_secret ?? undefined,
+      metadata,
+      createdAt: new Date(intent.created * 1000),
+      updatedAt: intent.canceled_at != null ? new Date(intent.canceled_at * 1000) : new Date(intent.created * 1000)
+    };
   }
-}
-
-// src/impls/linear.ts
-import { LinearClient } from "@linear/sdk";
-var PRIORITY_MAP = {
-  urgent: 1,
-  high: 2,
-  medium: 3,
-  low: 4,
-  none: 0
-};
-
-class LinearProjectManagementProvider {
-  client;
-  defaults;
-  constructor(options) {
-    this.client = options.client ?? new LinearClient({ apiKey: options.apiKey });
-    this.defaults = {
-      teamId: options.teamId,
-      projectId: options.projectId,
-      assigneeId: options.assigneeId,
-      stateId: options.stateId,
-      labelIds: options.labelIds,
-      tagLabelMap: options.tagLabelMap
+  toInvoice(invoice) {
+    const metadata = this.toMetadata(invoice.metadata);
+    return {
+      id: invoice.id,
+      number: invoice.number ?? undefined,
+      status: invoice.status ?? "draft",
+      amountDue: this.toMoney(invoice.amount_due ?? 0, invoice.currency),
+      amountPaid: this.toMoney(invoice.amount_paid ?? 0, invoice.currency),
+      customerId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id,
+      dueDate: invoice.due_date ? new Date(invoice.due_date * 1000) : undefined,
+      hostedInvoiceUrl: invoice.hosted_invoice_url ?? undefined,
+      metadata,
+      createdAt: invoice.created ? new Date(invoice.created * 1000) : undefined,
+      updatedAt: invoice.status_transitions?.finalized_at ? new Date(invoice.status_transitions.finalized_at * 1000) : undefined
     };
   }
-  async createWorkItem(input) {
-    const teamId = this.defaults.teamId;
-    if (!teamId) {
-      throw new Error("Linear teamId is required to create work items.");
-    }
-    const payload = await this.client.createIssue({
-      teamId,
-      title: input.title,
-      description: input.description,
-      priority: mapPriority(input.priority),
-      estimate: input.estimate,
-      assigneeId: input.assigneeId ?? this.defaults.assigneeId,
-      projectId: input.projectId ?? this.defaults.projectId,
-      stateId: this.defaults.stateId,
-      labelIds: resolveLabelIds(this.defaults, input.tags)
-    });
-    const issue = await payload.issue;
-    const state = issue ? await issue.state : undefined;
+  toMoney(amount, currency) {
     return {
-      id: issue?.id ?? "",
-      title: issue?.title ?? input.title,
-      url: issue?.url ?? undefined,
-      status: state?.name ?? undefined,
-      priority: input.priority,
-      tags: input.tags,
-      projectId: input.projectId ?? this.defaults.projectId,
-      externalId: input.externalId,
-      metadata: input.metadata
+      amount,
+      currency: currency?.toUpperCase() ?? "USD"
     };
   }
-  async createWorkItems(items) {
-    const created = [];
-    for (const item of items) {
-      created.push(await this.createWorkItem(item));
+  toMetadata(metadata) {
+    if (!metadata)
+      return;
+    const entries = Object.entries(metadata).filter((entry) => typeof entry[1] === "string");
+    if (entries.length === 0)
+      return;
+    return Object.fromEntries(entries);
+  }
+  mergeMetadata(base, extras) {
+    const filteredExtras = Object.entries(extras).filter((entry) => typeof entry[1] === "string");
+    if (!base && filteredExtras.length === 0) {
+      return;
     }
-    return created;
+    return {
+      ...base ?? {},
+      ...Object.fromEntries(filteredExtras)
+    };
   }
 }
-function mapPriority(priority) {
-  if (!priority)
+function mapRefundReason(reason) {
+  if (!reason)
     return;
-  return PRIORITY_MAP[priority] ?? undefined;
+  const allowed = [
+    "duplicate",
+    "fraudulent",
+    "requested_by_customer"
+  ];
+  return allowed.includes(reason) ? reason : undefined;
 }
-function resolveLabelIds(defaults, tags) {
-  const labelIds = new Set;
-  (defaults.labelIds ?? []).forEach((id) => labelIds.add(id));
-  if (tags && defaults.tagLabelMap) {
-    tags.forEach((tag) => {
-      const mapped = defaults.tagLabelMap?.[tag];
-      if (mapped)
-        labelIds.add(mapped);
-    });
+function mapPaymentIntentStatus(status) {
+  switch (status) {
+    case "requires_payment_method":
+      return "requires_payment_method";
+    case "requires_confirmation":
+      return "requires_confirmation";
+    case "requires_action":
+    case "requires_capture":
+      return "requires_action";
+    case "processing":
+      return "processing";
+    case "succeeded":
+      return "succeeded";
+    case "canceled":
+      return "canceled";
+    default:
+      return "requires_payment_method";
+  }
+}
+function mapRefundStatus(status) {
+  switch (status) {
+    case "pending":
+    case "succeeded":
+    case "failed":
+    case "canceled":
+      return status;
+    default:
+      return "pending";
+  }
+}
+function mapChargeStatus(status) {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return "pending";
+    case "succeeded":
+      return "succeeded";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "pending";
   }
-  const merged = [...labelIds];
-  return merged.length > 0 ? merged : undefined;
 }
 
-// src/impls/jira.ts
+// src/impls/supabase-psql.ts
 import { Buffer as Buffer5 } from "node:buffer";
+import { sql as drizzleSql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
 
-class JiraProjectManagementProvider {
-  siteUrl;
-  authHeader;
-  defaults;
-  fetchFn;
-  constructor(options) {
-    this.siteUrl = normalizeSiteUrl(options.siteUrl);
-    this.authHeader = buildAuthHeader(options.email, options.apiToken);
-    this.defaults = {
-      projectKey: options.projectKey,
-      issueType: options.issueType,
-      defaultLabels: options.defaultLabels,
-      issueTypeMap: options.issueTypeMap
-    };
-    this.fetchFn = options.fetch ?? fetch;
-  }
-  async createWorkItem(input) {
-    const projectKey = input.projectId ?? this.defaults.projectKey;
-    if (!projectKey) {
-      throw new Error("Jira projectKey is required to create work items.");
+class SupabasePostgresProvider {
+  client;
+  db;
+  ownsClient;
+  createDrizzle;
+  constructor(options = {}) {
+    this.createDrizzle = options.createDrizzle ?? ((client) => drizzle(client));
+    if (options.db) {
+      if (!options.client) {
+        throw new Error("SupabasePostgresProvider requires a postgres client when db is provided.");
+      }
+      this.client = options.client;
+      this.db = options.db;
+      this.ownsClient = false;
+      return;
     }
-    const issueType = resolveIssueType(input.type, this.defaults);
-    const description = buildJiraDescription(input.description);
-    const labels = mergeLabels(this.defaults.defaultLabels, input.tags);
-    const priority = mapPriority2(input.priority);
-    const payload = {
-      fields: {
-        project: { key: projectKey },
-        summary: input.title,
-        description,
-        issuetype: { name: issueType },
-        labels,
-        priority: priority ? { name: priority } : undefined,
-        assignee: input.assigneeId ? { accountId: input.assigneeId } : undefined,
-        duedate: input.dueDate ? input.dueDate.toISOString().slice(0, 10) : undefined
+    if (options.client) {
+      this.client = options.client;
+      this.ownsClient = false;
+    } else {
+      if (!options.connectionString) {
+        throw new Error("SupabasePostgresProvider requires either a connectionString or a client.");
       }
-    };
-    const response = await this.fetchFn(`${this.siteUrl}/rest/api/3/issue`, {
-      method: "POST",
-      headers: {
-        Authorization: this.authHeader,
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Jira API error (${response.status}): ${body || response.statusText}`);
+      this.client = postgres(options.connectionString, {
+        max: options.maxConnections,
+        prepare: false,
+        ssl: resolveSslMode(options.sslMode)
+      });
+      this.ownsClient = true;
     }
-    const data = await response.json();
+    this.db = this.createDrizzle(this.client);
+  }
+  async query(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    const result = await this.db.execute(query);
+    const rows = asRows(result);
     return {
-      id: data.id ?? data.key ?? "",
-      title: input.title,
-      url: data.key ? `${this.siteUrl}/browse/${data.key}` : undefined,
-      status: input.status,
-      priority: input.priority,
-      tags: input.tags,
-      projectId: projectKey,
-      externalId: input.externalId,
-      metadata: input.metadata
+      rows,
+      rowCount: rows.length
     };
   }
-  async createWorkItems(items) {
-    const created = [];
-    for (const item of items) {
-      created.push(await this.createWorkItem(item));
+  async execute(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    await this.db.execute(query);
+  }
+  async transaction(run) {
+    const transactionResult = this.client.begin(async (transactionClient) => {
+      const transactionalProvider = new SupabasePostgresProvider({
+        client: transactionClient,
+        db: this.createDrizzle(transactionClient),
+        createDrizzle: this.createDrizzle
+      });
+      return run(transactionalProvider);
+    });
+    return transactionResult;
+  }
+  async close() {
+    if (this.ownsClient) {
+      await this.client.end({ timeout: 5 });
     }
-    return created;
   }
 }
-function normalizeSiteUrl(siteUrl) {
-  return siteUrl.replace(/\/$/, "");
-}
-function buildAuthHeader(email, apiToken) {
-  const token = Buffer5.from(`${email}:${apiToken}`).toString("base64");
-  return `Basic ${token}`;
+function buildParameterizedSql(statement, params) {
+  const segments = [];
+  const pattern = /\$(\d+)/g;
+  let cursor = 0;
+  for (const match of statement.matchAll(pattern)) {
+    const token = match[0];
+    const indexPart = match[1];
+    const start = match.index;
+    if (indexPart == null || start == null)
+      continue;
+    const parameterIndex = Number(indexPart) - 1;
+    if (!Number.isInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= params.length) {
+      throw new Error(`SQL placeholder ${token} is out of bounds for ${params.length} parameter(s).`);
+    }
+    const staticSegment = statement.slice(cursor, start);
+    if (staticSegment.length > 0) {
+      segments.push(drizzleSql.raw(staticSegment));
+    }
+    const parameterValue = params[parameterIndex];
+    if (parameterValue === undefined) {
+      throw new Error(`SQL placeholder ${token} is missing a parameter value.`);
+    }
+    const normalizedValue = normalizeParam(parameterValue);
+    segments.push(drizzleSql`${normalizedValue}`);
+    cursor = start + token.length;
+  }
+  const tailSegment = statement.slice(cursor);
+  if (tailSegment.length > 0) {
+    segments.push(drizzleSql.raw(tailSegment));
+  }
+  if (segments.length === 0) {
+    return drizzleSql.raw("");
+  }
+  return drizzleSql.join(segments);
 }
-function resolveIssueType(type, defaults) {
-  if (type && defaults.issueTypeMap?.[type]) {
-    return defaults.issueTypeMap[type] ?? defaults.issueType ?? "Task";
+function normalizeParam(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
   }
-  return defaults.issueType ?? "Task";
+  if (value instanceof Uint8Array) {
+    return Buffer5.from(value);
+  }
+  if (isPlainObject(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
 }
-function mapPriority2(priority) {
-  switch (priority) {
-    case "urgent":
-      return "Highest";
-    case "high":
-      return "High";
-    case "medium":
-      return "Medium";
-    case "low":
-      return "Low";
-    case "none":
-    default:
-      return;
+function asRows(result) {
+  if (!Array.isArray(result)) {
+    return [];
   }
+  return result;
 }
-function mergeLabels(defaults, tags) {
-  const merged = new Set;
-  (defaults ?? []).forEach((label) => merged.add(label));
-  (tags ?? []).forEach((tag) => merged.add(tag));
-  const result = [...merged];
-  return result.length > 0 ? result : undefined;
+function isPlainObject(value) {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (value instanceof Uint8Array) {
+    return false;
+  }
+  return true;
 }
-function buildJiraDescription(description) {
-  if (!description)
-    return;
-  const lines = description.split(/\r?\n/).filter((line) => line.trim());
-  const content = lines.map((line) => ({
-    type: "paragraph",
-    content: [{ type: "text", text: line }]
-  }));
-  if (content.length === 0)
-    return;
-  return { type: "doc", version: 1, content };
+function resolveSslMode(mode) {
+  switch (mode) {
+    case "allow":
+      return false;
+    case "prefer":
+      return "prefer";
+    case "require":
+    default:
+      return "require";
+  }
 }
 
-// src/impls/notion.ts
-import { Client } from "@notionhq/client";
-
-class NotionProjectManagementProvider {
-  client;
-  defaults;
+// src/impls/supabase-vector.ts
+class SupabaseVectorProvider {
+  database;
+  createTableIfMissing;
+  distanceMetric;
+  quotedSchema;
+  qualifiedTable;
+  collectionIndex;
+  namespaceIndex;
+  ensureTablePromise;
   constructor(options) {
-    this.client = options.client ?? new Client({ auth: options.apiKey });
-    this.defaults = {
-      databaseId: options.databaseId,
-      summaryParentPageId: options.summaryParentPageId,
-      titleProperty: options.titleProperty,
-      statusProperty: options.statusProperty,
-      priorityProperty: options.priorityProperty,
-      tagsProperty: options.tagsProperty,
-      dueDateProperty: options.dueDateProperty,
-      descriptionProperty: options.descriptionProperty
-    };
+    this.database = options.database ?? new SupabasePostgresProvider({
+      connectionString: options.connectionString,
+      maxConnections: options.maxConnections,
+      sslMode: options.sslMode
+    });
+    this.createTableIfMissing = options.createTableIfMissing ?? true;
+    this.distanceMetric = options.distanceMetric ?? "cosine";
+    const schema = sanitizeIdentifier(options.schema ?? "public", "schema");
+    const table = sanitizeIdentifier(options.table ?? "contractspec_vectors", "table");
+    this.quotedSchema = quoteIdentifier(schema);
+    this.qualifiedTable = `${this.quotedSchema}.${quoteIdentifier(table)}`;
+    this.collectionIndex = quoteIdentifier(`${table}_collection_idx`);
+    this.namespaceIndex = quoteIdentifier(`${table}_namespace_idx`);
   }
-  async createWorkItem(input) {
-    if (input.type === "summary" && this.defaults.summaryParentPageId) {
-      return this.createSummaryPage(input);
+  async upsert(request) {
+    if (request.documents.length === 0) {
+      return;
     }
-    const databaseId = this.defaults.databaseId;
-    if (!databaseId) {
-      throw new Error("Notion databaseId is required to create work items.");
+    if (this.createTableIfMissing) {
+      await this.ensureTable();
     }
-    const titleProperty = this.defaults.titleProperty ?? "Name";
-    const properties = {
-      [titleProperty]: buildTitleProperty(input.title)
-    };
-    applySelect(properties, this.defaults.statusProperty, input.status);
-    applySelect(properties, this.defaults.priorityProperty, input.priority);
-    applyMultiSelect(properties, this.defaults.tagsProperty, input.tags);
-    applyDate(properties, this.defaults.dueDateProperty, input.dueDate);
-    applyRichText(properties, this.defaults.descriptionProperty, input.description);
-    const page = await this.client.pages.create({
-      parent: { type: "database_id", database_id: databaseId },
-      properties
+    for (const document of request.documents) {
+      await this.database.execute(`INSERT INTO ${this.qualifiedTable}
+          (collection, id, embedding, payload, namespace, expires_at, updated_at)
+         VALUES ($1, $2, $3::vector, $4::jsonb, $5, $6, now())
+         ON CONFLICT (collection, id)
+         DO UPDATE SET
+           embedding = EXCLUDED.embedding,
+           payload = EXCLUDED.payload,
+           namespace = EXCLUDED.namespace,
+           expires_at = EXCLUDED.expires_at,
+           updated_at = now();`, [
+        request.collection,
+        document.id,
+        toVectorLiteral(document.vector),
+        document.payload ? JSON.stringify(document.payload) : null,
+        document.namespace ?? null,
+        document.expiresAt ?? null
+      ]);
+    }
+  }
+  async search(query) {
+    const operator = this.distanceOperator;
+    const results = await this.database.query(`SELECT
+         id,
+         payload,
+         namespace,
+         (embedding ${operator} $3::vector) AS distance
+       FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND ($2::text IS NULL OR namespace = $2)
+         AND (expires_at IS NULL OR expires_at > now())
+         AND ($4::jsonb IS NULL OR payload @> $4::jsonb)
+       ORDER BY embedding ${operator} $3::vector
+       LIMIT $5;`, [
+      query.collection,
+      query.namespace ?? null,
+      toVectorLiteral(query.vector),
+      query.filter ? JSON.stringify(query.filter) : null,
+      query.topK
+    ]);
+    const mapped = results.rows.map((row) => {
+      const distance = Number(row.distance);
+      return {
+        id: row.id,
+        score: distanceToScore(distance, this.distanceMetric),
+        payload: isRecord(row.payload) ? row.payload : undefined,
+        namespace: row.namespace ?? undefined
+      };
     });
-    return {
-      id: page.id,
-      title: input.title,
-      url: "url" in page ? page.url : undefined,
-      status: input.status,
-      priority: input.priority,
-      tags: input.tags,
-      projectId: databaseId,
-      externalId: input.externalId,
-      metadata: input.metadata
-    };
+    const scoreThreshold = query.scoreThreshold;
+    if (scoreThreshold == null) {
+      return mapped;
+    }
+    return mapped.filter((result) => result.score >= scoreThreshold);
   }
-  async createWorkItems(items) {
-    const created = [];
-    for (const item of items) {
-      created.push(await this.createWorkItem(item));
+  async delete(request) {
+    if (request.ids.length === 0) {
+      return;
     }
-    return created;
+    const params = [
+      request.collection,
+      request.ids,
+      request.namespace ?? null
+    ];
+    await this.database.execute(`DELETE FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND id = ANY($2::text[])
+         AND ($3::text IS NULL OR namespace = $3);`, params);
   }
-  async createSummaryPage(input) {
-    const parentId = this.defaults.summaryParentPageId;
-    if (!parentId) {
-      throw new Error("Notion summaryParentPageId is required for summaries.");
+  async ensureTable() {
+    if (!this.ensureTablePromise) {
+      this.ensureTablePromise = this.createTable();
     }
-    const summaryProperties = {
-      title: buildTitleProperty(input.title)
-    };
-    const page = await this.client.pages.create({
-      parent: { type: "page_id", page_id: parentId },
-      properties: summaryProperties
-    });
-    if (input.description) {
-      const children = buildParagraphBlocks(input.description);
-      if (children.length > 0) {
-        await this.client.blocks.children.append({
-          block_id: page.id,
-          children
-        });
-      }
+    await this.ensureTablePromise;
+  }
+  async createTable() {
+    await this.database.execute("CREATE EXTENSION IF NOT EXISTS vector;");
+    await this.database.execute(`CREATE SCHEMA IF NOT EXISTS ${this.quotedSchema};`);
+    await this.database.execute(`CREATE TABLE IF NOT EXISTS ${this.qualifiedTable} (
+         collection text NOT NULL,
+         id text NOT NULL,
+         embedding vector NOT NULL,
+         payload jsonb,
+         namespace text,
+         expires_at timestamptz,
+         created_at timestamptz NOT NULL DEFAULT now(),
+         updated_at timestamptz NOT NULL DEFAULT now(),
+         PRIMARY KEY (collection, id)
+       );`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.collectionIndex}
+         ON ${this.qualifiedTable} (collection);`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.namespaceIndex}
+         ON ${this.qualifiedTable} (namespace);`);
+  }
+  get distanceOperator() {
+    switch (this.distanceMetric) {
+      case "l2":
+        return "<->";
+      case "inner_product":
+        return "<#>";
+      case "cosine":
+      default:
+        return "<=>";
     }
-    return {
-      id: page.id,
-      title: input.title,
-      url: "url" in page ? page.url : undefined,
-      status: input.status,
-      priority: input.priority,
-      tags: input.tags,
-      projectId: parentId,
-      externalId: input.externalId,
-      metadata: input.metadata
-    };
   }
 }
-function buildTitleProperty(title) {
-  return {
-    title: [
-      {
-        type: "text",
-        text: { content: title }
-      }
-    ]
-  };
-}
-function buildRichText(text) {
-  return {
-    rich_text: [
-      {
-        type: "text",
-        text: { content: text }
-      }
-    ]
-  };
-}
-function applySelect(properties, property, value) {
-  if (!property || !value)
-    return;
-  const next = {
-    select: { name: value }
-  };
-  properties[property] = next;
+function sanitizeIdentifier(value, label) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new Error(`SupabaseVectorProvider ${label} "${value}" is invalid.`);
+  }
+  return value;
 }
-function applyMultiSelect(properties, property, values) {
-  if (!property || !values || values.length === 0)
-    return;
-  const next = {
-    multi_select: values.map((value) => ({ name: value }))
-  };
-  properties[property] = next;
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
 }
-function applyDate(properties, property, value) {
-  if (!property || !value)
-    return;
-  const next = {
-    date: { start: value.toISOString() }
-  };
-  properties[property] = next;
+function toVectorLiteral(vector) {
+  if (vector.length === 0) {
+    throw new Error("Supabase vectors must contain at least one dimension.");
+  }
+  for (const value of vector) {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Supabase vectors must be finite numbers. Found "${value}".`);
+    }
+  }
+  return `[${vector.join(",")}]`;
 }
-function applyRichText(properties, property, value) {
-  if (!property || !value)
-    return;
-  properties[property] = buildRichText(value);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function buildParagraphBlocks(text) {
-  const lines = text.split(/\r?\n/).filter((line) => line.trim());
-  return lines.map((line) => ({
-    object: "block",
-    type: "paragraph",
-    paragraph: {
-      rich_text: [
-        {
-          type: "text",
-          text: { content: line }
-        }
-      ]
-    }
-  }));
+function distanceToScore(distance, metric) {
+  switch (metric) {
+    case "inner_product":
+      return -distance;
+    case "l2":
+      return 1 / (1 + distance);
+    case "cosine":
+    default:
+      return 1 - distance;
+  }
 }
 
 // src/impls/tldv-meeting-recorder.ts
@@ -6983,11 +6920,74 @@ async function safeReadError4(response) {
   }
 }
 
+// src/impls/twilio-sms.ts
+import Twilio from "twilio";
+
+class TwilioSmsProvider {
+  client;
+  fromNumber;
+  constructor(options) {
+    this.client = options.client ?? Twilio(options.accountSid, options.authToken);
+    this.fromNumber = options.fromNumber;
+  }
+  async sendSms(input) {
+    const message = await this.client.messages.create({
+      to: input.to,
+      from: input.from ?? this.fromNumber,
+      body: input.body
+    });
+    return {
+      id: message.sid,
+      to: message.to ?? input.to,
+      from: message.from ?? input.from ?? this.fromNumber ?? "",
+      body: message.body ?? input.body,
+      status: mapStatus(message.status),
+      sentAt: message.dateCreated ? new Date(message.dateCreated) : undefined,
+      deliveredAt: message.status === "delivered" && message.dateUpdated ? new Date(message.dateUpdated) : undefined,
+      price: message.price ? Number(message.price) : undefined,
+      priceCurrency: message.priceUnit ?? undefined,
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined
+    };
+  }
+  async getDeliveryStatus(messageId) {
+    const message = await this.client.messages(messageId).fetch();
+    return {
+      status: mapStatus(message.status),
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined,
+      updatedAt: message.dateUpdated ? new Date(message.dateUpdated) : new Date
+    };
+  }
+}
+function mapStatus(status) {
+  switch (status) {
+    case "queued":
+    case "accepted":
+    case "scheduled":
+      return "queued";
+    case "sending":
+    case "processing":
+      return "sending";
+    case "sent":
+      return "sent";
+    case "delivered":
+      return "delivered";
+    case "undelivered":
+      return "undelivered";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "queued";
+  }
+}
+
 // src/impls/provider-factory.ts
 import { Buffer as Buffer6 } from "node:buffer";
-import { resolveIntegrationRequestContext } from "@contractspec/lib.contracts-integrations/integrations/runtime";
-import { buildAuthHeaders } from "@contractspec/lib.contracts-integrations/integrations/auth-helpers";
 import { findAuthConfig } from "@contractspec/lib.contracts-integrations/integrations/auth";
+import { buildAuthHeaders } from "@contractspec/lib.contracts-integrations/integrations/auth-helpers";
+import { resolveIntegrationRequestContext } from "@contractspec/lib.contracts-integrations/integrations/runtime";
 var SECRET_CACHE = new Map;
 
 class IntegrationProviderFactory {