@skaile/workspaces 1.14.1 → 1.15.0

package/dist/channels/adapters/msteams.js

@@ -0,0 +1,595 @@
+import { makeConversationKey, normalizeMentions, parseConversationKey, makeQuestionCard, markdownToTeamsText } from '../../chunk-F2IBDVBP.js';
+import '../../chunk-NSBPE2FW.js';
+import { Buffer } from 'buffer';
+
+// channels/adapters/msteams/activity.ts
+var MESSAGE_ID_SEPARATOR = ";messageid=";
+function conversationKeyFromActivity(a) {
+  const sep = a.conversation.id.indexOf(MESSAGE_ID_SEPARATOR);
+  if (sep === -1) return makeConversationKey("msteams", a.conversation.id);
+  return makeConversationKey(
+    "msteams",
+    a.conversation.id.slice(0, sep),
+    a.conversation.id.slice(sep + MESSAGE_ID_SEPARATOR.length)
+  );
+}
+function tenantIdOfActivity(a) {
+  return a.conversation.tenantId ?? a.channelData?.tenant?.id;
+}
+function actorOfActivity(a) {
+  return {
+    platform: "msteams",
+    externalId: a.from.aadObjectId ?? a.from.id,
+    displayName: a.from.name ?? "",
+    tenantId: tenantIdOfActivity(a)
+  };
+}
+function stripMentionTokens(a) {
+  let text = a.text ?? "";
+  const entities = [];
+  for (const e of a.entities ?? []) {
+    if (e.type !== "mention" || !e.mentioned) continue;
+    const displayName = e.mentioned.name ?? "";
+    let offset = 0;
+    if (e.text) {
+      const at = text.indexOf(e.text);
+      if (at !== -1) {
+        text = text.slice(0, at) + displayName + text.slice(at + e.text.length);
+        offset = at;
+      }
+    }
+    entities.push({
+      externalId: e.mentioned.id,
+      displayName,
+      isBot: e.mentioned.id === a.recipient.id,
+      offset,
+      length: displayName.length
+    });
+  }
+  return { text, entities };
+}
+function optionOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const option = value.option;
+  return typeof option === "string" ? option : void 0;
+}
+async function activityToChannelMessage(a, identity) {
+  if (a.type !== "message") return null;
+  if (a.from.id === a.recipient.id) return null;
+  const conversationKey = conversationKeyFromActivity(a);
+  const { text, entities } = stripMentionTokens(a);
+  const mentions = await normalizeMentions(
+    entities,
+    (e) => ({
+      platform: "msteams",
+      externalId: e.externalId,
+      displayName: e.displayName,
+      tenantId: tenantIdOfActivity(a)
+    }),
+    identity
+  );
+  const actor = actorOfActivity(a);
+  const messageRef = {
+    platform: "msteams",
+    conversationKey,
+    messageId: a.id,
+    raw: { serviceUrl: a.serviceUrl, conversationId: a.conversation.id }
+  };
+  return {
+    id: crypto.randomUUID(),
+    // seq/sessionId are assigned on the session side; ingress carries placeholders.
+    seq: 0,
+    timestamp: a.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: "",
+    payload: { type: "prompt", prompt: text || (optionOf(a.value) ?? "") },
+    meta: {
+      mentions,
+      channel: {
+        platform: "msteams",
+        conversationKey,
+        eventId: a.id,
+        tenantId: tenantIdOfActivity(a),
+        actor: { externalId: actor.externalId, displayName: actor.displayName },
+        messageRef
+      }
+    }
+  };
+}
+
+// channels/adapters/msteams/client.ts
+var DEFAULT_LOGIN_BASE_URL = "https://login.microsoftonline.com/botframework.com";
+var BOTFRAMEWORK_SCOPE = "https://api.botframework.com/.default";
+var TOKEN_EXPIRY_MARGIN_MS = 6e4;
+var MAX_TRIES = 3;
+var MsTeamsApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "MsTeamsApiError";
+  }
+  status;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var MsTeamsClient = class {
+  opts;
+  fetchImpl;
+  now;
+  token;
+  constructor(opts) {
+    this.opts = opts;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.now = opts.now ?? Date.now;
+  }
+  /** client_credentials token for scope https://api.botframework.com/.default; cached until exp-60s. */
+  async getToken() {
+    if (this.token && this.token.expiresAt > this.now()) return this.token.value;
+    const loginBaseUrl = this.opts.loginBaseUrl ?? DEFAULT_LOGIN_BASE_URL;
+    const res = await this.fetchImpl(`${loginBaseUrl}/oauth2/v2.0/token`, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: this.opts.appId,
+        client_secret: this.opts.clientSecret,
+        scope: BOTFRAMEWORK_SCOPE
+      }).toString()
+    });
+    if (!res.ok) throw new MsTeamsApiError(res.status, `token request failed: ${res.status}`);
+    const body = await res.json();
+    this.token = {
+      value: body.access_token,
+      expiresAt: this.now() + body.expires_in * 1e3 - TOKEN_EXPIRY_MARGIN_MS
+    };
+    return body.access_token;
+  }
+  /** POST {serviceUrl}/v3/conversations/{conversationId}/activities[/{replyToId}] → { id }. */
+  async postActivity(serviceUrl, conversationId, activity, replyToId) {
+    const suffix = replyToId ? `/${encodeURIComponent(replyToId)}` : "";
+    const res = await this.request(
+      "POST",
+      `${this.activitiesUrl(serviceUrl, conversationId)}${suffix}`,
+      activity
+    );
+    const body = await res.json().catch(() => ({}));
+    return { id: body.id ?? "" };
+  }
+  /** PUT {serviceUrl}/v3/conversations/{conversationId}/activities/{activityId}. Same retry policy. */
+  async updateActivity(serviceUrl, conversationId, activityId, activity) {
+    const url = `${this.activitiesUrl(serviceUrl, conversationId)}/${encodeURIComponent(activityId)}`;
+    await this.request("PUT", url, activity);
+  }
+  activitiesUrl(serviceUrl, conversationId) {
+    const base = serviceUrl.replace(/\/+$/, "");
+    return `${base}/v3/conversations/${encodeURIComponent(conversationId)}/activities`;
+  }
+  /**
+   * Authorized JSON request honoring 429 Retry-After with jittered backoff,
+   * max 3 tries. One 401 forces a fresh token and a single immediate retry.
+   */
+  async request(method, url, body) {
+    let retried401 = false;
+    for (let attempt = 1; ; attempt++) {
+      const token = await this.getToken();
+      const res = await this.fetchImpl(url, {
+        method,
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (res.ok) return res;
+      if (res.status === 401 && !retried401 && attempt < MAX_TRIES) {
+        retried401 = true;
+        this.token = void 0;
+        continue;
+      }
+      if (res.status !== 429 || attempt >= MAX_TRIES) {
+        throw new MsTeamsApiError(res.status, `${method} ${url} failed: ${res.status}`);
+      }
+      const retryAfterSec = Number(res.headers.get("retry-after"));
+      const baseDelayMs = Number.isFinite(retryAfterSec) && retryAfterSec > 0 ? retryAfterSec * 1e3 : 1e3 * attempt;
+      await sleep(baseDelayMs + Math.random() * 250);
+    }
+  }
+};
+var DEFAULT_OPENID_METADATA_URL = "https://login.botframework.com/v1/.well-known/openidconfiguration";
+var BOTFRAMEWORK_ISSUER = "https://api.botframework.com";
+var DEFAULT_CLOCK_SKEW_MS = 3e5;
+var JWKS_CACHE_TTL_MS = 864e5;
+var JWKS_FORCED_REFETCH_MIN_INTERVAL_MS = 6e4;
+var jwksCache = /* @__PURE__ */ new Map();
+var lastForcedRefetch = /* @__PURE__ */ new Map();
+var fail = (reason) => ({ ok: false, reason });
+function decodeSegment(segment) {
+  const parsed = JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+  if (typeof parsed !== "object" || parsed === null) throw new Error("non-object JWT segment");
+  return parsed;
+}
+async function getSigningKey(metadataUrl, kid, fetchImpl, now) {
+  const cached = jwksCache.get(metadataUrl);
+  if (cached && cached.expiresAt > now()) {
+    const key = cached.keysByKid.get(kid);
+    if (key) return key;
+    const last = lastForcedRefetch.get(metadataUrl);
+    if (last !== void 0 && now() - last < JWKS_FORCED_REFETCH_MIN_INTERVAL_MS) return void 0;
+    lastForcedRefetch.set(metadataUrl, now());
+  }
+  const metadataRes = await fetchImpl(metadataUrl);
+  if (!metadataRes.ok) throw new Error(`OpenID metadata fetch failed: ${metadataRes.status}`);
+  const metadata = await metadataRes.json();
+  if (typeof metadata.jwks_uri !== "string") throw new Error("OpenID metadata has no jwks_uri");
+  const jwksRes = await fetchImpl(metadata.jwks_uri);
+  if (!jwksRes.ok) throw new Error(`JWKS fetch failed: ${jwksRes.status}`);
+  const jwks = await jwksRes.json();
+  const keysByKid = /* @__PURE__ */ new Map();
+  for (const jwk of jwks.keys ?? []) {
+    if (typeof jwk.kid !== "string" || jwk.kty !== "RSA") continue;
+    try {
+      const key = await crypto.subtle.importKey(
+        "jwk",
+        jwk,
+        { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+        false,
+        ["verify"]
+      );
+      keysByKid.set(jwk.kid, key);
+    } catch {
+    }
+  }
+  jwksCache.set(metadataUrl, { expiresAt: now() + JWKS_CACHE_TTL_MS, keysByKid });
+  return keysByKid.get(kid);
+}
+async function validateBotFrameworkJwt(authorizationHeader, activityServiceUrl, opts) {
+  const clockSkewMs = opts.clockSkewMs ?? DEFAULT_CLOCK_SKEW_MS;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const now = opts.now ?? Date.now;
+  const metadataUrl = opts.openIdMetadataUrl ?? DEFAULT_OPENID_METADATA_URL;
+  if (!authorizationHeader?.startsWith("Bearer ")) return fail("missing Bearer token");
+  const token = authorizationHeader.slice("Bearer ".length).trim();
+  const parts = token.split(".");
+  if (parts.length !== 3) return fail("malformed JWT (expected three segments)");
+  let header;
+  let payload;
+  try {
+    header = decodeSegment(parts[0]);
+    payload = decodeSegment(parts[1]);
+  } catch {
+    return fail("undecodable JWT header or payload");
+  }
+  if (header.alg !== "RS256") return fail(`unexpected alg "${String(header.alg)}"`);
+  if (payload.iss !== BOTFRAMEWORK_ISSUER) return fail(`wrong iss "${String(payload.iss)}"`);
+  const aud = payload.aud;
+  const audOk = Array.isArray(aud) ? aud.includes(opts.appId) : aud === opts.appId;
+  if (!audOk) return fail(`wrong aud "${String(aud)}"`);
+  if (typeof payload.exp !== "number") return fail("missing exp claim");
+  if (now() > payload.exp * 1e3 + clockSkewMs) return fail("token expired");
+  if (typeof payload.nbf === "number" && now() < payload.nbf * 1e3 - clockSkewMs) {
+    return fail("token not yet valid");
+  }
+  if (payload.serviceurl !== activityServiceUrl) {
+    return fail("serviceurl claim does not match the activity serviceUrl");
+  }
+  if (typeof header.kid !== "string") return fail("missing kid header");
+  let key;
+  try {
+    key = await getSigningKey(metadataUrl, header.kid, fetchImpl, now);
+  } catch (err) {
+    return fail(`signing key resolution failed: ${String(err)}`);
+  }
+  if (!key) return fail(`unknown signing key "${header.kid}"`);
+  const valid = await crypto.subtle.verify(
+    "RSASSA-PKCS1-v1_5",
+    key,
+    Buffer.from(parts[2], "base64url"),
+    new TextEncoder().encode(`${parts[0]}.${parts[1]}`)
+  );
+  return valid ? { ok: true } : fail("invalid signature");
+}
+
+// channels/adapters/msteams/index.ts
+var DEFAULT_INGRESS_PATH = "/channels/msteams/messages";
+var DEDUPE_TTL_MS = 6e5;
+var NULL_IDENTITY = { resolveActor: async () => null };
+var emptyOk = () => new Response(null, { status: 200 });
+var jsonOk = () => new Response("{}", { status: 200, headers: { "content-type": "application/json" } });
+var MsTeamsAdapter = class {
+  platform = "msteams";
+  capabilities = {
+    canEditMessages: true,
+    canDeleteMessages: true,
+    supportsThreads: true,
+    supportsCards: true,
+    supportsTyping: true,
+    supportsEphemeral: false,
+    supportsReactions: true,
+    maxMessageLength: 25e3,
+    ackDeadlineMs: 15e3,
+    editThrottleMs: 1e3,
+    textFormat: "adaptive-card"
+  };
+  opts;
+  ctx;
+  /** tenantId → lazily-created provider client (promise-cached to collapse races). */
+  clients = /* @__PURE__ */ new Map();
+  /** Ingress-observed conversation facts, keyed by conversationKey (thread AND channel level). */
+  conversations = /* @__PURE__ */ new Map();
+  /** Ingress-observed actors by externalId — the lookupActor roster. */
+  roster = /* @__PURE__ */ new Map();
+  /** post() idempotency: dedupeKey → prior ref, TTL {@link DEDUPE_TTL_MS}. */
+  posted = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** Registers the ingress route on the host; no connection is opened. */
+  async start(ctx) {
+    this.ctx = ctx;
+    ctx.ingress.registerHttpRoute?.(
+      this.opts.ingressPath ?? DEFAULT_INGRESS_PATH,
+      this.handleRequest
+    );
+  }
+  /** Drops the context and per-tenant clients; the host owns route teardown. */
+  async stop() {
+    this.ctx = void 0;
+    this.clients.clear();
+  }
+  /**
+   * The Bot Framework messaging endpoint. Guarded by a `Promise.race` at
+   * `ackDeadlineMs - 1000`: if processing overruns, Teams still gets its 200
+   * and at-least-once redelivery covers the rest.
+   */
+  handleRequest = async (req) => {
+    let timer;
+    const guard = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(jsonOk()), this.capabilities.ackDeadlineMs - 1e3);
+    });
+    try {
+      return await Promise.race([this.processRequest(req), guard]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  async processRequest(req) {
+    const ctx = this.ctx;
+    if (!ctx) return new Response("adapter not started", { status: 503 });
+    let activity;
+    try {
+      activity = await req.json();
+    } catch {
+      return new Response("invalid JSON body", { status: 400 });
+    }
+    if (typeof activity?.type !== "string" || typeof activity?.serviceUrl !== "string") {
+      return new Response("not a Bot Framework activity", { status: 400 });
+    }
+    const verdict = await validateBotFrameworkJwt(
+      req.headers.get("authorization") ?? void 0,
+      activity.serviceUrl,
+      {
+        appId: this.opts.appId,
+        openIdMetadataUrl: this.opts.openIdMetadataUrl,
+        fetchImpl: this.opts.fetchImpl
+      }
+    );
+    if (!verdict.ok) return new Response(verdict.reason, { status: 401 });
+    this.rememberConversation(activity);
+    this.rememberActors(activity);
+    if (activity.from?.id === activity.recipient?.id) return emptyOk();
+    if (activity.type === "messageReaction") {
+      await this.forwardReactions(activity, ctx);
+      return emptyOk();
+    }
+    if (activity.type !== "message") return emptyOk();
+    const msg = await activityToChannelMessage(activity, NULL_IDENTITY);
+    if (!msg) return emptyOk();
+    await ctx.sink.onMessage(msg);
+    return jsonOk();
+  }
+  /** Records serviceUrl + tenant under the thread key AND its channel-level key. */
+  rememberConversation(a) {
+    const key = conversationKeyFromActivity(a);
+    const info = { serviceUrl: a.serviceUrl, tenantId: tenantIdOfActivity(a) };
+    this.conversations.set(key, info);
+    const { conversationId } = parseConversationKey(key);
+    this.conversations.set(makeConversationKey("msteams", conversationId), info);
+  }
+  /** Grows the lookupActor roster from the sender and mention entities (bot excluded). */
+  rememberActors(a) {
+    if (a.from?.id !== a.recipient?.id) {
+      const actor = actorOfActivity(a);
+      if (actor.externalId) this.roster.set(actor.externalId, actor);
+    }
+    for (const e of a.entities ?? []) {
+      if (e.type !== "mention" || !e.mentioned || e.mentioned.id === a.recipient?.id) continue;
+      this.roster.set(e.mentioned.id, {
+        platform: "msteams",
+        externalId: e.mentioned.id,
+        displayName: e.mentioned.name ?? "",
+        tenantId: tenantIdOfActivity(a)
+      });
+    }
+  }
+  /** Maps a messageReaction activity onto InboundReaction events (one per emoji). */
+  async forwardReactions(a, ctx) {
+    if (!ctx.sink.onReaction) return;
+    const conversationKey = conversationKeyFromActivity(a);
+    const actor = actorOfActivity(a);
+    const messageRef = {
+      platform: "msteams",
+      conversationKey,
+      // Teams points a reaction at its target via replyToId.
+      messageId: a.replyToId ?? a.id,
+      raw: { serviceUrl: a.serviceUrl, conversationId: a.conversation.id }
+    };
+    const groups = [
+      ["added", a.reactionsAdded ?? []],
+      ["removed", a.reactionsRemoved ?? []]
+    ];
+    for (const [action, reactions] of groups) {
+      for (const reaction of reactions) {
+        await ctx.sink.onReaction({
+          conversationKey,
+          messageRef,
+          emoji: reaction.type,
+          actor,
+          action,
+          eventId: `${a.id}:${action}:${reaction.type}`
+        });
+      }
+    }
+  }
+  /** Posts a message; a repeated `dedupeKey` returns the prior ref with no second side effect. */
+  async post(target, msg, dedupeKey) {
+    const prior = this.dedupeGet(dedupeKey);
+    if (prior) return prior;
+    if (msg.markdown.length > this.capabilities.maxMessageLength) {
+      throw new Error(
+        `message length ${msg.markdown.length} exceeds maxMessageLength ${this.capabilities.maxMessageLength} \u2014 chunk upstream`
+      );
+    }
+    const { serviceUrl, conversationId } = this.resolveTarget(target);
+    const client = await this.clientForConversation(target.conversationKey);
+    const { id } = await client.postActivity(serviceUrl, conversationId, this.buildActivity(msg));
+    const ref = {
+      platform: "msteams",
+      conversationKey: target.conversationKey,
+      messageId: id,
+      raw: { serviceUrl, conversationId }
+    };
+    this.posted.set(dedupeKey, { ref, expiresAt: Date.now() + DEDUPE_TTL_MS });
+    return ref;
+  }
+  /** Replaces a previously posted activity's content in place. */
+  async update(ref, msg) {
+    const raw = ref.raw ?? {};
+    const fallback = typeof raw.serviceUrl === "string" && typeof raw.conversationId === "string" ? { serviceUrl: raw.serviceUrl, conversationId: raw.conversationId } : this.resolveTarget({ conversationKey: ref.conversationKey });
+    const client = await this.clientForConversation(ref.conversationKey);
+    await client.updateActivity(
+      fallback.serviceUrl,
+      fallback.conversationId,
+      ref.messageId,
+      this.buildActivity(msg)
+    );
+  }
+  /** Native Teams typing indicator — fire-and-forget, never deduped. */
+  async indicateTyping(target) {
+    const { serviceUrl, conversationId } = this.resolveTarget(target);
+    const client = await this.clientForConversation(target.conversationKey);
+    await client.postActivity(serviceUrl, conversationId, { type: "typing" });
+  }
+  /** Preflight: a typing probe proves the bot can post; 403/404 → actionable problem. */
+  async verifyConversation(key) {
+    try {
+      const { serviceUrl, conversationId } = this.resolveTarget({ conversationKey: key });
+      const client = await this.clientForConversation(key);
+      await client.postActivity(serviceUrl, conversationId, { type: "typing" });
+      return { ok: true, problems: [] };
+    } catch (err) {
+      if (err instanceof MsTeamsApiError && (err.status === 403 || err.status === 404)) {
+        return {
+          ok: false,
+          problems: [
+            `bot cannot post to ${key} \u2014 check the app is installed in the team and the bot has access`
+          ]
+        };
+      }
+      return { ok: false, problems: [err instanceof Error ? err.message : String(err)] };
+    }
+  }
+  /** Resolves from the ingress-observed roster only (Graph lookup is platform glue, later). */
+  async lookupActor(query) {
+    if (query.externalId) return this.roster.get(query.externalId);
+    for (const actor of this.roster.values()) {
+      if (query.email && actor.email === query.email) return actor;
+      if (query.name && actor.displayName.toLowerCase().includes(query.name.toLowerCase())) {
+        return actor;
+      }
+    }
+    return void 0;
+  }
+  /** Decision 11: Adaptive Card for questions with options; markdown text otherwise. */
+  buildActivity(msg) {
+    if (msg.kind === "question" && msg.options?.length) {
+      return {
+        type: "message",
+        attachments: [
+          {
+            contentType: "application/vnd.microsoft.card.adaptive",
+            content: makeQuestionCard(markdownToTeamsText(msg.markdown), msg.options)
+          }
+        ]
+      };
+    }
+    const text = markdownToTeamsText(msg.markdown);
+    return {
+      type: "message",
+      textFormat: "markdown",
+      text: msg.kind === "error" ? `\u26A0\uFE0F ${text}` : text
+    };
+  }
+  /** serviceUrl + native conversation id for a target — threadRef.raw first, ingress memory else. */
+  resolveTarget(target) {
+    const raw = target.threadRef?.raw ?? {};
+    if (typeof raw.serviceUrl === "string" && typeof raw.conversationId === "string") {
+      return { serviceUrl: raw.serviceUrl, conversationId: raw.conversationId };
+    }
+    const { conversationId, threadRootId } = parseConversationKey(target.conversationKey);
+    const nativeId = threadRootId ? `${conversationId};messageid=${threadRootId}` : conversationId;
+    const info = this.infoFor(target.conversationKey);
+    if (!info) {
+      throw new Error(
+        `no known serviceUrl for ${target.conversationKey} \u2014 the conversation has not been seen on ingress`
+      );
+    }
+    return { serviceUrl: info.serviceUrl, conversationId: nativeId };
+  }
+  /** Conversation facts under the exact key, falling back to its channel-level key. */
+  infoFor(key) {
+    const exact = this.conversations.get(key);
+    if (exact) return exact;
+    const { conversationId } = parseConversationKey(key);
+    return this.conversations.get(makeConversationKey("msteams", conversationId));
+  }
+  /** One MsTeamsClient per tenant, built from CredentialPort (kind must be "msteams"). */
+  clientForConversation(key) {
+    const ctx = this.ctx;
+    if (!ctx) return Promise.reject(new Error("adapter not started"));
+    const tenantId = this.infoFor(key)?.tenantId;
+    if (!tenantId) {
+      return Promise.reject(
+        new Error(`no known tenant for ${key} \u2014 the conversation has not been seen on ingress`)
+      );
+    }
+    return this.clientForTenant(tenantId, ctx.credentials);
+  }
+  clientForTenant(tenantId, credentials) {
+    const cached = this.clients.get(tenantId);
+    if (cached) return cached;
+    const created = (async () => {
+      const cred = await credentials.forTenant("msteams", tenantId);
+      if (cred.kind !== "msteams") {
+        throw new Error(
+          `expected "msteams" credentials for tenant ${tenantId}, got "${cred.kind}"`
+        );
+      }
+      return new MsTeamsClient({
+        appId: cred.appId,
+        clientSecret: cred.clientSecret,
+        loginBaseUrl: this.opts.loginBaseUrl,
+        fetchImpl: this.opts.fetchImpl
+      });
+    })();
+    this.clients.set(tenantId, created);
+    created.catch(() => this.clients.delete(tenantId));
+    return created;
+  }
+  /** Live dedupe hit for `key`, sweeping expired entries opportunistically. */
+  dedupeGet(key) {
+    const now = Date.now();
+    for (const [k, entry] of this.posted) {
+      if (entry.expiresAt <= now) this.posted.delete(k);
+    }
+    return this.posted.get(key)?.ref;
+  }
+};
+
+export { MsTeamsAdapter, MsTeamsApiError, MsTeamsClient, activityToChannelMessage, actorOfActivity, conversationKeyFromActivity, tenantIdOfActivity, validateBotFrameworkJwt };
+//# sourceMappingURL=msteams.js.map
+//# sourceMappingURL=msteams.js.map