@contractspec/integration.providers-impls 2.9.0 → 3.0.0

package/dist/node/index.js

@@ -13,6 +13,53 @@ export * from "@contractspec/lib.contracts-integrations";
 // src/embedding.ts
 export * from "@contractspec/lib.contracts-integrations";
 
+// src/health.ts
+export * from "@contractspec/lib.contracts-integrations";
+
+// src/impls/async-event-queue.ts
+class AsyncEventQueue {
+  values = [];
+  waiters = [];
+  done = false;
+  push(value) {
+    if (this.done) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    for (const waiter of this.waiters) {
+      waiter({ value: undefined, done: true });
+    }
+    this.waiters.length = 0;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        const value = this.values.shift();
+        if (value != null) {
+          return { value, done: false };
+        }
+        if (this.done) {
+          return { value: undefined, done: true };
+        }
+        return new Promise((resolve) => {
+          this.waiters.push(resolve);
+        });
+      }
+    };
+  }
+}
+
 // src/impls/elevenlabs-voice.ts
 import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
 var FORMAT_MAP = {
@@ -2030,128 +2077,1433 @@ async function safeReadError3(response) {
   }
 }
 
-// src/impls/mistral-llm.ts
-import { Mistral } from "@mistralai/mistralai";
+// src/impls/health/provider-normalizers.ts
+var DEFAULT_LIST_KEYS = [
+  "items",
+  "data",
+  "records",
+  "activities",
+  "workouts",
+  "sleep",
+  "biometrics",
+  "nutrition"
+];
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  return value;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : undefined;
+}
+function readString2(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function readNumber(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
+function readBoolean2(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return;
+}
+function extractList(payload, listKeys = DEFAULT_LIST_KEYS) {
+  const root = asRecord(payload);
+  if (!root) {
+    return asArray2(payload)?.map((item) => asRecord(item)).filter((item) => Boolean(item)) ?? [];
+  }
+  for (const key of listKeys) {
+    const arrayValue = asArray2(root[key]);
+    if (!arrayValue)
+      continue;
+    return arrayValue.map((item) => asRecord(item)).filter((item) => Boolean(item));
+  }
+  return [];
+}
+function extractPagination(payload) {
+  const root = asRecord(payload);
+  const nestedPagination = asRecord(root?.pagination);
+  const nextCursor = readString2(nestedPagination, ["nextCursor", "next_cursor"]) ?? readString2(root, [
+    "nextCursor",
+    "next_cursor",
+    "cursor",
+    "next_page_token"
+  ]);
+  const hasMore = readBoolean2(nestedPagination, ["hasMore", "has_more"]) ?? readBoolean2(root, ["hasMore", "has_more"]);
+  return {
+    nextCursor,
+    hasMore: hasMore ?? Boolean(nextCursor)
+  };
+}
+function toHealthActivity(item, context, fallbackType = "activity") {
+  const externalId = readString2(item, ["external_id", "externalId", "uuid", "id"]) ?? `${context.providerKey}:${fallbackType}`;
+  const id = readString2(item, ["id", "uuid", "workout_id"]) ?? `${context.providerKey}:activity:${externalId}`;
+  return {
+    id,
+    externalId,
+    tenantId: context.tenantId,
+    connectionId: context.connectionId ?? "unknown",
+    userId: readString2(item, ["user_id", "userId", "athlete_id"]),
+    providerKey: context.providerKey,
+    activityType: readString2(item, ["activity_type", "type", "sport_type", "sport"]) ?? fallbackType,
+    startedAt: readIsoDate(item, [
+      "started_at",
+      "start_time",
+      "start_date",
+      "created_at"
+    ]),
+    endedAt: readIsoDate(item, ["ended_at", "end_time"]),
+    durationSeconds: readNumber(item, [
+      "duration_seconds",
+      "duration",
+      "elapsed_time"
+    ]),
+    distanceMeters: readNumber(item, ["distance_meters", "distance"]),
+    caloriesKcal: readNumber(item, [
+      "calories_kcal",
+      "calories",
+      "active_kilocalories"
+    ]),
+    steps: readNumber(item, ["steps"])?.valueOf(),
+    metadata: item
+  };
+}
+function toHealthWorkout(item, context, fallbackType = "workout") {
+  const activity = toHealthActivity(item, context, fallbackType);
+  return {
+    id: activity.id,
+    externalId: activity.externalId,
+    tenantId: activity.tenantId,
+    connectionId: activity.connectionId,
+    userId: activity.userId,
+    providerKey: activity.providerKey,
+    workoutType: readString2(item, [
+      "workout_type",
+      "sport_type",
+      "type",
+      "activity_type"
+    ]) ?? fallbackType,
+    startedAt: activity.startedAt,
+    endedAt: activity.endedAt,
+    durationSeconds: activity.durationSeconds,
+    distanceMeters: activity.distanceMeters,
+    caloriesKcal: activity.caloriesKcal,
+    averageHeartRateBpm: readNumber(item, [
+      "average_heart_rate",
+      "avg_hr",
+      "average_heart_rate_bpm"
+    ]),
+    maxHeartRateBpm: readNumber(item, [
+      "max_heart_rate",
+      "max_hr",
+      "max_heart_rate_bpm"
+    ]),
+    metadata: item
+  };
+}
+function toHealthSleep(item, context) {
+  const externalId = readString2(item, ["external_id", "externalId", "uuid", "id"]) ?? `${context.providerKey}:sleep`;
+  const id = readString2(item, ["id", "uuid"]) ?? `${context.providerKey}:sleep:${externalId}`;
+  const startedAt = readIsoDate(item, ["started_at", "start_time", "bedtime_start", "start"]) ?? new Date(0).toISOString();
+  const endedAt = readIsoDate(item, ["ended_at", "end_time", "bedtime_end", "end"]) ?? startedAt;
+  return {
+    id,
+    externalId,
+    tenantId: context.tenantId,
+    connectionId: context.connectionId ?? "unknown",
+    userId: readString2(item, ["user_id", "userId"]),
+    providerKey: context.providerKey,
+    startedAt,
+    endedAt,
+    durationSeconds: readNumber(item, [
+      "duration_seconds",
+      "duration",
+      "total_sleep_duration"
+    ]),
+    deepSleepSeconds: readNumber(item, [
+      "deep_sleep_seconds",
+      "deep_sleep_duration"
+    ]),
+    lightSleepSeconds: readNumber(item, [
+      "light_sleep_seconds",
+      "light_sleep_duration"
+    ]),
+    remSleepSeconds: readNumber(item, [
+      "rem_sleep_seconds",
+      "rem_sleep_duration"
+    ]),
+    awakeSeconds: readNumber(item, ["awake_seconds", "awake_time"]),
+    sleepScore: readNumber(item, ["sleep_score", "score"]),
+    metadata: item
+  };
+}
+function toHealthBiometric(item, context, metricTypeFallback = "metric") {
+  const externalId = readString2(item, ["external_id", "externalId", "uuid", "id"]) ?? `${context.providerKey}:biometric`;
+  const id = readString2(item, ["id", "uuid"]) ?? `${context.providerKey}:biometric:${externalId}`;
+  return {
+    id,
+    externalId,
+    tenantId: context.tenantId,
+    connectionId: context.connectionId ?? "unknown",
+    userId: readString2(item, ["user_id", "userId"]),
+    providerKey: context.providerKey,
+    metricType: readString2(item, ["metric_type", "metric", "type", "name"]) ?? metricTypeFallback,
+    value: readNumber(item, ["value", "score", "measurement"]) ?? 0,
+    unit: readString2(item, ["unit"]),
+    measuredAt: readIsoDate(item, ["measured_at", "timestamp", "created_at"]) ?? new Date().toISOString(),
+    metadata: item
+  };
+}
+function toHealthNutrition(item, context) {
+  const externalId = readString2(item, ["external_id", "externalId", "uuid", "id"]) ?? `${context.providerKey}:nutrition`;
+  const id = readString2(item, ["id", "uuid"]) ?? `${context.providerKey}:nutrition:${externalId}`;
+  return {
+    id,
+    externalId,
+    tenantId: context.tenantId,
+    connectionId: context.connectionId ?? "unknown",
+    userId: readString2(item, ["user_id", "userId"]),
+    providerKey: context.providerKey,
+    loggedAt: readIsoDate(item, ["logged_at", "created_at", "date", "timestamp"]) ?? new Date().toISOString(),
+    caloriesKcal: readNumber(item, ["calories_kcal", "calories"]),
+    proteinGrams: readNumber(item, ["protein_grams", "protein"]),
+    carbsGrams: readNumber(item, ["carbs_grams", "carbs"]),
+    fatGrams: readNumber(item, ["fat_grams", "fat"]),
+    fiberGrams: readNumber(item, ["fiber_grams", "fiber"]),
+    hydrationMl: readNumber(item, ["hydration_ml", "water_ml", "water"]),
+    metadata: item
+  };
+}
+function toHealthConnectionStatus(payload, params, source) {
+  const record = asRecord(payload);
+  const rawStatus = readString2(record, ["status", "connection_status", "health"]) ?? "healthy";
+  return {
+    tenantId: params.tenantId,
+    connectionId: params.connectionId,
+    status: rawStatus === "healthy" || rawStatus === "degraded" || rawStatus === "error" || rawStatus === "disconnected" ? rawStatus : "healthy",
+    source,
+    lastCheckedAt: readIsoDate(record, ["last_checked_at", "lastCheckedAt"]) ?? new Date().toISOString(),
+    errorCode: readString2(record, ["error_code", "errorCode"]),
+    errorMessage: readString2(record, ["error_message", "errorMessage"]),
+    metadata: asRecord(record?.metadata)
+  };
+}
+function toHealthWebhookEvent(payload, providerKey, verified) {
+  const record = asRecord(payload);
+  const entityType = readString2(record, ["entity_type", "entityType", "type"]);
+  const normalizedEntityType = entityType === "activity" || entityType === "workout" || entityType === "sleep" || entityType === "biometric" || entityType === "nutrition" ? entityType : undefined;
+  return {
+    providerKey,
+    eventType: readString2(record, ["event_type", "eventType", "event"]),
+    externalEntityId: readString2(record, [
+      "external_entity_id",
+      "externalEntityId",
+      "entity_id",
+      "entityId",
+      "id"
+    ]),
+    entityType: normalizedEntityType,
+    receivedAt: new Date().toISOString(),
+    verified,
+    payload,
+    metadata: asRecord(record?.metadata)
+  };
+}
+function readIsoDate(record, keys) {
+  const value = readString2(record, keys);
+  if (!value)
+    return;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()))
+    return;
+  return parsed.toISOString();
+}
 
-class MistralLLMProvider {
-  client;
-  defaultModel;
+// src/impls/health/base-health-provider.ts
+class HealthProviderCapabilityError extends Error {
+  code = "NOT_SUPPORTED";
+  constructor(message) {
+    super(message);
+    this.name = "HealthProviderCapabilityError";
+  }
+}
+
+class BaseHealthProvider {
+  providerKey;
+  transport;
+  apiBaseUrl;
+  mcpUrl;
+  apiKey;
+  accessToken;
+  refreshToken;
+  mcpAccessToken;
+  webhookSecret;
+  webhookSignatureHeader;
+  route;
+  aggregatorKey;
+  oauth;
+  fetchFn;
+  mcpRequestId = 0;
   constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("MistralLLMProvider requires an apiKey");
-    }
-    this.client = options.client ?? new Mistral({
-      apiKey: options.apiKey,
-      serverURL: options.serverURL,
-      userAgent: options.userAgentSuffix ? `${options.userAgentSuffix}` : undefined
+    this.providerKey = options.providerKey;
+    this.transport = options.transport;
+    this.apiBaseUrl = options.apiBaseUrl;
+    this.mcpUrl = options.mcpUrl;
+    this.apiKey = options.apiKey;
+    this.accessToken = options.accessToken;
+    this.refreshToken = options.oauth?.refreshToken;
+    this.mcpAccessToken = options.mcpAccessToken;
+    this.webhookSecret = options.webhookSecret;
+    this.webhookSignatureHeader = options.webhookSignatureHeader ?? "x-webhook-signature";
+    this.route = options.route ?? "primary";
+    this.aggregatorKey = options.aggregatorKey;
+    this.oauth = options.oauth ?? {};
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async listActivities(_params) {
+    throw this.unsupported("activities");
+  }
+  async listWorkouts(_params) {
+    throw this.unsupported("workouts");
+  }
+  async listSleep(_params) {
+    throw this.unsupported("sleep");
+  }
+  async listBiometrics(_params) {
+    throw this.unsupported("biometrics");
+  }
+  async listNutrition(_params) {
+    throw this.unsupported("nutrition");
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      mcpTool: `${this.providerSlug()}_connection_status`
     });
-    this.defaultModel = options.defaultModel ?? "mistral-large-latest";
   }
-  async chat(messages, options = {}) {
-    const request = this.buildChatRequest(messages, options);
-    const response = await this.client.chat.complete(request);
-    return this.buildLLMResponse(response);
+  async syncActivities(params) {
+    return this.syncFromList(() => this.listActivities(params));
   }
-  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: "" }]
+  async syncWorkouts(params) {
+    return this.syncFromList(() => this.listWorkouts(params));
+  }
+  async syncSleep(params) {
+    return this.syncFromList(() => this.listSleep(params));
+  }
+  async syncBiometrics(params) {
+    return this.syncFromList(() => this.listBiometrics(params));
+  }
+  async syncNutrition(params) {
+    return this.syncFromList(() => this.listNutrition(params));
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? safeJsonParse(request.rawBody);
+    const verified = await this.verifyWebhook(request);
+    return toHealthWebhookEvent(payload, this.providerKey, verified);
+  }
+  async verifyWebhook(request) {
+    if (!this.webhookSecret)
+      return true;
+    const signature = readHeader(request.headers, this.webhookSignatureHeader);
+    return signature === this.webhookSecret;
+  }
+  async fetchActivities(params, config) {
+    const response = await this.fetchList(params, config);
+    return {
+      activities: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
     };
-    if (aggregatedToolCalls.length > 0) {
-      message.content = [
-        ...aggregatedToolCalls,
-        ...aggregatedParts.length ? aggregatedParts : []
-      ];
-    }
-    yield {
-      type: "end",
-      response: {
-        message,
-        usage,
-        finishReason: mapFinishReason(finishReason)
-      }
+  }
+  async fetchWorkouts(params, config) {
+    const response = await this.fetchList(params, config);
+    return {
+      workouts: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
     };
   }
-  async countTokens(_messages) {
-    throw new Error("Mistral API does not currently support token counting");
+  async fetchSleep(params, config) {
+    const response = await this.fetchList(params, config);
+    return {
+      sleep: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
+    };
   }
-  buildChatRequest(messages, options) {
-    const model = options.model ?? this.defaultModel;
-    const mappedMessages = messages.map((message) => this.toMistralMessage(message));
-    const request = {
-      model,
-      messages: mappedMessages
+  async fetchBiometrics(params, config) {
+    const response = await this.fetchList(params, config);
+    return {
+      biometrics: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
     };
-    if (options.temperature != null) {
-      request.temperature = options.temperature;
-    }
-    if (options.topP != null) {
-      request.topP = options.topP;
+  }
+  async fetchNutrition(params, config) {
+    const response = await this.fetchList(params, config);
+    return {
+      nutrition: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async fetchConnectionStatus(params, config) {
+    const payload = await this.fetchPayload(config, params);
+    return toHealthConnectionStatus(payload, params, this.currentSource());
+  }
+  currentSource() {
+    return {
+      providerKey: this.providerKey,
+      transport: this.transport,
+      route: this.route,
+      aggregatorKey: this.aggregatorKey
+    };
+  }
+  providerSlug() {
+    return this.providerKey.replace("health.", "").replace(/-/g, "_");
+  }
+  unsupported(capability) {
+    return new HealthProviderCapabilityError(`${this.providerKey} does not support ${capability}`);
+  }
+  async syncFromList(executor) {
+    const result = await executor();
+    const records = countResultRecords(result);
+    return {
+      synced: records,
+      failed: 0,
+      nextCursor: undefined,
+      source: result.source
+    };
+  }
+  async fetchList(params, config) {
+    const payload = await this.fetchPayload(config, params);
+    const items = extractList(payload, config.listKeys).map((item) => config.mapItem(item, params)).filter((item) => Boolean(item));
+    const pagination = extractPagination(payload);
+    return {
+      items,
+      nextCursor: pagination.nextCursor,
+      hasMore: pagination.hasMore
+    };
+  }
+  async fetchPayload(config, params) {
+    const method = config.method ?? "GET";
+    const query = config.buildQuery?.(params);
+    const body = config.buildBody?.(params);
+    if (this.isMcpTransport()) {
+      return this.callMcpTool(config.mcpTool, {
+        ...query ?? {},
+        ...body ?? {}
+      });
     }
-    if (options.maxOutputTokens != null) {
-      request.maxTokens = options.maxOutputTokens;
+    if (!config.apiPath || !this.apiBaseUrl) {
+      throw new Error(`${this.providerKey} transport is missing an API path.`);
     }
-    if (options.stopSequences?.length) {
-      request.stop = options.stopSequences.length === 1 ? options.stopSequences[0] : options.stopSequences;
+    if (method === "POST") {
+      return this.requestApi(config.apiPath, "POST", undefined, body);
     }
-    if (options.tools?.length) {
-      request.tools = options.tools.map((tool) => ({
+    return this.requestApi(config.apiPath, "GET", query, undefined);
+  }
+  isMcpTransport() {
+    return this.transport.endsWith("mcp") || this.transport === "unofficial";
+  }
+  async requestApi(path, method, query, body) {
+    const url = new URL(path, ensureTrailingSlash(this.apiBaseUrl ?? ""));
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value == null)
+          continue;
+        if (Array.isArray(value)) {
+          value.forEach((entry) => {
+            if (entry != null)
+              url.searchParams.append(key, String(entry));
+          });
+          continue;
+        }
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const response = await this.fetchFn(url, {
+      method,
+      headers: this.authorizationHeaders(),
+      body: method === "POST" ? JSON.stringify(body ?? {}) : undefined
+    });
+    if (response.status === 401 && await this.refreshAccessToken()) {
+      const retryResponse = await this.fetchFn(url, {
+        method,
+        headers: this.authorizationHeaders(),
+        body: method === "POST" ? JSON.stringify(body ?? {}) : undefined
+      });
+      return this.readResponsePayload(retryResponse, path);
+    }
+    return this.readResponsePayload(response, path);
+  }
+  async callMcpTool(toolName, args) {
+    if (!this.mcpUrl) {
+      throw new Error(`${this.providerKey} MCP URL is not configured.`);
+    }
+    const response = await this.fetchFn(this.mcpUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.mcpAccessToken ? { Authorization: `Bearer ${this.mcpAccessToken}` } : {}
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++this.mcpRequestId,
+        method: "tools/call",
+        params: {
+          name: toolName,
+          arguments: args
+        }
+      })
+    });
+    const payload = await this.readResponsePayload(response, toolName);
+    const rpcEnvelope = asRecord(payload);
+    if (!rpcEnvelope)
+      return payload;
+    const rpcResult = asRecord(rpcEnvelope.result);
+    if (rpcResult) {
+      return rpcResult.structuredContent ?? rpcResult.data ?? rpcResult;
+    }
+    return rpcEnvelope.structuredContent ?? rpcEnvelope.data ?? rpcEnvelope;
+  }
+  authorizationHeaders() {
+    const token = this.accessToken ?? this.apiKey;
+    return {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    };
+  }
+  async refreshAccessToken() {
+    if (!this.oauth.tokenUrl || !this.refreshToken) {
+      return false;
+    }
+    const tokenUrl = new URL(this.oauth.tokenUrl);
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: this.refreshToken,
+      ...this.oauth.clientId ? { client_id: this.oauth.clientId } : {},
+      ...this.oauth.clientSecret ? { client_secret: this.oauth.clientSecret } : {}
+    });
+    const response = await this.fetchFn(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const payload = await response.json();
+    this.accessToken = payload.access_token;
+    this.refreshToken = payload.refresh_token ?? this.refreshToken;
+    if (typeof payload.expires_in === "number") {
+      this.oauth.tokenExpiresAt = new Date(Date.now() + payload.expires_in * 1000).toISOString();
+    }
+    return Boolean(this.accessToken);
+  }
+  async readResponsePayload(response, context) {
+    if (!response.ok) {
+      const message = await safeReadText2(response);
+      throw new Error(`${this.providerKey} request ${context} failed (${response.status}): ${message}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return response.json();
+  }
+}
+function readHeader(headers, key) {
+  const target = key.toLowerCase();
+  const entry = Object.entries(headers).find(([headerKey]) => headerKey.toLowerCase() === target);
+  if (!entry)
+    return;
+  const value = entry[1];
+  return Array.isArray(value) ? value[0] : value;
+}
+function countResultRecords(result) {
+  const listKeys = [
+    "activities",
+    "workouts",
+    "sleep",
+    "biometrics",
+    "nutrition"
+  ];
+  for (const key of listKeys) {
+    const value = result[key];
+    if (Array.isArray(value)) {
+      return value.length;
+    }
+  }
+  return 0;
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { rawBody: raw };
+  }
+}
+async function safeReadText2(response) {
+  try {
+    return await response.text();
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/health/official-health-providers.ts
+function buildSharedQuery(params) {
+  return {
+    tenantId: params.tenantId,
+    connectionId: params.connectionId,
+    userId: params.userId,
+    from: params.from,
+    to: params.to,
+    cursor: params.cursor,
+    pageSize: params.pageSize
+  };
+}
+function withMetricTypes(params) {
+  return {
+    ...buildSharedQuery(params),
+    metricTypes: params.metricTypes
+  };
+}
+
+class OpenWearablesHealthProvider extends BaseHealthProvider {
+  upstreamProvider;
+  constructor(options) {
+    super({
+      providerKey: options.providerKey ?? "health.openwearables",
+      apiBaseUrl: options.apiBaseUrl ?? "https://api.openwearables.io",
+      webhookSignatureHeader: "x-openwearables-signature",
+      ...options
+    });
+    this.upstreamProvider = options.upstreamProvider;
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      apiPath: "/v1/activities",
+      mcpTool: "openwearables_list_activities",
+      buildQuery: (input) => this.withUpstreamProvider(buildSharedQuery(input)),
+      mapItem: (item, input) => toHealthActivity(item, this.context(input), "activity")
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      apiPath: "/v1/workouts",
+      mcpTool: "openwearables_list_workouts",
+      buildQuery: (input) => this.withUpstreamProvider(buildSharedQuery(input)),
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(params) {
+    return this.fetchSleep(params, {
+      apiPath: "/v1/sleep",
+      mcpTool: "openwearables_list_sleep",
+      buildQuery: (input) => this.withUpstreamProvider(buildSharedQuery(input)),
+      mapItem: (item, input) => toHealthSleep(item, this.context(input))
+    });
+  }
+  async listBiometrics(params) {
+    return this.fetchBiometrics(params, {
+      apiPath: "/v1/biometrics",
+      mcpTool: "openwearables_list_biometrics",
+      buildQuery: (input) => this.withUpstreamProvider(withMetricTypes(input)),
+      mapItem: (item, input) => toHealthBiometric(item, this.context(input))
+    });
+  }
+  async listNutrition(params) {
+    return this.fetchNutrition(params, {
+      apiPath: "/v1/nutrition",
+      mcpTool: "openwearables_list_nutrition",
+      buildQuery: (input) => this.withUpstreamProvider(buildSharedQuery(input)),
+      mapItem: (item, input) => toHealthNutrition(item, this.context(input))
+    });
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      apiPath: `/v1/connections/${encodeURIComponent(params.connectionId)}/status`,
+      mcpTool: "openwearables_connection_status"
+    });
+  }
+  withUpstreamProvider(query) {
+    return {
+      ...query,
+      ...this.upstreamProvider ? { upstreamProvider: this.upstreamProvider } : {}
+    };
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+
+class AppleHealthBridgeProvider extends OpenWearablesHealthProvider {
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: "health.apple-health",
+      upstreamProvider: "apple-health"
+    });
+  }
+}
+
+class WhoopHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.whoop",
+      apiBaseUrl: options.apiBaseUrl ?? "https://api.prod.whoop.com",
+      webhookSignatureHeader: "x-whoop-signature",
+      oauth: {
+        tokenUrl: options.oauth?.tokenUrl ?? "https://api.prod.whoop.com/oauth/oauth2/token",
+        ...options.oauth
+      },
+      ...options
+    });
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      apiPath: "/v2/activity/workout",
+      mcpTool: "whoop_list_activities",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthActivity(item, this.context(input), "workout")
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      apiPath: "/v2/activity/workout",
+      mcpTool: "whoop_list_workouts",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(params) {
+    return this.fetchSleep(params, {
+      apiPath: "/v2/activity/sleep",
+      mcpTool: "whoop_list_sleep",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthSleep(item, this.context(input))
+    });
+  }
+  async listBiometrics(params) {
+    return this.fetchBiometrics(params, {
+      apiPath: "/v2/recovery",
+      mcpTool: "whoop_list_biometrics",
+      buildQuery: withMetricTypes,
+      mapItem: (item, input) => toHealthBiometric(item, this.context(input), "recovery_score")
+    });
+  }
+  async listNutrition(_params) {
+    throw this.unsupported("nutrition");
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      apiPath: "/v2/user/profile/basic",
+      mcpTool: "whoop_connection_status"
+    });
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+
+class OuraHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.oura",
+      apiBaseUrl: options.apiBaseUrl ?? "https://api.ouraring.com",
+      webhookSignatureHeader: "x-oura-signature",
+      oauth: {
+        tokenUrl: options.oauth?.tokenUrl ?? "https://api.ouraring.com/oauth/token",
+        ...options.oauth
+      },
+      ...options
+    });
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      apiPath: "/v2/usercollection/daily_activity",
+      mcpTool: "oura_list_activities",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthActivity(item, this.context(input))
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      apiPath: "/v2/usercollection/workout",
+      mcpTool: "oura_list_workouts",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(params) {
+    return this.fetchSleep(params, {
+      apiPath: "/v2/usercollection/sleep",
+      mcpTool: "oura_list_sleep",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthSleep(item, this.context(input))
+    });
+  }
+  async listBiometrics(params) {
+    return this.fetchBiometrics(params, {
+      apiPath: "/v2/usercollection/daily_readiness",
+      mcpTool: "oura_list_biometrics",
+      buildQuery: withMetricTypes,
+      mapItem: (item, input) => toHealthBiometric(item, this.context(input), "readiness_score")
+    });
+  }
+  async listNutrition(_params) {
+    throw this.unsupported("nutrition");
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      apiPath: "/v2/usercollection/personal_info",
+      mcpTool: "oura_connection_status"
+    });
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+
+class StravaHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.strava",
+      apiBaseUrl: options.apiBaseUrl ?? "https://www.strava.com",
+      webhookSignatureHeader: "x-strava-signature",
+      oauth: {
+        tokenUrl: options.oauth?.tokenUrl ?? "https://www.strava.com/oauth/token",
+        ...options.oauth
+      },
+      ...options
+    });
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      apiPath: "/api/v3/athlete/activities",
+      mcpTool: "strava_list_activities",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthActivity(item, this.context(input))
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      apiPath: "/api/v3/athlete/activities",
+      mcpTool: "strava_list_workouts",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(_params) {
+    throw this.unsupported("sleep");
+  }
+  async listBiometrics(_params) {
+    throw this.unsupported("biometrics");
+  }
+  async listNutrition(_params) {
+    throw this.unsupported("nutrition");
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      apiPath: "/api/v3/athlete",
+      mcpTool: "strava_connection_status"
+    });
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+
+class FitbitHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.fitbit",
+      apiBaseUrl: options.apiBaseUrl ?? "https://api.fitbit.com",
+      webhookSignatureHeader: "x-fitbit-signature",
+      oauth: {
+        tokenUrl: options.oauth?.tokenUrl ?? "https://api.fitbit.com/oauth2/token",
+        ...options.oauth
+      },
+      ...options
+    });
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      apiPath: "/1/user/-/activities/list.json",
+      mcpTool: "fitbit_list_activities",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthActivity(item, this.context(input))
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      apiPath: "/1/user/-/activities/list.json",
+      mcpTool: "fitbit_list_workouts",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(params) {
+    return this.fetchSleep(params, {
+      apiPath: "/1.2/user/-/sleep/list.json",
+      mcpTool: "fitbit_list_sleep",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthSleep(item, this.context(input))
+    });
+  }
+  async listBiometrics(params) {
+    return this.fetchBiometrics(params, {
+      apiPath: "/1/user/-/body/log/weight/date/today/1m.json",
+      mcpTool: "fitbit_list_biometrics",
+      buildQuery: withMetricTypes,
+      mapItem: (item, input) => toHealthBiometric(item, this.context(input), "weight")
+    });
+  }
+  async listNutrition(params) {
+    return this.fetchNutrition(params, {
+      apiPath: "/1/user/-/foods/log/date/today.json",
+      mcpTool: "fitbit_list_nutrition",
+      buildQuery: buildSharedQuery,
+      mapItem: (item, input) => toHealthNutrition(item, this.context(input))
+    });
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      apiPath: "/1/user/-/profile.json",
+      mcpTool: "fitbit_connection_status"
+    });
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+
+// src/impls/health/hybrid-health-providers.ts
+var LIMITED_PROVIDER_SLUG = {
+  "health.garmin": "garmin",
+  "health.myfitnesspal": "myfitnesspal",
+  "health.eightsleep": "eightsleep",
+  "health.peloton": "peloton"
+};
+function buildSharedQuery2(params) {
+  return {
+    tenantId: params.tenantId,
+    connectionId: params.connectionId,
+    userId: params.userId,
+    from: params.from,
+    to: params.to,
+    cursor: params.cursor,
+    pageSize: params.pageSize
+  };
+}
+
+class GarminHealthProvider extends OpenWearablesHealthProvider {
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: "health.garmin",
+      upstreamProvider: "garmin"
+    });
+  }
+}
+
+class MyFitnessPalHealthProvider extends OpenWearablesHealthProvider {
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: "health.myfitnesspal",
+      upstreamProvider: "myfitnesspal"
+    });
+  }
+}
+
+class EightSleepHealthProvider extends OpenWearablesHealthProvider {
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: "health.eightsleep",
+      upstreamProvider: "eightsleep"
+    });
+  }
+}
+
+class PelotonHealthProvider extends OpenWearablesHealthProvider {
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: "health.peloton",
+      upstreamProvider: "peloton"
+    });
+  }
+}
+
+class UnofficialHealthAutomationProvider extends BaseHealthProvider {
+  providerSlugValue;
+  constructor(options) {
+    super({
+      ...options,
+      providerKey: options.providerKey,
+      webhookSignatureHeader: "x-unofficial-signature"
+    });
+    this.providerSlugValue = LIMITED_PROVIDER_SLUG[options.providerKey];
+  }
+  async listActivities(params) {
+    return this.fetchActivities(params, {
+      mcpTool: `${this.providerSlugValue}_list_activities`,
+      buildQuery: buildSharedQuery2,
+      mapItem: (item, input) => toHealthActivity(item, this.context(input), "activity")
+    });
+  }
+  async listWorkouts(params) {
+    return this.fetchWorkouts(params, {
+      mcpTool: `${this.providerSlugValue}_list_workouts`,
+      buildQuery: buildSharedQuery2,
+      mapItem: (item, input) => toHealthWorkout(item, this.context(input))
+    });
+  }
+  async listSleep(params) {
+    return this.fetchSleep(params, {
+      mcpTool: `${this.providerSlugValue}_list_sleep`,
+      buildQuery: buildSharedQuery2,
+      mapItem: (item, input) => toHealthSleep(item, this.context(input))
+    });
+  }
+  async listBiometrics(params) {
+    return this.fetchBiometrics(params, {
+      mcpTool: `${this.providerSlugValue}_list_biometrics`,
+      buildQuery: (input) => ({
+        ...buildSharedQuery2(input),
+        metricTypes: input.metricTypes
+      }),
+      mapItem: (item, input) => toHealthBiometric(item, this.context(input))
+    });
+  }
+  async listNutrition(params) {
+    return this.fetchNutrition(params, {
+      mcpTool: `${this.providerSlugValue}_list_nutrition`,
+      buildQuery: buildSharedQuery2,
+      mapItem: (item, input) => toHealthNutrition(item, this.context(input))
+    });
+  }
+  async getConnectionStatus(params) {
+    return this.fetchConnectionStatus(params, {
+      mcpTool: `${this.providerSlugValue}_connection_status`
+    });
+  }
+  context(params) {
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      providerKey: this.providerKey
+    };
+  }
+}
+// src/impls/health-provider-factory.ts
+import {
+  isUnofficialHealthProviderAllowed,
+  resolveHealthStrategyOrder
+} from "@contractspec/integration.runtime/runtime";
+var OFFICIAL_TRANSPORT_SUPPORTED_BY_PROVIDER = {
+  "health.openwearables": false,
+  "health.whoop": true,
+  "health.apple-health": false,
+  "health.oura": true,
+  "health.strava": true,
+  "health.garmin": false,
+  "health.fitbit": true,
+  "health.myfitnesspal": false,
+  "health.eightsleep": false,
+  "health.peloton": false
+};
+var UNOFFICIAL_SUPPORTED_BY_PROVIDER = {
+  "health.openwearables": false,
+  "health.whoop": false,
+  "health.apple-health": false,
+  "health.oura": false,
+  "health.strava": false,
+  "health.garmin": true,
+  "health.fitbit": false,
+  "health.myfitnesspal": true,
+  "health.eightsleep": true,
+  "health.peloton": true
+};
+function createHealthProviderFromContext(context, secrets) {
+  const providerKey = context.spec.meta.key;
+  const config = toFactoryConfig(context.config);
+  const strategyOrder = buildStrategyOrder(config);
+  const attemptLogs = [];
+  for (let index = 0;index < strategyOrder.length; index += 1) {
+    const strategy = strategyOrder[index];
+    if (!strategy)
+      continue;
+    const route = index === 0 ? "primary" : "fallback";
+    if (!supportsStrategy(providerKey, strategy)) {
+      attemptLogs.push(`${strategy}: unsupported by ${providerKey}`);
+      continue;
+    }
+    if (!hasCredentialsForStrategy(strategy, config, secrets)) {
+      attemptLogs.push(`${strategy}: missing credentials`);
+      continue;
+    }
+    const provider = createHealthProviderForStrategy(providerKey, strategy, route, config, secrets);
+    if (provider) {
+      return provider;
+    }
+    attemptLogs.push(`${strategy}: not available`);
+  }
+  throw new Error(`Unable to resolve health provider for ${providerKey}. Strategies attempted: ${attemptLogs.join(", ")}.`);
+}
+function createHealthProviderForStrategy(providerKey, strategy, route, config, secrets) {
+  const options = {
+    transport: strategy,
+    apiBaseUrl: config.apiBaseUrl,
+    mcpUrl: config.mcpUrl,
+    apiKey: getSecretString(secrets, "apiKey"),
+    accessToken: getSecretString(secrets, "accessToken"),
+    mcpAccessToken: getSecretString(secrets, "mcpAccessToken"),
+    webhookSecret: getSecretString(secrets, "webhookSecret"),
+    route,
+    oauth: {
+      tokenUrl: config.oauthTokenUrl,
+      refreshToken: getSecretString(secrets, "refreshToken"),
+      clientId: getSecretString(secrets, "clientId"),
+      clientSecret: getSecretString(secrets, "clientSecret"),
+      tokenExpiresAt: getSecretString(secrets, "tokenExpiresAt")
+    }
+  };
+  if (strategy === "aggregator-api" || strategy === "aggregator-mcp") {
+    return createAggregatorProvider(providerKey, {
+      ...options,
+      aggregatorKey: "health.openwearables"
+    });
+  }
+  if (strategy === "unofficial") {
+    if (!isUnofficialHealthProviderAllowed(providerKey, config)) {
+      return;
+    }
+    if (providerKey !== "health.myfitnesspal" && providerKey !== "health.eightsleep" && providerKey !== "health.peloton" && providerKey !== "health.garmin") {
+      return;
+    }
+    return new UnofficialHealthAutomationProvider({
+      ...options,
+      providerKey
+    });
+  }
+  if (strategy === "official-mcp") {
+    return createOfficialProvider(providerKey, {
+      ...options,
+      transport: "official-mcp"
+    });
+  }
+  return createOfficialProvider(providerKey, options);
+}
+function createAggregatorProvider(providerKey, options) {
+  if (providerKey === "health.apple-health") {
+    return new AppleHealthBridgeProvider(options);
+  }
+  if (providerKey === "health.garmin") {
+    return new GarminHealthProvider(options);
+  }
+  if (providerKey === "health.myfitnesspal") {
+    return new MyFitnessPalHealthProvider(options);
+  }
+  if (providerKey === "health.eightsleep") {
+    return new EightSleepHealthProvider(options);
+  }
+  if (providerKey === "health.peloton") {
+    return new PelotonHealthProvider(options);
+  }
+  if (providerKey === "health.openwearables") {
+    return new OpenWearablesHealthProvider(options);
+  }
+  return new OpenWearablesHealthProvider({
+    ...options,
+    providerKey,
+    upstreamProvider: providerKey.replace("health.", "")
+  });
+}
+function createOfficialProvider(providerKey, options) {
+  switch (providerKey) {
+    case "health.openwearables":
+      return new OpenWearablesHealthProvider(options);
+    case "health.whoop":
+      return new WhoopHealthProvider(options);
+    case "health.apple-health":
+      return new AppleHealthBridgeProvider(options);
+    case "health.oura":
+      return new OuraHealthProvider(options);
+    case "health.strava":
+      return new StravaHealthProvider(options);
+    case "health.garmin":
+      return new GarminHealthProvider(options);
+    case "health.fitbit":
+      return new FitbitHealthProvider(options);
+    case "health.myfitnesspal":
+      return new MyFitnessPalHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
+    case "health.eightsleep":
+      return new EightSleepHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
+    case "health.peloton":
+      return new PelotonHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
+    default:
+      throw new Error(`Unsupported health provider key: ${providerKey}`);
+  }
+}
+function toFactoryConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return {};
+  }
+  const record = config;
+  return {
+    apiBaseUrl: asString(record.apiBaseUrl),
+    mcpUrl: asString(record.mcpUrl),
+    oauthTokenUrl: asString(record.oauthTokenUrl),
+    defaultTransport: normalizeTransport(record.defaultTransport),
+    strategyOrder: normalizeTransportArray(record.strategyOrder),
+    allowUnofficial: typeof record.allowUnofficial === "boolean" ? record.allowUnofficial : false,
+    unofficialAllowList: Array.isArray(record.unofficialAllowList) ? record.unofficialAllowList.map((item) => typeof item === "string" ? item : undefined).filter((item) => Boolean(item)) : undefined
+  };
+}
+function buildStrategyOrder(config) {
+  const order = resolveHealthStrategyOrder(config);
+  if (!config.defaultTransport) {
+    return order;
+  }
+  const withoutDefault = order.filter((item) => item !== config.defaultTransport);
+  return [config.defaultTransport, ...withoutDefault];
+}
+function normalizeTransport(value) {
+  if (typeof value !== "string")
+    return;
+  if (value === "official-api" || value === "official-mcp" || value === "aggregator-api" || value === "aggregator-mcp" || value === "unofficial") {
+    return value;
+  }
+  return;
+}
+function normalizeTransportArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const transports = value.map((item) => normalizeTransport(item)).filter((item) => Boolean(item));
+  return transports.length > 0 ? transports : undefined;
+}
+function supportsStrategy(providerKey, strategy) {
+  if (strategy === "official-api" || strategy === "official-mcp") {
+    return OFFICIAL_TRANSPORT_SUPPORTED_BY_PROVIDER[providerKey];
+  }
+  if (strategy === "unofficial") {
+    return UNOFFICIAL_SUPPORTED_BY_PROVIDER[providerKey];
+  }
+  return true;
+}
+function hasCredentialsForStrategy(strategy, config, secrets) {
+  const hasApiCredential = Boolean(getSecretString(secrets, "accessToken")) || Boolean(getSecretString(secrets, "apiKey"));
+  const hasMcpCredential = Boolean(getSecretString(secrets, "mcpAccessToken")) || hasApiCredential;
+  if (strategy === "official-api" || strategy === "aggregator-api") {
+    return hasApiCredential;
+  }
+  if (strategy === "official-mcp" || strategy === "aggregator-mcp") {
+    return Boolean(config.mcpUrl) && hasMcpCredential;
+  }
+  const hasAutomationCredential = hasMcpCredential || Boolean(getSecretString(secrets, "username")) && Boolean(getSecretString(secrets, "password"));
+  return Boolean(config.mcpUrl) && hasAutomationCredential;
+}
+function getSecretString(secrets, key) {
+  const value = secrets[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+
+// src/impls/mistral-llm.ts
+import { Mistral } from "@mistralai/mistralai";
+
+class MistralLLMProvider {
+  client;
+  defaultModel;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("MistralLLMProvider requires an apiKey");
+    }
+    this.client = options.client ?? new Mistral({
+      apiKey: options.apiKey,
+      serverURL: options.serverURL,
+      userAgent: options.userAgentSuffix ? `${options.userAgentSuffix}` : undefined
+    });
+    this.defaultModel = options.defaultModel ?? "mistral-large-latest";
+  }
+  async chat(messages, options = {}) {
+    const request = this.buildChatRequest(messages, options);
+    const response = await this.client.chat.complete(request);
+    return this.buildLLMResponse(response);
+  }
+  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,
@@ -2265,77 +3617,506 @@ class MistralLLMProvider {
       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
-      }
-    }));
+  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 mapFinishReason(reason) {
+  if (!reason)
+    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;
+  }
+}
+
+// src/impls/mistral-embedding.ts
+import { Mistral as Mistral2 } from "@mistralai/mistralai";
+
+class MistralEmbeddingProvider {
+  client;
+  defaultModel;
+  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.defaultModel = options.defaultModel ?? "mistral-embed";
+  }
+  async embedDocuments(documents, options) {
+    if (documents.length === 0)
+      return [];
+    const model = options?.model ?? this.defaultModel;
+    const response = await this.client.embeddings.create({
+      model,
+      inputs: documents.map((doc) => doc.text)
+    });
+    return response.data.map((item, index) => ({
+      id: documents[index]?.id ?? (item.index != null ? `embedding-${item.index}` : `embedding-${index}`),
+      vector: item.embedding ?? [],
+      dimensions: item.embedding?.length ?? 0,
+      model: response.model,
+      metadata: documents[index]?.metadata ? Object.fromEntries(Object.entries(documents[index]?.metadata ?? {}).map(([key, value]) => [key, String(value)])) : undefined
+    }));
+  }
+  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;
+  }
+}
+
+// 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;
+  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;
+  }
+  async transcribe(input) {
+    const formData = new FormData;
+    const model = input.model ?? this.defaultModel;
+    const mimeType = AUDIO_MIME_BY_FORMAT[input.audio.format] ?? "audio/wav";
+    const fileName = `audio.${input.audio.format}`;
+    const audioBytes = new Uint8Array(input.audio.data);
+    const blob = new Blob([audioBytes], { type: mimeType });
+    formData.append("file", blob, fileName);
+    formData.append("model", model);
+    formData.append("response_format", "verbose_json");
+    const language = input.language ?? this.defaultLanguage;
+    if (language) {
+      formData.append("language", language);
+    }
+    const response = await this.fetchImpl(`${this.baseUrl}/audio/transcriptions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Mistral transcription request failed (${response.status}): ${body}`);
+    }
+    const payload = await response.json();
+    return toTranscriptionResult(payload, input);
+  }
+}
+function toTranscriptionResult(payload, input) {
+  const record = 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
+    });
+  }
+  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 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;
+    }
+    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;
+    }
+    seen.add(segment.speakerId);
+    speakers.push({
+      id: segment.speakerId,
+      name: segment.speakerName
+    });
+  }
+  return speakers;
+}
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function asRecord2(value) {
+  if (value && typeof value === "object") {
+    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;
+}
+function secondsToMs(value) {
+  return Math.round(value * 1000);
+}
+
+// src/impls/mistral-conversational.session.ts
+class MistralConversationSession {
+  events;
+  queue = new AsyncEventQueue;
+  turns = [];
+  history = [];
+  sessionId = crypto.randomUUID();
+  startedAt = Date.now();
+  sessionConfig;
+  defaultModel;
+  complete;
+  sttProvider;
+  pending = Promise.resolve();
+  closed = false;
+  closedSummary;
+  constructor(options) {
+    this.sessionConfig = options.sessionConfig;
+    this.defaultModel = options.defaultModel;
+    this.complete = options.complete;
+    this.sttProvider = options.sttProvider;
+    this.events = this.queue;
+    this.queue.push({
+      type: "session_started",
+      sessionId: this.sessionId
+    });
+  }
+  sendAudio(chunk) {
+    if (this.closed) {
+      return;
+    }
+    this.pending = this.pending.then(async () => {
+      const transcription = await this.sttProvider.transcribe({
+        audio: {
+          data: chunk,
+          format: this.sessionConfig.inputFormat ?? "pcm",
+          sampleRateHz: 16000
+        },
+        language: this.sessionConfig.language
+      });
+      const transcriptText = transcription.text.trim();
+      if (transcriptText.length > 0) {
+        await this.handleUserText(transcriptText);
+      }
+    }).catch((error) => {
+      this.emitError(error);
+    });
+  }
+  sendText(text) {
+    if (this.closed) {
+      return;
+    }
+    const normalized = text.trim();
+    if (normalized.length === 0) {
+      return;
+    }
+    this.pending = this.pending.then(() => this.handleUserText(normalized)).catch((error) => {
+      this.emitError(error);
+    });
+  }
+  interrupt() {
+    if (this.closed) {
+      return;
+    }
+    this.queue.push({
+      type: "error",
+      error: new Error("Interrupt is not supported for non-streaming sessions.")
+    });
+  }
+  async close() {
+    if (this.closedSummary) {
+      return this.closedSummary;
+    }
+    this.closed = true;
+    await this.pending;
+    const durationMs = Date.now() - this.startedAt;
+    const summary = {
+      sessionId: this.sessionId,
+      durationMs,
+      turns: this.turns.map((turn) => ({
+        role: turn.role === "assistant" ? "agent" : turn.role,
+        text: turn.text,
+        startMs: turn.startMs,
+        endMs: turn.endMs
+      })),
+      transcript: this.turns.map((turn) => `${turn.role}: ${turn.text}`).join(`
+`)
+    };
+    this.closedSummary = summary;
+    this.queue.push({
+      type: "session_ended",
+      reason: "closed_by_client",
+      durationMs
+    });
+    this.queue.close();
+    return summary;
+  }
+  async handleUserText(text) {
+    if (this.closed) {
+      return;
+    }
+    const userStart = Date.now();
+    this.queue.push({ type: "user_speech_started" });
+    this.queue.push({ type: "user_speech_ended", transcript: text });
+    this.queue.push({
+      type: "transcript",
+      role: "user",
+      text,
+      timestamp: userStart
+    });
+    this.turns.push({
+      role: "user",
+      text,
+      startMs: userStart,
+      endMs: Date.now()
+    });
+    this.history.push({ role: "user", content: text });
+    const assistantStart = Date.now();
+    const assistantText = await this.complete(this.history, {
+      ...this.sessionConfig,
+      llmModel: this.sessionConfig.llmModel ?? this.defaultModel
+    });
+    if (this.closed) {
+      return;
+    }
+    const normalizedAssistantText = assistantText.trim();
+    const finalAssistantText = normalizedAssistantText.length > 0 ? normalizedAssistantText : "I was unable to produce a response.";
+    this.queue.push({
+      type: "agent_speech_started",
+      text: finalAssistantText
+    });
+    this.queue.push({
+      type: "transcript",
+      role: "agent",
+      text: finalAssistantText,
+      timestamp: assistantStart
+    });
+    this.queue.push({ type: "agent_speech_ended" });
+    this.turns.push({
+      role: "assistant",
+      text: finalAssistantText,
+      startMs: assistantStart,
+      endMs: Date.now()
+    });
+    this.history.push({ role: "assistant", content: finalAssistantText });
+  }
+  emitError(error) {
+    if (this.closed) {
+      return;
+    }
+    this.queue.push({ type: "error", error: toError(error) });
   }
 }
-function mapFinishReason(reason) {
-  if (!reason)
-    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;
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
   }
+  return new Error(String(error));
 }
 
-// src/impls/mistral-embedding.ts
-import { Mistral as Mistral2 } from "@mistralai/mistralai";
+// 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 MistralEmbeddingProvider {
-  client;
+class MistralConversationalProvider {
+  apiKey;
   defaultModel;
+  defaultVoiceId;
+  baseUrl;
+  fetchImpl;
+  sttProvider;
   constructor(options) {
     if (!options.apiKey) {
-      throw new Error("MistralEmbeddingProvider requires an apiKey");
+      throw new Error("MistralConversationalProvider requires an apiKey");
     }
-    this.client = options.client ?? new Mistral2({
+    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,
-      serverURL: options.serverURL
+      defaultModel: options.sttOptions?.defaultModel,
+      defaultLanguage: options.sttOptions?.defaultLanguage,
+      serverURL: options.sttOptions?.serverURL ?? options.serverURL,
+      fetchImpl: this.fetchImpl
     });
-    this.defaultModel = options.defaultModel ?? "mistral-embed";
   }
-  async embedDocuments(documents, options) {
-    if (documents.length === 0)
-      return [];
-    const model = options?.model ?? this.defaultModel;
-    const response = await this.client.embeddings.create({
-      model,
-      inputs: documents.map((doc) => doc.text)
+  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
     });
-    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 embedQuery(query, options) {
-    const [result] = await this.embedDocuments([{ id: "query", text: query }], options);
-    if (!result) {
-      throw new Error("Failed to compute embedding for query");
+  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 });
     }
-    return result;
+    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
@@ -2737,7 +4518,7 @@ function distanceToScore(distance, metric) {
 
 // src/impls/stripe-payments.ts
 import Stripe from "stripe";
-var API_VERSION = "2026-01-28.clover";
+var API_VERSION = "2026-02-25.clover";
 
 class StripePaymentsProvider {
   stripe;
@@ -3402,8 +5183,320 @@ function mapStatus(status) {
   }
 }
 
+// src/impls/messaging-slack.ts
+class SlackMessagingProvider {
+  botToken;
+  defaultChannelId;
+  apiBaseUrl;
+  constructor(options) {
+    this.botToken = options.botToken;
+    this.defaultChannelId = options.defaultChannelId;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://slack.com/api";
+  }
+  async sendMessage(input) {
+    const channel = input.channelId ?? input.recipientId ?? this.defaultChannelId;
+    if (!channel) {
+      throw new Error("Slack sendMessage requires channelId, recipientId, or defaultChannelId.");
+    }
+    const payload = {
+      channel,
+      text: input.text,
+      mrkdwn: input.markdown ?? true,
+      thread_ts: input.threadId
+    };
+    const response = await fetch(`${this.apiBaseUrl}/chat.postMessage`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.botToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    const body = await response.json();
+    if (!response.ok || !body.ok || !body.ts) {
+      throw new Error(`Slack sendMessage failed: ${body.error ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: `slack:${body.channel ?? channel}:${body.ts}`,
+      providerMessageId: body.ts,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        channelId: body.channel ?? channel
+      }
+    };
+  }
+  async updateMessage(messageId, input) {
+    const channel = input.channelId ?? this.defaultChannelId;
+    if (!channel) {
+      throw new Error("Slack updateMessage requires channelId or defaultChannelId.");
+    }
+    const response = await fetch(`${this.apiBaseUrl}/chat.update`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.botToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        channel,
+        ts: messageId,
+        text: input.text,
+        mrkdwn: input.markdown ?? true
+      })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.ok || !body.ts) {
+      throw new Error(`Slack updateMessage failed: ${body.error ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: `slack:${body.channel ?? channel}:${body.ts}`,
+      providerMessageId: body.ts,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        channelId: body.channel ?? channel
+      }
+    };
+  }
+}
+
+// src/impls/messaging-github.ts
+class GithubMessagingProvider {
+  token;
+  defaultOwner;
+  defaultRepo;
+  apiBaseUrl;
+  constructor(options) {
+    this.token = options.token;
+    this.defaultOwner = options.defaultOwner;
+    this.defaultRepo = options.defaultRepo;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.github.com";
+  }
+  async sendMessage(input) {
+    const target = this.resolveTarget(input);
+    const response = await fetch(`${this.apiBaseUrl}/repos/${target.owner}/${target.repo}/issues/${target.issueNumber}/comments`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        accept: "application/vnd.github+json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ body: input.text })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.id) {
+      throw new Error(`GitHub sendMessage failed: ${body.message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: String(body.id),
+      providerMessageId: body.node_id,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        url: body.html_url ?? "",
+        owner: target.owner,
+        repo: target.repo,
+        issueNumber: String(target.issueNumber)
+      }
+    };
+  }
+  async updateMessage(messageId, input) {
+    const owner = input.metadata?.owner ?? this.defaultOwner;
+    const repo = input.metadata?.repo ?? this.defaultRepo;
+    if (!owner || !repo) {
+      throw new Error("GitHub updateMessage requires owner and repo metadata.");
+    }
+    const response = await fetch(`${this.apiBaseUrl}/repos/${owner}/${repo}/issues/comments/${messageId}`, {
+      method: "PATCH",
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        accept: "application/vnd.github+json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ body: input.text })
+    });
+    const body = await response.json();
+    if (!response.ok || !body.id) {
+      throw new Error(`GitHub updateMessage failed: ${body.message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: String(body.id),
+      providerMessageId: body.node_id,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        url: body.html_url ?? "",
+        owner,
+        repo
+      }
+    };
+  }
+  resolveTarget(input) {
+    const parsedRecipient = parseRecipient(input.recipientId);
+    const owner = parsedRecipient?.owner ?? this.defaultOwner;
+    const repo = parsedRecipient?.repo ?? this.defaultRepo;
+    const issueNumber = parsedRecipient?.issueNumber ?? parseIssueNumber(input.threadId);
+    if (!owner || !repo || issueNumber == null) {
+      throw new Error("GitHub sendMessage requires owner/repo and issueNumber (use recipientId like owner/repo#123 or provide defaults + threadId).");
+    }
+    return {
+      owner,
+      repo,
+      issueNumber
+    };
+  }
+}
+function parseRecipient(value) {
+  if (!value)
+    return null;
+  const match = value.trim().match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (!match)
+    return null;
+  const owner = match[1];
+  const repo = match[2];
+  const issueNumber = Number(match[3]);
+  if (!owner || !repo || !Number.isInteger(issueNumber)) {
+    return null;
+  }
+  return { owner, repo, issueNumber };
+}
+function parseIssueNumber(value) {
+  if (!value)
+    return null;
+  const numeric = Number(value);
+  return Number.isInteger(numeric) ? numeric : null;
+}
+
+// src/impls/messaging-whatsapp-meta.ts
+class MetaWhatsappMessagingProvider {
+  accessToken;
+  phoneNumberId;
+  apiVersion;
+  constructor(options) {
+    this.accessToken = options.accessToken;
+    this.phoneNumberId = options.phoneNumberId;
+    this.apiVersion = options.apiVersion ?? "v22.0";
+  }
+  async sendMessage(input) {
+    const to = input.recipientId;
+    if (!to) {
+      throw new Error("Meta WhatsApp sendMessage requires recipientId.");
+    }
+    const response = await fetch(`https://graph.facebook.com/${this.apiVersion}/${this.phoneNumberId}/messages`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.accessToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        to,
+        type: "text",
+        text: {
+          body: input.text,
+          preview_url: false
+        }
+      })
+    });
+    const body = await response.json();
+    const messageId = body.messages?.[0]?.id;
+    if (!response.ok || !messageId) {
+      const errorCode = body.error?.code != null ? String(body.error.code) : "";
+      throw new Error(`Meta WhatsApp sendMessage failed: ${body.error?.message ?? `HTTP_${response.status}`}${errorCode ? ` (${errorCode})` : ""}`);
+    }
+    return {
+      id: messageId,
+      providerMessageId: messageId,
+      status: "sent",
+      sentAt: new Date,
+      metadata: {
+        phoneNumberId: this.phoneNumberId
+      }
+    };
+  }
+}
+
+// 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;
+  }
+  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()
+    });
+    const body = await response.json();
+    if (!response.ok || !body.sid) {
+      throw new Error(`Twilio WhatsApp sendMessage failed: ${body.error_message ?? `HTTP_${response.status}`}`);
+    }
+    return {
+      id: body.sid,
+      providerMessageId: body.sid,
+      status: mapTwilioStatus(body.status),
+      sentAt: new Date,
+      errorCode: body.error_code != null ? String(body.error_code) : undefined,
+      errorMessage: body.error_message ?? undefined,
+      metadata: {
+        from,
+        to
+      }
+    };
+  }
+}
+function normalizeWhatsappAddress(value) {
+  if (!value)
+    return null;
+  if (value.startsWith("whatsapp:"))
+    return value;
+  return `whatsapp:${value}`;
+}
+function mapTwilioStatus(status) {
+  switch (status) {
+    case "queued":
+    case "accepted":
+    case "scheduled":
+      return "queued";
+    case "sending":
+      return "sending";
+    case "delivered":
+      return "delivered";
+    case "failed":
+    case "undelivered":
+    case "canceled":
+      return "failed";
+    case "sent":
+    default:
+      return "sent";
+  }
+}
+
 // src/impls/powens-client.ts
-import { URL } from "node:url";
+import { URL as URL2 } from "node:url";
 var POWENS_BASE_URL = {
   sandbox: "https://api-sandbox.powens.com/v2",
   production: "https://api.powens.com/v2"
@@ -3489,7 +5582,7 @@ class PowensClient {
     });
   }
   async request(options) {
-    const url = new URL(options.path, this.baseUrl);
+    const url = new URL2(options.path, this.baseUrl);
     if (options.searchParams) {
       for (const [key, value] of Object.entries(options.searchParams)) {
         if (value === undefined || value === null)
@@ -3559,7 +5652,7 @@ class PowensClient {
     return this.token.accessToken;
   }
   async fetchAccessToken() {
-    const url = new URL("/oauth/token", this.baseUrl);
+    const url = new URL2("/oauth/token", this.baseUrl);
     const basicAuth = Buffer.from(`${this.clientId}:${this.clientSecret}`, "utf-8").toString("base64");
     const response = await this.fetchImpl(url, {
       method: "POST",
@@ -3908,7 +6001,7 @@ function resolveLabelIds(defaults, tags) {
 }
 
 // src/impls/jira.ts
-import { Buffer as Buffer4 } from "node:buffer";
+import { Buffer as Buffer5 } from "node:buffer";
 
 class JiraProjectManagementProvider {
   siteUrl;
@@ -3985,7 +6078,7 @@ function normalizeSiteUrl(siteUrl) {
   return siteUrl.replace(/\/$/, "");
 }
 function buildAuthHeader(email, apiToken) {
-  const token = Buffer4.from(`${email}:${apiToken}`).toString("base64");
+  const token = Buffer5.from(`${email}:${apiToken}`).toString("base64");
   return `Basic ${token}`;
 }
 function resolveIssueType(type, defaults) {
@@ -4188,7 +6281,7 @@ function buildParagraphBlocks(text) {
 }
 
 // src/impls/tldv-meeting-recorder.ts
-var DEFAULT_BASE_URL4 = "https://pasta.tldv.io/v1alpha1";
+var DEFAULT_BASE_URL6 = "https://pasta.tldv.io/v1alpha1";
 
 class TldvMeetingRecorderProvider {
   apiKey;
@@ -4196,7 +6289,7 @@ class TldvMeetingRecorderProvider {
   defaultPageSize;
   constructor(options) {
     this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL4;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL6;
     this.defaultPageSize = options.pageSize;
   }
   async listMeetings(params) {
@@ -4331,7 +6424,7 @@ async function safeReadError4(response) {
 }
 
 // src/impls/provider-factory.ts
-import { Buffer as Buffer5 } from "node:buffer";
+import { Buffer as Buffer6 } from "node:buffer";
 var SECRET_CACHE = new Map;
 
 class IntegrationProviderFactory {
@@ -4372,6 +6465,39 @@ class IntegrationProviderFactory {
         throw new Error(`Unsupported SMS integration: ${context.spec.meta.key}`);
     }
   }
+  async createMessagingProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "messaging.slack":
+        return new SlackMessagingProvider({
+          botToken: requireSecret(secrets, "botToken", "Slack bot token is required"),
+          defaultChannelId: config?.defaultChannelId,
+          apiBaseUrl: config?.apiBaseUrl
+        });
+      case "messaging.github":
+        return new GithubMessagingProvider({
+          token: requireSecret(secrets, "token", "GitHub token is required"),
+          defaultOwner: config?.defaultOwner,
+          defaultRepo: config?.defaultRepo,
+          apiBaseUrl: config?.apiBaseUrl
+        });
+      case "messaging.whatsapp.meta":
+        return new MetaWhatsappMessagingProvider({
+          accessToken: requireSecret(secrets, "accessToken", "Meta WhatsApp access token is required"),
+          phoneNumberId: requireConfig(context, "phoneNumberId", "Meta WhatsApp phoneNumberId is required"),
+          apiVersion: config?.apiVersion
+        });
+      case "messaging.whatsapp.twilio":
+        return new TwilioWhatsappMessagingProvider({
+          accountSid: requireSecret(secrets, "accountSid", "Twilio account SID is required"),
+          authToken: requireSecret(secrets, "authToken", "Twilio auth token is required"),
+          fromNumber: config?.fromNumber
+        });
+      default:
+        throw new Error(`Unsupported messaging integration: ${context.spec.meta.key}`);
+    }
+  }
   async createVectorStoreProvider(context) {
     const secrets = await this.loadSecrets(context);
     const config = context.config;
@@ -4470,6 +6596,41 @@ class IntegrationProviderFactory {
         throw new Error(`Unsupported voice integration: ${context.spec.meta.key}`);
     }
   }
+  async createSttProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "ai-voice-stt.mistral":
+        return new MistralSttProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
+          defaultModel: config?.model,
+          defaultLanguage: config?.language,
+          serverURL: config?.serverURL
+        });
+      default:
+        throw new Error(`Unsupported STT integration: ${context.spec.meta.key}`);
+    }
+  }
+  async createConversationalProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    const config = context.config;
+    switch (context.spec.meta.key) {
+      case "ai-voice-conv.mistral":
+        return new MistralConversationalProvider({
+          apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
+          defaultModel: config?.model,
+          defaultVoiceId: config?.defaultVoice,
+          serverURL: config?.serverURL,
+          sttOptions: {
+            defaultModel: config?.model,
+            defaultLanguage: config?.language,
+            serverURL: config?.serverURL
+          }
+        });
+      default:
+        throw new Error(`Unsupported conversational integration: ${context.spec.meta.key}`);
+    }
+  }
   async createProjectManagementProvider(context) {
     const secrets = await this.loadSecrets(context);
     const config = context.config;
@@ -4603,6 +6764,10 @@ class IntegrationProviderFactory {
         throw new Error(`Unsupported open banking integration: ${context.spec.meta.key}`);
     }
   }
+  async createHealthProvider(context) {
+    const secrets = await this.loadSecrets(context);
+    return createHealthProviderFromContext(context, secrets);
+  }
   async loadSecrets(context) {
     const cacheKey = context.connection.meta.id;
     if (SECRET_CACHE.has(cacheKey)) {
@@ -4616,7 +6781,7 @@ class IntegrationProviderFactory {
   }
 }
 function parseSecret(secret) {
-  const text = Buffer5.from(secret.data).toString("utf-8").trim();
+  const text = Buffer6.from(secret.data).toString("utf-8").trim();
   if (!text)
     return {};
   try {
@@ -4662,6 +6827,9 @@ export * from "@contractspec/lib.contracts-integrations";
 // src/sms.ts
 export * from "@contractspec/lib.contracts-integrations";
 
+// src/messaging.ts
+export * from "@contractspec/lib.contracts-integrations";
+
 // src/payments.ts
 export * from "@contractspec/lib.contracts-integrations";
 
@@ -4674,11 +6842,17 @@ export * from "@contractspec/lib.contracts-integrations";
 // src/meeting-recorder.ts
 export * from "@contractspec/lib.contracts-integrations";
 export {
+  createHealthProviderFromContext,
+  WhoopHealthProvider,
+  UnofficialHealthAutomationProvider,
+  TwilioWhatsappMessagingProvider,
   TwilioSmsProvider,
   TldvMeetingRecorderProvider,
   SupabaseVectorProvider,
   SupabasePostgresProvider,
   StripePaymentsProvider,
+  StravaHealthProvider,
+  SlackMessagingProvider,
   QdrantVectorProvider,
   PowensOpenBankingProvider,
   PowensClientError,
@@ -4686,9 +6860,16 @@ export {
   PostmarkEmailProvider,
   PosthogAnalyticsReader,
   PosthogAnalyticsProvider,
+  PelotonHealthProvider,
+  OuraHealthProvider,
+  OpenWearablesHealthProvider,
   NotionProjectManagementProvider,
+  MyFitnessPalHealthProvider,
+  MistralSttProvider,
   MistralLLMProvider,
   MistralEmbeddingProvider,
+  MistralConversationalProvider,
+  MetaWhatsappMessagingProvider,
   LinearProjectManagementProvider,
   JiraProjectManagementProvider,
   IntegrationProviderFactory,
@@ -4698,8 +6879,13 @@ export {
   GoogleCalendarProvider,
   GmailOutboundProvider,
   GmailInboundProvider,
+  GithubMessagingProvider,
+  GarminHealthProvider,
+  FitbitHealthProvider,
   FirefliesMeetingRecorderProvider,
   FathomMeetingRecorderProvider,
   FalVoiceProvider,
-  ElevenLabsVoiceProvider
+  ElevenLabsVoiceProvider,
+  EightSleepHealthProvider,
+  AppleHealthBridgeProvider
 };