@sentry/junior 0.174.0 → 0.176.0

package/dist/{chunk-BLBKORDG.js → chunk-JIZ3RFER.js}

@@ -1,8 +1,11 @@
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-JVORBSUR.js";
+} from "./chunk-JHCAX7XY.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
@@ -11,23 +14,23 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-VZFLAGFK.js";
+} from "./chunk-CUA5SZR5.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   hash,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-XOXKL2DL.js";
+} from "./chunk-CNC65LIX.js";
 import {
   getStateAdapter
-} from "./chunk-HJFWO72I.js";
+} from "./chunk-B6IOTX7W.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-OXYAEFKS.js";
+} from "./chunk-Z2YZ6QLG.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -43,7 +46,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-Z23POK2V.js";
+} from "./chunk-SBIQ5MZW.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -893,6 +896,447 @@ function createResourceEventTeamIdResolver() {
   };
 }
 
+// src/chat/resource-events/store.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  destinationSchema,
+  resourceEventTypeSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v3";
+var INDEX_LOCK_TTL_MS = 1e4;
+var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
+var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
+var SUBSCRIPTION_LOCK_RETRY_MS = 25;
+var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
+var subscriptionStatusSchema = z2.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z2.array(z2.string().min(1));
+var subscriptionSchema = z2.object({
+  conversationId: z2.string().min(1),
+  createdAtMs: z2.number().finite(),
+  destination: destinationSchema,
+  events: z2.array(resourceEventTypeSchema).min(1),
+  expiresAtMs: z2.number().finite(),
+  id: z2.string().min(1),
+  intent: z2.string().min(1),
+  label: z2.string().min(1),
+  namespace: z2.string().min(1),
+  identifier: z2.string().min(1),
+  resourceType: z2.string().min(1),
+  status: subscriptionStatusSchema,
+  updatedAtMs: z2.number().finite()
+}).strict();
+function digest(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 32);
+}
+function subscriptionKey(id) {
+  return `${RESOURCE_EVENT_PREFIX}:record:${id}`;
+}
+function subscriptionLockKey(id) {
+  return `${RESOURCE_EVENT_PREFIX}:lock:${id}`;
+}
+function resourceIndexKey(teamId, namespace, identifier) {
+  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${teamId}\0${namespace}\0${identifier}`)}`;
+}
+function subscriptionTeamId(destination) {
+  if (destination.platform !== "slack") {
+    throw new Error("Resource event subscriptions require a Slack destination");
+  }
+  return destination.teamId;
+}
+function conversationIndexKey(conversationId) {
+  return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
+}
+function indexLockKey(key) {
+  return `${key}:lock`;
+}
+async function sleep2(ms) {
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+async function acquireSubscriptionLock(state, subscriptionId, waitDeadlineMs = Date.now() + SUBSCRIPTION_LOCK_WAIT_MS) {
+  while (true) {
+    const lock = await state.acquireLock(
+      subscriptionLockKey(subscriptionId),
+      SUBSCRIPTION_LOCK_TTL_MS
+    );
+    if (lock) {
+      return lock;
+    }
+    if (Date.now() >= waitDeadlineMs) {
+      throw new Error(
+        `Could not acquire resource event subscription lock for ${subscriptionId}`
+      );
+    }
+    await sleep2(SUBSCRIPTION_LOCK_RETRY_MS);
+  }
+}
+async function withSubscriptionLock(state, subscriptionId, callback, waitDeadlineMs) {
+  const lock = await acquireSubscriptionLock(
+    state,
+    subscriptionId,
+    waitDeadlineMs
+  );
+  let lockLostError;
+  let heartbeatError;
+  let heartbeat;
+  const timer = setInterval(() => {
+    if (heartbeat) {
+      return;
+    }
+    heartbeat = state.extendLock(lock, SUBSCRIPTION_LOCK_TTL_MS).then((extended) => {
+      if (extended) {
+        heartbeatError = void 0;
+      } else {
+        lockLostError = new Error(
+          `Resource event subscription lock was lost for ${subscriptionId}`
+        );
+      }
+    }).catch((error) => {
+      heartbeatError = error instanceof Error ? error : new Error(`Failed to extend subscription lock: ${String(error)}`);
+    }).finally(() => {
+      heartbeat = void 0;
+    });
+  }, SUBSCRIPTION_LOCK_HEARTBEAT_MS);
+  timer.unref?.();
+  let result;
+  try {
+    result = await callback();
+  } finally {
+    clearInterval(timer);
+    await heartbeat;
+    await state.releaseLock(lock);
+  }
+  const lockError = lockLostError ?? heartbeatError;
+  if (lockError) {
+    throw lockError;
+  }
+  return result;
+}
+function ttlUntil(expiresAtMs, nowMs) {
+  return Math.max(1, expiresAtMs - nowMs);
+}
+async function readSubscriptionIdIndex(state, key) {
+  const value = await state.get(key);
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return subscriptionIdIndexSchema.parse(value);
+}
+function buildSubscriptionId(input) {
+  const eventKey = [...new Set(input.events)].sort().join("\0");
+  return `resub_${digest(
+    `${input.teamId}\0${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}`
+  )}`;
+}
+async function withIndexLock(state, key, callback) {
+  const lock = await state.acquireLock(indexLockKey(key), INDEX_LOCK_TTL_MS);
+  if (!lock) {
+    throw new Error(`Could not acquire resource event index lock for ${key}`);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function addToIndex(state, key, subscriptionId, nowMs) {
+  await withIndexLock(state, key, async () => {
+    const ids = [...new Set(await readSubscriptionIdIndex(state, key))];
+    const next = ids.includes(subscriptionId) ? ids : [...ids, subscriptionId];
+    await state.set(key, next, await indexTtlMs(state, next, nowMs));
+  });
+}
+async function removeFromIndex(state, key, subscriptionId, nowMs) {
+  await withIndexLock(state, key, async () => {
+    const existing = await readSubscriptionIdIndex(state, key);
+    const next = existing.filter((id) => id !== subscriptionId);
+    await state.set(key, next, await indexTtlMs(state, next, nowMs));
+  });
+}
+async function indexTtlMs(state, subscriptionIds, nowMs) {
+  const records = await Promise.all(
+    subscriptionIds.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  const latestExpiresAtMs = Math.max(
+    nowMs,
+    ...records.filter(
+      (record) => record !== void 0 && activeAt(record, nowMs)
+    ).map((record) => record.expiresAtMs)
+  );
+  return ttlUntil(latestExpiresAtMs, nowMs);
+}
+function parseSubscription(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return subscriptionSchema.parse(value);
+}
+function activeAt(subscription, nowMs) {
+  return subscription.status === "active" && subscription.expiresAtMs > nowMs;
+}
+function matchesEvent(subscription, input) {
+  return subscription.namespace === input.namespace && subscription.identifier === input.identifier && subscriptionTeamId(subscription.destination) === input.teamId && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs);
+}
+async function createResourceEventSubscription(input, options = {}) {
+  const state = options.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = options.nowMs ?? Date.now();
+  const events = [...new Set(input.events.map((event) => event.trim()))].filter(
+    Boolean
+  );
+  if (events.length === 0) {
+    throw new Error("Resource event subscription requires at least one event");
+  }
+  if (input.expiresAtMs <= nowMs) {
+    throw new Error("Resource event subscription expiry must be in the future");
+  }
+  const id = buildSubscriptionId({
+    conversationId: input.conversationId,
+    events,
+    namespace: input.namespace,
+    identifier: input.identifier,
+    teamId: subscriptionTeamId(input.destination)
+  });
+  const record = {
+    conversationId: input.conversationId,
+    createdAtMs: nowMs,
+    destination: input.destination,
+    events,
+    expiresAtMs: input.expiresAtMs,
+    id,
+    intent: input.intent,
+    label: input.label,
+    namespace: input.namespace,
+    identifier: input.identifier,
+    resourceType: input.resourceType,
+    status: "active",
+    updatedAtMs: nowMs
+  };
+  const parsed = subscriptionSchema.parse(record);
+  await state.set(
+    subscriptionKey(id),
+    parsed,
+    ttlUntil(parsed.expiresAtMs, nowMs)
+  );
+  await addToIndex(
+    state,
+    resourceIndexKey(
+      subscriptionTeamId(parsed.destination),
+      input.namespace,
+      input.identifier
+    ),
+    id,
+    nowMs
+  );
+  await addToIndex(
+    state,
+    conversationIndexKey(input.conversationId),
+    id,
+    nowMs
+  );
+  return parsed;
+}
+async function listResourceEventSubscriptions(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = input.nowMs ?? Date.now();
+  const ids = await readSubscriptionIdIndex(
+    state,
+    conversationIndexKey(input.conversationId)
+  );
+  const records = await Promise.all(
+    ids.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  return records.filter(
+    (record) => record !== void 0 && record.conversationId === input.conversationId && activeAt(record, nowMs)
+  ).sort((left, right) => left.createdAtMs - right.createdAtMs);
+}
+async function cancelResourceEventSubscription(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  return await withSubscriptionLock(state, input.id, async () => {
+    const current = parseSubscription(
+      await state.get(subscriptionKey(input.id))
+    );
+    if (!current || current.conversationId !== input.conversationId) {
+      return void 0;
+    }
+    const nowMs = input.nowMs ?? Date.now();
+    const next = {
+      ...current,
+      status: "cancelled",
+      updatedAtMs: nowMs
+    };
+    await state.set(
+      subscriptionKey(input.id),
+      next,
+      JUNIOR_THREAD_STATE_TTL_MS
+    );
+    await removeFromIndex(
+      state,
+      resourceIndexKey(
+        subscriptionTeamId(current.destination),
+        current.namespace,
+        current.identifier
+      ),
+      input.id,
+      nowMs
+    );
+    await removeFromIndex(
+      state,
+      conversationIndexKey(current.conversationId),
+      input.id,
+      nowMs
+    );
+    return next;
+  });
+}
+async function cancelSubscriptions(input) {
+  const subscriptions = await listResourceEventSubscriptions(input);
+  for (const subscription of subscriptions) {
+    await cancelResourceEventSubscription({
+      conversationId: input.conversationId,
+      id: subscription.id,
+      nowMs: input.nowMs,
+      state: input.state
+    });
+  }
+}
+async function findMatchingResourceEventSubscriptions(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = input.nowMs ?? Date.now();
+  const ids = await readSubscriptionIdIndex(
+    state,
+    resourceIndexKey(input.teamId, input.namespace, input.identifier)
+  );
+  const records = await Promise.all(
+    ids.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  return records.filter(
+    (record) => record !== void 0 && matchesEvent(record, {
+      eventType: input.eventType,
+      nowMs,
+      namespace: input.namespace,
+      identifier: input.identifier,
+      teamId: input.teamId
+    })
+  );
+}
+async function deliverResourceEventSubscription(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  return await withSubscriptionLock(
+    state,
+    input.subscription.id,
+    async () => {
+      const nowMs = input.nowMs ?? Date.now();
+      const current = parseSubscription(
+        await state.get(subscriptionKey(input.subscription.id))
+      );
+      if (!current || !matchesEvent(current, {
+        eventType: input.eventType,
+        nowMs,
+        namespace: input.namespace,
+        identifier: input.identifier,
+        teamId: input.teamId
+      })) {
+        return false;
+      }
+      const delivered = await input.deliver(current);
+      if (input.terminal) {
+        const latest = parseSubscription(
+          await state.get(subscriptionKey(current.id))
+        );
+        if (!latest || latest.status !== current.status || latest.updatedAtMs !== current.updatedAtMs) {
+          return delivered;
+        }
+        const next = {
+          ...current,
+          status: "completed",
+          updatedAtMs: nowMs
+        };
+        await state.set(
+          subscriptionKey(current.id),
+          next,
+          JUNIOR_THREAD_STATE_TTL_MS
+        );
+        await removeFromIndex(
+          state,
+          resourceIndexKey(
+            subscriptionTeamId(current.destination),
+            current.namespace,
+            current.identifier
+          ),
+          current.id,
+          nowMs
+        );
+        await removeFromIndex(
+          state,
+          conversationIndexKey(current.conversationId),
+          current.id,
+          nowMs
+        );
+      }
+      return delivered;
+    },
+    input.waitDeadlineMs
+  );
+}
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+// src/chat/resource-events/tool-support.ts
+var RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var RESOURCE_SUBSCRIPTION_MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
+var RESOURCE_WATCH_TOOL_SOURCE = {
+  id: "resource-watches",
+  description: "Inspect or stop resource watches for the current conversation."
+};
+function requireResourceWatchConversation(context) {
+  if (!context.conversationId) {
+    throw new ToolInputError(
+      "Resource event subscriptions require a conversation"
+    );
+  }
+  if (context.destination.platform !== "slack") {
+    throw new ToolInputError(
+      "Resource event subscriptions currently require Slack delivery"
+    );
+  }
+  if (!isSlackThreadConversationId(context.conversationId)) {
+    throw new ToolInputError(
+      "Resource event subscriptions require a Slack thread conversation"
+    );
+  }
+  return context.conversationId;
+}
+function canUseResourceEventSubscriptionTools(context) {
+  return context.destination.platform === "slack" && Boolean(
+    context.conversationId && isSlackThreadConversationId(context.conversationId)
+  );
+}
+function isSlackThreadConversationId(conversationId) {
+  const parts = conversationId.split(":");
+  return parts.length === 3 && parts[0] === "slack" && Boolean(parts[1]) && Boolean(parts[2]);
+}
+
 // src/chat/slack/tool-support/context.ts
 function getSlackToolContext(context) {
   if (context.source.platform !== "slack") {
@@ -1029,8 +1473,8 @@ function buildPayload(parts) {
   return [CREDENTIAL_SUBJECT_HMAC_CONTEXT, ...parts].join("\0");
 }
 function signPayload(secret, payload) {
-  const digest = createHmac("sha256", secret).update(payload).digest("hex");
-  return `${CREDENTIAL_SUBJECT_SIGNATURE_VERSION}=${digest}`;
+  const digest2 = createHmac("sha256", secret).update(payload).digest("hex");
+  return `${CREDENTIAL_SUBJECT_SIGNATURE_VERSION}=${digest2}`;
 }
 function timingSafeMatch(expected, actual) {
   const expectedBuffer = Buffer.from(expected);
@@ -1201,7 +1645,7 @@ function resolveChannelCapabilities(channelId) {
 }
 
 // src/chat/plugins/agent-hooks.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/chat/workspaces/checkout-path.ts
 function tryWorkspaceRepoCheckoutPath(repo) {
@@ -1655,7 +2099,7 @@ var PLUGIN_ROUTE_METHODS = /* @__PURE__ */ new Set([
 var PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS = 16e3;
 var PLUGIN_PROMPT_CONTEXT_MAX_BYTES = 8e3;
 var PLUGIN_PROMPT_CONTEXT_TOTAL_MAX_BYTES = 16e3;
-var systemPromptMessageArraySchema = z2.array(promptMessageSchema);
+var systemPromptMessageArraySchema = z3.array(promptMessageSchema);
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -2033,8 +2477,45 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
       plugin: pluginName
     }) : void 0;
     const mcp = pluginMcpContext(plugin, context);
+    const canSubscribe = context.source.platform === "slack" && context.destination.platform === "slack" && Boolean(context.conversationId) && canRouteResourceEvents() && Boolean(plugin.resourceEvents) && plugin.resourceEvents?.isEnabled?.() !== false;
     const resourceEvents = {
-      canSubscribe: context.source.platform === "slack" && canRouteResourceEvents()
+      canSubscribe,
+      async subscribe(input) {
+        if (!canSubscribe || context.destination.platform !== "slack") {
+          throw new Error(
+            "Resource subscriptions are not available in this conversation."
+          );
+        }
+        const registration = plugin.resourceEvents;
+        const resourceType = registration?.resourceTypes.find(
+          (candidate) => candidate.type === input.resource.type
+        );
+        if (input.resource.namespace !== pluginName || !resourceType || input.events.length === 0 || input.events.some(
+          (eventType) => !resourceType.supportedEvents.includes(eventType)
+        )) {
+          throw new Error(
+            "Resource subscription contains an event or resource that the plugin does not support."
+          );
+        }
+        const subscription = await createResourceEventSubscription({
+          conversationId: context.conversationId,
+          destination: context.destination,
+          events: input.events,
+          expiresAtMs: Date.now() + RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
+          intent: input.intent,
+          label: input.resource.label,
+          namespace: pluginName,
+          identifier: normalizeResourceEventIdentifier(
+            registration,
+            input.resource.identifier
+          ),
+          resourceType: input.resource.type
+        });
+        return {
+          events: subscription.events,
+          id: subscription.id
+        };
+      }
     };
     const resolveActor = context.resolveActorIdentity ?? (async () => void 0);
     const common = {
@@ -2808,6 +3289,7 @@ function createPluginHookRunner(input = {}) {
 }
 
 export {
+  ToolInputError,
   listConversationAnnotations,
   listConversationAnnotationsById,
   createPluginConversationEvents,
@@ -2833,6 +3315,18 @@ export {
   downloadPrivateSlackFile,
   canRouteResourceEvents,
   createResourceEventTeamIdResolver,
+  createResourceEventSubscription,
+  listResourceEventSubscriptions,
+  cancelResourceEventSubscription,
+  cancelSubscriptions,
+  findMatchingResourceEventSubscriptions,
+  deliverResourceEventSubscription,
+  RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
+  RESOURCE_SUBSCRIPTION_MAX_TTL_MS,
+  STOP_WATCHING_TOOL_NAME,
+  RESOURCE_WATCH_TOOL_SOURCE,
+  requireResourceWatchConversation,
+  canUseResourceEventSubscriptionTools,
   getSlackToolContext,
   resolveViewerUser,
   findUserByEmail,

package/dist/{chunk-DRRUFZKZ.js → chunk-KYHHJ6LS.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-2E353AHN.js";
+} from "./chunk-DVHYQDGM.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-N7Y3T47I.js → chunk-OKXHYVKE.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-JVORBSUR.js";
+} from "./chunk-JHCAX7XY.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-HJFWO72I.js";
+} from "./chunk-B6IOTX7W.js";
 import {
   getChatConfig
-} from "./chunk-OXYAEFKS.js";
+} from "./chunk-Z2YZ6QLG.js";
 import {
   parseStoredSlackActor
 } from "./chunk-M63DETLL.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-Z23POK2V.js";
+} from "./chunk-SBIQ5MZW.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-REUKFWLH.js → chunk-PS3ZPRL2.js}

@@ -1,7 +1,7 @@
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig
-} from "./chunk-OXYAEFKS.js";
+} from "./chunk-Z2YZ6QLG.js";
 
 // src/chat/runtime/request-deadline.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-7V25DLCB.js → chunk-Q374NKGS.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-RF6J3DIO.js";
 import {
   resolveBaseUrl
-} from "./chunk-DIW6IQYK.js";
+} from "./chunk-665JOQEP.js";
 import {
   isExperimentalFeatureEnabled
 } from "./chunk-VRS6WDK5.js";
@@ -12,27 +12,27 @@ import {
   getPlugins,
   getSlackClient,
   withSlackRetries
-} from "./chunk-BLBKORDG.js";
+} from "./chunk-JIZ3RFER.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-JVORBSUR.js";
+} from "./chunk-JHCAX7XY.js";
 import {
   sleep
-} from "./chunk-XOXKL2DL.js";
+} from "./chunk-CNC65LIX.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-HJFWO72I.js";
+} from "./chunk-B6IOTX7W.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-RL23S5DG.js";
+} from "./chunk-5JB5JJO5.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-IYI7RPHU.js";
+} from "./chunk-CI4JX64I.js";
 import {
   isRecord
-} from "./chunk-Z23POK2V.js";
+} from "./chunk-SBIQ5MZW.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {