@opengeni/api-router 3.0.1 → 3.1.2

package/src/index.ts

@@ -16,6 +16,7 @@ import type {
 } from "@opengeni/contracts";
 import {
   assertRuntimeDatabasePosture,
+  isRetryableRuntimeDatabaseStartupError,
   createDb,
   markSessionWorkflowWakeDelivered,
   runtimeDatabaseReadyCheck,
@@ -28,11 +29,12 @@ import {
   type Observability,
 } from "@opengeni/observability";
 import { createObjectStorage } from "@opengeni/storage";
-import { createNativeRemoteMcpCredentialsPort } from "@opengeni/core/remote-mcp-credentials";
 import { isArtifactRuntimeConfigured } from "@opengeni/artifact-tool/runtime/development";
 import {
   resolveCatalogSettings,
-  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID,
+  SESSION_WORKFLOW_WAKE_DISPATCH_REQUESTED_SIGNAL,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_ID,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE,
 } from "@opengeni/core";
 import {
   Connection,
@@ -43,20 +45,29 @@ import {
 } from "@temporalio/client";
 import type { ScheduleOptions, ScheduleSpec, ScheduleUpdateOptions } from "@temporalio/client";
 import { createAppComposition, type DocumentIndexClient, type SessionWorkflowClient } from "./app";
-import { observabilityEventLogger } from "./observability";
+import { observabilityEventBusOptions } from "./observability";
 import { startAuthCalloutResponder } from "./sandbox/auth-callout";
 import { startHelloIngestion, startMetricsIngestion } from "./sandbox/metrics-ingestion";
+import { createAutomaticAgentUpdater } from "./sandbox/agent-update";
 import { startSlackInteractionPump } from "./integrations/slack-interactions";
 import { startMemorySlackPublicationPump } from "./memory-slack-delivery";
 import { startTemporalScheduleCleanupPump } from "./temporal-schedule-cleanup";
+import { startScheduledTaskLifecyclePump } from "./scheduled-task-lifecycle";
+import { createTemporalScheduleSynchronizer } from "./temporal-schedule-sync";
+import { startNativePushDispatchPump } from "./native-push-dispatch";
+import { startWorkspaceWebhookDispatchPump } from "./workspace-webhook-dispatch";
 import { cleanupScheduledTaskConnectorAuthorization } from "./scheduled-task-deletion";
 import {
   EDITABLE_ARTIFACT_LIVE_WEBSOCKET_MAX_MESSAGE_BYTES,
   EditableArtifactWebSocketTransport,
 } from "./editable-artifact-websocket";
+import { editableArtifactSourceSessionAuthorizer } from "./editable-artifact-source-session";
 import type { ApiWebSocketConnection } from "./api-websocket";
 import { InteractionFrameProxyTransport } from "./interaction-frame-proxy";
 import { apiRequestBindingsForTransportPeer } from "./http/request-source";
+import { startApiMetricsListener } from "./http/metrics-listener";
+import { createLocalBrowserBoundary } from "./http/local-browser-boundary";
+import { dispatchApiWebSocketUpgrade } from "./http/websocket-upgrade-dispatch";
 import {
   createStandaloneEditableArtifactApplication,
   type StandaloneEditableArtifactApplication,
@@ -101,6 +112,28 @@ export async function createTemporalWorkflowClient(
     connection,
     namespace: settings.temporalNamespace,
   });
+  const scheduledTasks = createTemporalScheduleSynchronizer({
+    db,
+    withDeadline: (deadline, work) => temporal.withDeadline(deadline, work),
+    upsert: async (task) => {
+      const options = temporalScheduleOptions(task, settings.temporalTaskQueue);
+      try {
+        await temporal.schedule
+          .getHandle(task.temporalScheduleId)
+          .update(() => temporalScheduleUpdateOptions(options));
+      } catch (error) {
+        if (!shouldCreateScheduleAfterUpdateError(error)) throw error;
+        await temporal.schedule.create(options);
+      }
+    },
+    remove: async (temporalScheduleId) => {
+      try {
+        await temporal.schedule.getHandle(temporalScheduleId).delete();
+      } catch (error) {
+        if (!(error instanceof ScheduleNotFoundError)) throw error;
+      }
+    },
+  });
   const client: SessionWorkflowClient = {
     triggerAutomationRun: async ({ accountId, workspaceId, runId }) => {
       try {
@@ -144,9 +177,13 @@ export async function createTemporalWorkflowClient(
       });
     },
     requestSessionWorkflowWakeDispatch: async () => {
-      await temporal.schedule
-        .getHandle(SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID)
-        .trigger(ScheduleOverlapPolicy.BUFFER_ONE);
+      await temporal.workflow.signalWithStart(SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE, {
+        taskQueue: settings.temporalTaskQueue,
+        workflowId: SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_ID,
+        workflowIdReusePolicy: "ALLOW_DUPLICATE",
+        args: [],
+        signal: SESSION_WORKFLOW_WAKE_DISPATCH_REQUESTED_SIGNAL,
+      });
     },
     signalCodexCapacity: async ({
       accountId,
@@ -196,41 +233,15 @@ export async function createTemporalWorkflowClient(
         wakeRevision: workflowWakeRevision,
       });
     },
-    syncScheduledTask: async ({ task }) => {
-      const schedule = temporal.schedule.getHandle(task.temporalScheduleId);
-      if (task.schedule.type === "manual") {
-        try {
-          await schedule.delete();
-        } catch (error) {
-          if (!(error instanceof ScheduleNotFoundError)) throw error;
-        }
-        return;
-      }
-      const options = temporalScheduleOptions(task, settings.temporalTaskQueue);
-      try {
-        await schedule.update(() => temporalScheduleUpdateOptions(options));
-      } catch (error) {
-        if (!shouldCreateScheduleAfterUpdateError(error)) {
-          throw error;
-        }
-        await temporal.schedule.create(options);
-      }
-    },
-    deleteScheduledTaskSchedule: async ({ temporalScheduleId }) => {
-      try {
-        await temporal.withDeadline(Date.now() + 5_000, async () => {
-          await temporal.schedule.getHandle(temporalScheduleId).delete();
-        });
-      } catch (error) {
-        if (error instanceof ScheduleNotFoundError) return;
-        throw error;
-      }
-    },
+    syncScheduledTask: async ({ task, onFailure }) => scheduledTasks.sync(task, onFailure),
+    deleteScheduledTaskSchedule: async ({ temporalScheduleId }) =>
+      scheduledTasks.remove(temporalScheduleId),
     triggerScheduledTask: async ({
       task,
       agentRunUsageIdempotencyKey,
       triggerWorkflowId,
       initiator,
+      credentialRestriction,
       triggerType = "manual",
     }) => {
       // Deterministic workflowId (derived from the trigger token by the
@@ -251,6 +262,7 @@ export async function createTemporalWorkflowClient(
               triggerType,
               agentRunUsageIdempotencyKey,
               initiator,
+              ...(credentialRestriction ? { credentialRestriction } : {}),
             },
           ],
         });
@@ -266,7 +278,7 @@ export async function createTemporalWorkflowClient(
     startRigVerification: async ({ workspaceId, changeId, versionId, workflowId }) => {
       const targetId = changeId ?? versionId;
       if (!targetId) {
-        throw new Error("rig verification requires changeId or versionId");
+        throw new Error("sandbox environment verification requires changeId or versionId");
       }
       try {
         await temporal.workflow.start("rigVerificationWorkflow", {
@@ -326,7 +338,7 @@ export async function startApi(
   // strategy.
   const searchPath = dbSearchPath(settings);
   const dbClient = createDb(settings.databaseUrl, {
-    max: 32,
+    max: settings.apiDatabasePoolMax,
     ...(searchPath ? { searchPath } : {}),
     rlsStrategy: settings.rlsStrategy,
   });
@@ -339,8 +351,6 @@ export async function startApi(
     rlsStrategy: settings.rlsStrategy,
     expectedRole: settings.runtimeDatabaseRole,
     targetSchema: settings.dbSchema.trim() || "public",
-    organizationTenancyCanonicalActivationEnabled:
-      settings.organizationTenancyCanonicalActivationEnabled,
   } as const;
   // The PRIVILEGED control-plane NATS login (M-AUTH): when the server runs with
   // auth_callout, api/worker authenticate as a static account user permitted to
@@ -363,14 +373,14 @@ export async function startApi(
     await retryStartupDependency(
       "PostgreSQL runtime posture",
       () => assertRuntimeDatabasePosture(dbClient.db, databasePosture),
-      { ...retryOptions, onRetry },
+      { ...retryOptions, onRetry, shouldRetry: isRetryableRuntimeDatabaseStartupError },
     );
     const resolvedCatalog = await retryStartupDependency(
       "model catalog",
       () => resolveCatalogSettings(dbClient.db, settings),
       { ...retryOptions, onRetry },
     );
-    observability.info("OpenGeni model catalog resolved", {
+    observability.info("Opengeni model catalog resolved", {
       catalogSource: resolvedCatalog.source,
       catalogVersion: resolvedCatalog.version,
     });
@@ -382,7 +392,7 @@ export async function startApi(
           controlPlaneAuth
             ? { user: controlPlaneAuth.user, pass: controlPlaneAuth.password }
             : undefined,
-          { logger: observabilityEventLogger(observability) },
+          observabilityEventBusOptions(observability),
         ),
       {
         ...retryOptions,
@@ -403,7 +413,7 @@ export async function startApi(
   }
   if (!bus || !workflowClient) {
     await dbClient.close();
-    throw new Error("OpenGeni API startup dependencies were not initialized");
+    throw new Error("Opengeni API startup dependencies were not initialized");
   }
   const objectStorage = createObjectStorage(settings);
   let editableArtifactComposition: StandaloneEditableArtifactApplication | undefined;
@@ -421,7 +431,6 @@ export async function startApi(
   }
   const { app, routeDeps } = createAppComposition({
     settings,
-    connectionCredentials: createNativeRemoteMcpCredentialsPort(settings, dbClient.db),
     db: dbClient.db,
     bus,
     workflowClient: workflowClient.client,
@@ -446,21 +455,32 @@ export async function startApi(
       behavior: "http_and_websocket_fail_closed",
     });
   }
-  const artifactWebSockets = new EditableArtifactWebSocketTransport(routeDeps.editableArtifacts);
+  const artifactWebSockets = new EditableArtifactWebSocketTransport(
+    routeDeps.editableArtifacts,
+    editableArtifactSourceSessionAuthorizer(routeDeps),
+  );
   const interactionFrameProxies = new InteractionFrameProxyTransport(
     resolveFirstPartyDelegationSecret(settings),
   );
+  // WebSocket upgrades bypass the Hono app, so the local-mode browser boundary
+  // (http/local-browser-boundary.ts) is applied to them in the dispatcher;
+  // every other request meets it in the Hono middleware.
+  const localBrowserBoundary = createLocalBrowserBoundary(settings, {
+    warn: (message, attributes) => observability.warn(message, attributes),
+  });
+  const webSocketUpgrades = [interactionFrameProxies, artifactWebSockets];
   const server = Bun.serve<ApiWebSocketConnection>({
     hostname: settings.apiHost,
     port: settings.apiPort,
     idleTimeout: 255,
     fetch: (request, bunServer) => {
-      if (interactionFrameProxies.handles(request)) {
-        return interactionFrameProxies.upgrade(request, bunServer);
-      }
-      if (artifactWebSockets.handles(request)) {
-        return artifactWebSockets.upgrade(request, bunServer);
-      }
+      const upgrade = dispatchApiWebSocketUpgrade(
+        request,
+        bunServer,
+        webSocketUpgrades,
+        localBrowserBoundary,
+      );
+      if (upgrade.handled) return upgrade.response;
       return app.fetch(
         request,
         apiRequestBindingsForTransportPeer(bunServer.requestIP(request)?.address),
@@ -475,10 +495,21 @@ export async function startApi(
       close: (socket) => socket.data.transportClosed(),
     },
   });
+  const metricsServer = startApiMetricsListener(settings, observability);
   const stopSlackInteractionPump = settings.slackSigningSecret
     ? startSlackInteractionPump(routeDeps)
     : undefined;
   const stopMemorySlackPublicationPump = startMemorySlackPublicationPump(routeDeps);
+  const stopWorkspaceWebhookDispatchPump = startWorkspaceWebhookDispatchPump({
+    db: dbClient.db,
+    settings,
+    observability,
+  });
+  const stopNativePushDispatchPump = startNativePushDispatchPump({
+    db: dbClient.db,
+    settings,
+    observability,
+  });
   const stopTemporalScheduleCleanupPump = startTemporalScheduleCleanupPump({
     db: dbClient.db,
     cleanupConnectorAuthorization: async (claim) =>
@@ -488,6 +519,12 @@ export async function startApi(
     },
     observability,
   });
+  const stopScheduledTaskLifecyclePump = startScheduledTaskLifecyclePump({
+    db: dbClient.db,
+    sync: (task) => workflowClient.client.syncScheduledTask({ task }),
+    bus,
+    observability,
+  });
   // M10 — start the metrics-ingestion consumer (agent heartbeats → DB last-sample
   // + downsampled series), gated on the selfhosted flag. A no-op when disabled.
   let stopMetricsIngestion: (() => void) | undefined;
@@ -507,13 +544,19 @@ export async function startApi(
       db: dbClient.db,
       bus,
       observability,
+      agentUpdates: createAutomaticAgentUpdater({
+        db: dbClient.db,
+        bus,
+        settings,
+        observability,
+      }),
     });
     stopHelloIngestion = startHelloIngestion({
       db: dbClient.db,
       bus,
       observability,
     });
-    observability.info("OpenGeni machine-metrics + hello ingestion consumers started", {});
+    observability.info("Opengeni machine-metrics + hello ingestion consumers started", {});
 
     const callout = resolveNatsCalloutConfig(settings);
     if (callout) {
@@ -525,7 +568,7 @@ export async function startApi(
       } catch {
         // A responder start failure must not crash the API (other planes work); log
         // loudly — selfhosted agents will fail to connect until it is up.
-        observability.error("OpenGeni NATS auth-callout responder failed to start", {
+        observability.error("Opengeni NATS auth-callout responder failed to start", {
           errorClass: "NatsAuthCalloutOperationError",
           errorCode: "nats_auth_callout_start_failed",
           origin: "api",
@@ -533,24 +576,31 @@ export async function startApi(
       }
     } else {
       observability.warn(
-        "OpenGeni selfhosted enabled but the NATS auth-callout plane is not configured; selfhosted agents cannot connect",
+        "Opengeni selfhosted enabled but the NATS auth-callout plane is not configured; selfhosted agents cannot connect",
         {},
       );
     }
   }
-  observability.info("OpenGeni API listening", {
+  observability.info("Opengeni API listening", {
     host: settings.apiHost,
     port: settings.apiPort,
+    ...(metricsServer ? { metricsPort: settings.apiMetricsPort } : {}),
   });
   return {
     server,
     close: async () => {
       server.stop(true);
+      metricsServer?.stop(true);
       stopSlackInteractionPump?.();
       await stopMemorySlackPublicationPump();
       stopMetricsIngestion?.();
       stopHelloIngestion?.();
       await stopTemporalScheduleCleanupPump();
+      await stopScheduledTaskLifecyclePump();
+      await stopWorkspaceWebhookDispatchPump();
+      await stopNativePushDispatchPump();
+      // Write queued presence before the database pool closes.
+      await routeDeps.userPresence?.close().catch(() => undefined);
       await Promise.allSettled([
         Promise.resolve(editableArtifactComposition?.close()),
         authCalloutResponder?.close(),
@@ -640,7 +690,7 @@ function temporalIntervalSpec(
   // Temporal interval schedules match Epoch + (n * every) + offset. Its
   // top-level startAt only filters matching times before that boundary, so it
   // does not itself anchor the cadence. Derive the phase from startAt to make
-  // the stored OpenGeni timestamp the first interval boundary rather than the
+  // the stored Opengeni timestamp the first interval boundary rather than the
   // next epoch-aligned match.
   const everyMilliseconds = BigInt(schedule.everySeconds) * 1_000n;
   const startMilliseconds = BigInt(new Date(schedule.startAt).getTime());

package/src/integration-connect-metrics.ts

@@ -0,0 +1,228 @@
+import { CORE_INTEGRATION_DEFINITIONS } from "@opengeni/capabilities";
+import type { ConnectAttemptTransition } from "@opengeni/db";
+import type { Observability } from "@opengeni/observability";
+
+/**
+ * Low-cardinality product telemetry for connecting capabilities, integrations,
+ * and MCP servers. Labels are closed sets: a caller-chosen provider id, MCP
+ * URL, provider domain, workspace, or user never becomes a label value.
+ *
+ * Three signals cover the whole connect surface:
+ * - `opengeni_connect_attempts_total` — every unified Connect attempt (the
+ *   popup flow behind every provider card), counted on each committed state
+ *   transition, so `started` minus terminal states is abandonment.
+ * - `opengeni_integration_oauth_callbacks_total` — every provider redirect back
+ *   to Opengeni, including the legacy settings-page flows whose failure is only
+ *   visible in a `?<flow>=error&reason=` redirect, never in an HTTP status.
+ * - `opengeni_integration_oauth_starts_total` — MCP OAuth discovery/registration
+ *   at the start of a connection, where remote servers most often fail.
+ */
+
+const FIXED_CONNECT_PROVIDERS = [
+  "x",
+  "reddit",
+  "mcp-install",
+  "openapi",
+  "graphql",
+  "slack-bot",
+  "gmail",
+  "slack-personal",
+  "github-personal",
+  "github-app",
+  "github-lens",
+  "google-drive-knowledge",
+  "google-drive-publish",
+  "fiken-token",
+  "fiken-oauth",
+  "mcp-oauth",
+  "mcp-headers",
+  "mcp-bearer",
+] as const;
+
+const CONNECT_PROVIDERS: ReadonlySet<string> = new Set([
+  ...FIXED_CONNECT_PROVIDERS,
+  ...CORE_INTEGRATION_DEFINITIONS.map((definition) => definition.id),
+]);
+
+const CONNECT_STATES: ReadonlySet<string> = new Set([
+  "requires_user_action",
+  "credential_input",
+  "provider_wait",
+  "account_selection",
+  "resource_selection",
+  "preview",
+  "installing",
+  "connected_but_incomplete",
+  "complete",
+  "cancelled",
+  "expired",
+  "failed",
+  "uncertain",
+]);
+
+const BOUNDED_CODE = /^[a-z][a-z0-9_]{0,47}$/;
+
+export function connectMetricProvider(providerId: string): string {
+  return CONNECT_PROVIDERS.has(providerId) ? providerId : "other";
+}
+
+/** `http_404`/`upstream_http_502` collapse to a status class; other codes keep a closed grammar. */
+export function boundedConnectReason(value: string | null | undefined): string {
+  if (!value) return "none";
+  const http = /^(upstream_)?http_([1-5])\d\d$/.exec(value);
+  if (http) return `${http[1] ?? ""}http_${http[2]}xx`;
+  return BOUNDED_CODE.test(value) ? value : "other";
+}
+
+export function observeConnectAttemptTransition(
+  observability: Observability | null | undefined,
+  transition: ConnectAttemptTransition,
+): void {
+  if (!observability) return;
+  try {
+    observability.incrementCounter({
+      name: "opengeni_connect_attempts_total",
+      help: "Connect (capability/integration/MCP setup) attempt transitions by bounded provider, resulting state, and error code. state=started counts new attempts.",
+      labels: {
+        provider: connectMetricProvider(transition.providerId),
+        state:
+          transition.previousState === null
+            ? "started"
+            : CONNECT_STATES.has(transition.state)
+              ? transition.state
+              : "other",
+        error: boundedConnectReason(transition.errorCode),
+      },
+    });
+  } catch {
+    // Telemetry never changes a committed setup outcome.
+  }
+}
+
+/** Provider redirect routes, keyed by route label, with the flow they complete. */
+const OAUTH_CALLBACK_FLOWS = new Map<string, string>([
+  ["/v1/integrations/oauth/callback", "mcp_oauth"],
+  ["/v1/integrations/provider-oauth/callback", "provider_oauth"],
+  ["/v1/integrations/slack/callback", "slack_bot"],
+  ["/v1/integrations/fiken/callback", "fiken"],
+  ["/v1/integrations/atlassian/callback", "atlassian"],
+  ["/v1/integrations/google-drive/callback", "google_drive"],
+  ["/v1/integrations/github-personal/oauth/callback", "github_personal"],
+  ["/v1/social/oauth/callback", "social"],
+  ["/v1/github/setup", "github_app"],
+  ["/v1/github/install/callback", "github_app"],
+  ["/v1/github/oauth/callback", "github_app"],
+  ["/v1/github/app-manifest/callback", "github_app"],
+  ["/v1/pr-review/github/install/callback", "github_lens"],
+  ["/v1/pr-review/github/oauth/callback", "github_lens"],
+]);
+
+/** Redirect query markers written by each flow's `callbackReturnPath`. */
+const OAUTH_RESULT_MARKERS = [
+  "integration_oauth",
+  "slack",
+  "google_drive",
+  "fiken",
+  "atlassian",
+  "github_personal_oauth",
+  "social_oauth",
+  "github",
+] as const;
+const SUCCESS_MARKER_VALUES = new Set(["success", "connected", "complete"]);
+
+export function isOAuthCallbackRoute(route: string): boolean {
+  return OAUTH_CALLBACK_FLOWS.has(route);
+}
+
+/**
+ * Classify one provider callback response from its status and redirect only.
+ * A popup (Connect attempt) callback returns to its exact opener URL without
+ * a result marker; its outcome is counted by `opengeni_connect_attempts_total`
+ * and here as `handoff`.
+ */
+export function classifyOAuthCallback(input: {
+  route: string;
+  status: number;
+  location: string | null;
+}): { flow: string; provider: string; outcome: string; stage: string; reason: string } | null {
+  const flow = OAUTH_CALLBACK_FLOWS.get(input.route);
+  if (!flow) return null;
+  if (input.status >= 400) {
+    return {
+      flow,
+      provider: flow,
+      outcome: "failure",
+      stage: "none",
+      reason: `http_${String(input.status)[0]}xx`,
+    };
+  }
+  let params: URLSearchParams | null = null;
+  if (input.location) {
+    try {
+      params = new URL(input.location, "https://opengeni.invalid").searchParams;
+    } catch {
+      params = null;
+    }
+  }
+  const marker = params
+    ? OAUTH_RESULT_MARKERS.map((name) => params!.get(name)).find((value) => value !== null)
+    : undefined;
+  const definitionId = params?.get("definitionId") ?? null;
+  const provider =
+    flow === "provider_oauth" && definitionId && CONNECT_PROVIDERS.has(definitionId)
+      ? definitionId
+      : flow;
+  if (marker === undefined || marker === null) {
+    return { flow, provider, outcome: "handoff", stage: "none", reason: "none" };
+  }
+  if (SUCCESS_MARKER_VALUES.has(marker)) {
+    return { flow, provider, outcome: "success", stage: "none", reason: "none" };
+  }
+  const reason = boundedConnectReason(params?.get("reason"));
+  return {
+    flow,
+    provider,
+    outcome: reason === "access_denied" || reason === "cancelled" ? "cancelled" : "failure",
+    stage: boundedConnectReason(params?.get("stage")),
+    reason,
+  };
+}
+
+export function observeOAuthCallback(
+  observability: Observability | null | undefined,
+  input: { route: string; status: number; location: string | null },
+): void {
+  if (!observability) return;
+  const classified = classifyOAuthCallback(input);
+  if (!classified) return;
+  try {
+    observability.incrementCounter({
+      name: "opengeni_integration_oauth_callbacks_total",
+      help: "Provider OAuth/install callbacks by bounded flow, provider, outcome, stage, and reason.",
+      labels: classified,
+    });
+  } catch {
+    // Telemetry never changes the callback redirect.
+  }
+}
+
+export function observeOAuthStart(
+  observability: Observability | null | undefined,
+  input: { flow: string; outcome: "success" | "failure"; stage?: string; reason?: string },
+): void {
+  if (!observability) return;
+  try {
+    observability.incrementCounter({
+      name: "opengeni_integration_oauth_starts_total",
+      help: "Integration OAuth starts (discovery, registration, state) by bounded flow, outcome, stage, and reason.",
+      labels: {
+        flow: BOUNDED_CODE.test(input.flow) ? input.flow : "other",
+        outcome: input.outcome,
+        stage: boundedConnectReason(input.stage),
+        reason: boundedConnectReason(input.reason),
+      },
+    });
+  } catch {
+    // Telemetry never changes the start response.
+  }
+}