@contractspec/integration.providers-impls 2.10.0 → 3.0.0

package/dist/impls/provider-factory.js

@@ -1,4 +1,48 @@
 // @bun
+// 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 = {
@@ -1465,7 +1509,286 @@ async function safeReadError3(response) {
   }
 }
 
+// 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();
+}
+
 // 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;
@@ -1473,146 +1796,191 @@ class BaseHealthProvider {
   mcpUrl;
   apiKey;
   accessToken;
+  refreshToken;
   mcpAccessToken;
   webhookSecret;
+  webhookSignatureHeader;
+  route;
+  aggregatorKey;
+  oauth;
   fetchFn;
   mcpRequestId = 0;
   constructor(options) {
     this.providerKey = options.providerKey;
     this.transport = options.transport;
-    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.example-health.local";
+    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) {
-    const result = await this.fetchList("activities", params);
-    return {
-      activities: result.items,
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
-      source: this.currentSource()
-    };
+  async listActivities(_params) {
+    throw this.unsupported("activities");
   }
-  async listWorkouts(params) {
-    const result = await this.fetchList("workouts", params);
+  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`
+    });
+  }
+  async syncActivities(params) {
+    return this.syncFromList(() => this.listActivities(params));
+  }
+  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 {
-      workouts: result.items,
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
+      activities: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
       source: this.currentSource()
     };
   }
-  async listSleep(params) {
-    const result = await this.fetchList("sleep", params);
+  async fetchWorkouts(params, config) {
+    const response = await this.fetchList(params, config);
     return {
-      sleep: result.items,
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
+      workouts: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
       source: this.currentSource()
     };
   }
-  async listBiometrics(params) {
-    const result = await this.fetchList("biometrics", params);
+  async fetchSleep(params, config) {
+    const response = await this.fetchList(params, config);
     return {
-      biometrics: result.items,
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
+      sleep: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
       source: this.currentSource()
     };
   }
-  async listNutrition(params) {
-    const result = await this.fetchList("nutrition", params);
+  async fetchBiometrics(params, config) {
+    const response = await this.fetchList(params, config);
     return {
-      nutrition: result.items,
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
+      biometrics: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
       source: this.currentSource()
     };
   }
-  async getConnectionStatus(params) {
-    const payload = await this.fetchRecord("connection/status", params);
-    const status = readString2(payload, "status") ?? "healthy";
+  async fetchNutrition(params, config) {
+    const response = await this.fetchList(params, config);
     return {
-      tenantId: params.tenantId,
-      connectionId: params.connectionId,
-      status: status === "healthy" || status === "degraded" || status === "error" || status === "disconnected" ? status : "healthy",
-      source: this.currentSource(),
-      lastCheckedAt: readString2(payload, "lastCheckedAt") ?? new Date().toISOString(),
-      errorCode: readString2(payload, "errorCode"),
-      errorMessage: readString2(payload, "errorMessage"),
-      metadata: asRecord(payload.metadata)
+      nutrition: response.items,
+      nextCursor: response.nextCursor,
+      hasMore: response.hasMore,
+      source: this.currentSource()
     };
   }
-  async syncActivities(params) {
-    return this.sync("activities", params);
-  }
-  async syncWorkouts(params) {
-    return this.sync("workouts", params);
-  }
-  async syncSleep(params) {
-    return this.sync("sleep", params);
-  }
-  async syncBiometrics(params) {
-    return this.sync("biometrics", params);
-  }
-  async syncNutrition(params) {
-    return this.sync("nutrition", params);
+  async fetchConnectionStatus(params, config) {
+    const payload = await this.fetchPayload(config, params);
+    return toHealthConnectionStatus(payload, params, this.currentSource());
   }
-  async parseWebhook(request) {
-    const payload = request.parsedBody ?? safeJsonParse(request.rawBody);
-    const body = asRecord(payload);
+  currentSource() {
     return {
       providerKey: this.providerKey,
-      eventType: readString2(body, "eventType") ?? readString2(body, "event"),
-      externalEntityId: readString2(body, "externalEntityId") ?? readString2(body, "entityId"),
-      entityType: normalizeEntityType(readString2(body, "entityType") ?? readString2(body, "type")),
-      receivedAt: new Date().toISOString(),
-      verified: await this.verifyWebhook(request),
-      payload
+      transport: this.transport,
+      route: this.route,
+      aggregatorKey: this.aggregatorKey
     };
   }
-  async verifyWebhook(request) {
-    if (!this.webhookSecret) {
-      return true;
-    }
-    const signature = readHeader(request.headers, "x-webhook-signature");
-    return signature === this.webhookSecret;
+  providerSlug() {
+    return this.providerKey.replace("health.", "").replace(/-/g, "_");
   }
-  async fetchList(resource, params) {
-    const payload = await this.fetchRecord(resource, params);
-    const items = asArray2(payload.items) ?? asArray2(payload[resource]) ?? asArray2(payload.records) ?? [];
+  unsupported(capability) {
+    return new HealthProviderCapabilityError(`${this.providerKey} does not support ${capability}`);
+  }
+  async syncFromList(executor) {
+    const result = await executor();
+    const records = countResultRecords(result);
     return {
-      items,
-      nextCursor: readString2(payload, "nextCursor") ?? readString2(payload, "cursor"),
-      hasMore: readBoolean2(payload, "hasMore")
+      synced: records,
+      failed: 0,
+      nextCursor: undefined,
+      source: result.source
     };
   }
-  async sync(resource, params) {
-    const payload = await this.fetchRecord(`sync/${resource}`, params, "POST");
+  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 {
-      synced: readNumber(payload, "synced") ?? 0,
-      failed: readNumber(payload, "failed") ?? 0,
-      nextCursor: readString2(payload, "nextCursor"),
-      errors: asArray2(payload.errors)?.map((item) => String(item)),
-      source: this.currentSource()
+      items,
+      nextCursor: pagination.nextCursor,
+      hasMore: pagination.hasMore
     };
   }
-  async fetchRecord(resource, params, method = "GET") {
-    if (this.transport.endsWith("mcp")) {
-      return this.callMcpTool(resource, params);
+  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 (!config.apiPath || !this.apiBaseUrl) {
+      throw new Error(`${this.providerKey} transport is missing an API path.`);
     }
-    const url = new URL(`${this.apiBaseUrl.replace(/\/$/, "")}/${resource}`);
-    if (method === "GET") {
-      for (const [key, value] of Object.entries(params)) {
+    if (method === "POST") {
+      return this.requestApi(config.apiPath, "POST", undefined, body);
+    }
+    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((item) => {
-            url.searchParams.append(key, String(item));
+          value.forEach((entry) => {
+            if (entry != null)
+              url.searchParams.append(key, String(entry));
           });
           continue;
         }
@@ -1621,22 +1989,22 @@ class BaseHealthProvider {
     }
     const response = await this.fetchFn(url, {
       method,
-      headers: {
-        "Content-Type": "application/json",
-        ...this.accessToken || this.apiKey ? { Authorization: `Bearer ${this.accessToken ?? this.apiKey}` } : {}
-      },
-      body: method === "POST" ? JSON.stringify(params) : undefined
+      headers: this.authorizationHeaders(),
+      body: method === "POST" ? JSON.stringify(body ?? {}) : undefined
     });
-    if (!response.ok) {
-      const errorBody = await safeResponseText(response);
-      throw new Error(`${this.providerKey} ${resource} failed (${response.status}): ${errorBody}`);
+    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);
     }
-    const data = await response.json();
-    return asRecord(data) ?? {};
+    return this.readResponsePayload(response, path);
   }
-  async callMcpTool(resource, params) {
+  async callMcpTool(toolName, args) {
     if (!this.mcpUrl) {
-      return {};
+      throw new Error(`${this.providerKey} MCP URL is not configured.`);
     }
     const response = await this.fetchFn(this.mcpUrl, {
       method: "POST",
@@ -1649,78 +2017,103 @@ class BaseHealthProvider {
         id: ++this.mcpRequestId,
         method: "tools/call",
         params: {
-          name: `${this.providerKey.replace("health.", "")}_${resource.replace(/\//g, "_")}`,
-          arguments: params
+          name: toolName,
+          arguments: args
         }
       })
     });
-    if (!response.ok) {
-      const errorBody = await safeResponseText(response);
-      throw new Error(`${this.providerKey} MCP ${resource} failed (${response.status}): ${errorBody}`);
-    }
-    const rpcPayload = await response.json();
-    const rpc = asRecord(rpcPayload);
-    const result = asRecord(rpc?.result) ?? {};
-    const structured = asRecord(result.structuredContent);
-    if (structured)
-      return structured;
-    const data = asRecord(result.data);
-    if (data)
-      return data;
-    return result;
+    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;
   }
-  currentSource() {
+  authorizationHeaders() {
+    const token = this.accessToken ?? this.apiKey;
     return {
-      providerKey: this.providerKey,
-      transport: this.transport,
-      route: "primary"
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
     };
   }
-}
-function safeJsonParse(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { rawBody: raw };
+  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 match = Object.entries(headers).find(([headerKey]) => headerKey.toLowerCase() === key.toLowerCase());
-  if (!match)
+  const target = key.toLowerCase();
+  const entry = Object.entries(headers).find(([headerKey]) => headerKey.toLowerCase() === target);
+  if (!entry)
     return;
-  const value = match[1];
+  const value = entry[1];
   return Array.isArray(value) ? value[0] : value;
 }
-function normalizeEntityType(value) {
-  if (!value)
-    return;
-  if (value === "activity" || value === "workout" || value === "sleep" || value === "biometric" || value === "nutrition") {
-    return value;
-  }
-  return;
-}
-function asRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return;
+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 value;
-}
-function asArray2(value) {
-  return Array.isArray(value) ? value : undefined;
-}
-function readString2(record, key) {
-  const value = record?.[key];
-  return typeof value === "string" ? value : undefined;
+  return 0;
 }
-function readBoolean2(record, key) {
-  const value = record?.[key];
-  return typeof value === "boolean" ? value : undefined;
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
 }
-function readNumber(record, key) {
-  const value = record?.[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { rawBody: raw };
+  }
 }
-async function safeResponseText(response) {
+async function safeReadText2(response) {
   try {
     return await response.text();
   } catch {
@@ -1728,133 +2121,530 @@ async function safeResponseText(response) {
   }
 }
 
-// src/impls/health/providers.ts
-function createProviderOptions(options, fallbackTransport) {
+// src/impls/health/official-health-providers.ts
+function buildSharedQuery(params) {
   return {
-    ...options,
-    transport: options.transport ?? fallbackTransport
+    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: "health.openwearables",
-      ...createProviderOptions(options, "aggregator-api")
+      providerKey: options.providerKey ?? "health.openwearables",
+      apiBaseUrl: options.apiBaseUrl ?? "https://api.openwearables.io",
+      webhookSignatureHeader: "x-openwearables-signature",
+      ...options
     });
+    this.upstreamProvider = options.upstreamProvider;
   }
-}
-
-class WhoopHealthProvider extends BaseHealthProvider {
-  constructor(options) {
-    super({
-      providerKey: "health.whoop",
-      ...createProviderOptions(options, "official-api")
+  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")
     });
   }
-}
-
-class AppleHealthBridgeProvider extends BaseHealthProvider {
-  constructor(options) {
-    super({
-      providerKey: "health.apple-health",
-      ...createProviderOptions(options, "aggregator-api")
+  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))
     });
   }
-}
-
-class OuraHealthProvider extends BaseHealthProvider {
-  constructor(options) {
-    super({
-      providerKey: "health.oura",
-      ...createProviderOptions(options, "official-api")
+  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))
     });
   }
-}
-
-class StravaHealthProvider extends BaseHealthProvider {
-  constructor(options) {
-    super({
-      providerKey: "health.strava",
-      ...createProviderOptions(options, "official-api")
+  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 GarminHealthProvider extends BaseHealthProvider {
+class AppleHealthBridgeProvider extends OpenWearablesHealthProvider {
   constructor(options) {
     super({
-      providerKey: "health.garmin",
-      ...createProviderOptions(options, "official-api")
+      ...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",
-      ...createProviderOptions(options, "official-api")
+      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
+    };
+  }
 }
 
-class MyFitnessPalHealthProvider extends BaseHealthProvider {
+// 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",
-      ...createProviderOptions(options, "official-api")
+      upstreamProvider: "myfitnesspal"
     });
   }
 }
 
-class EightSleepHealthProvider extends BaseHealthProvider {
+class EightSleepHealthProvider extends OpenWearablesHealthProvider {
   constructor(options) {
     super({
+      ...options,
       providerKey: "health.eightsleep",
-      ...createProviderOptions(options, "official-api")
+      upstreamProvider: "eightsleep"
     });
   }
 }
 
-class PelotonHealthProvider extends BaseHealthProvider {
+class PelotonHealthProvider extends OpenWearablesHealthProvider {
   constructor(options) {
     super({
+      ...options,
       providerKey: "health.peloton",
-      ...createProviderOptions(options, "official-api")
+      upstreamProvider: "peloton"
     });
   }
 }
 
 class UnofficialHealthAutomationProvider extends BaseHealthProvider {
+  providerSlugValue;
   constructor(options) {
     super({
-      ...createProviderOptions(options, "unofficial"),
-      providerKey: options.providerKey
+      ...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 errors = [];
-  for (const strategy of strategyOrder) {
-    const provider = createHealthProviderForStrategy(providerKey, strategy, config, secrets);
+  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;
     }
-    errors.push(`${strategy}: not available`);
+    attemptLogs.push(`${strategy}: not available`);
   }
-  throw new Error(`Unable to resolve health provider for ${providerKey}. Strategies attempted: ${errors.join(", ")}.`);
+  throw new Error(`Unable to resolve health provider for ${providerKey}. Strategies attempted: ${attemptLogs.join(", ")}.`);
 }
-function createHealthProviderForStrategy(providerKey, strategy, config, secrets) {
+function createHealthProviderForStrategy(providerKey, strategy, route, config, secrets) {
   const options = {
     transport: strategy,
     apiBaseUrl: config.apiBaseUrl,
@@ -1862,10 +2652,21 @@ function createHealthProviderForStrategy(providerKey, strategy, config, secrets)
     apiKey: getSecretString(secrets, "apiKey"),
     accessToken: getSecretString(secrets, "accessToken"),
     mcpAccessToken: getSecretString(secrets, "mcpAccessToken"),
-    webhookSecret: getSecretString(secrets, "webhookSecret")
+    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 new OpenWearablesHealthProvider(options);
+    return createAggregatorProvider(providerKey, {
+      ...options,
+      aggregatorKey: "health.openwearables"
+    });
   }
   if (strategy === "unofficial") {
     if (!isUnofficialHealthProviderAllowed(providerKey, config)) {
@@ -1887,6 +2688,31 @@ function createHealthProviderForStrategy(providerKey, strategy, config, secrets)
   }
   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":
@@ -1904,11 +2730,20 @@ function createOfficialProvider(providerKey, options) {
     case "health.fitbit":
       return new FitbitHealthProvider(options);
     case "health.myfitnesspal":
-      return new MyFitnessPalHealthProvider(options);
+      return new MyFitnessPalHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
     case "health.eightsleep":
-      return new EightSleepHealthProvider(options);
+      return new EightSleepHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
     case "health.peloton":
-      return new PelotonHealthProvider(options);
+      return new PelotonHealthProvider({
+        ...options,
+        transport: "aggregator-api"
+      });
     default:
       throw new Error(`Unsupported health provider key: ${providerKey}`);
   }
@@ -1921,6 +2756,7 @@ function toFactoryConfig(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,
@@ -1949,6 +2785,27 @@ function normalizeTransportArray(value) {
   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;
@@ -2192,77 +3049,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
@@ -2664,7 +3950,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;
@@ -3329,6 +4615,318 @@ 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 "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 as URL2 } from "url";
 var POWENS_BASE_URL = {
@@ -3835,7 +5433,7 @@ function resolveLabelIds(defaults, tags) {
 }
 
 // src/impls/jira.ts
-import { Buffer as Buffer4 } from "buffer";
+import { Buffer as Buffer5 } from "buffer";
 
 class JiraProjectManagementProvider {
   siteUrl;
@@ -3912,7 +5510,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) {
@@ -4115,7 +5713,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;
@@ -4123,7 +5721,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) {
@@ -4258,7 +5856,7 @@ async function safeReadError4(response) {
 }
 
 // src/impls/provider-factory.ts
-import { Buffer as Buffer5 } from "buffer";
+import { Buffer as Buffer6 } from "buffer";
 var SECRET_CACHE = new Map;
 
 class IntegrationProviderFactory {
@@ -4299,6 +5897,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;
@@ -4397,6 +6028,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;
@@ -4547,7 +6213,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 {