usage-panel-opencode 0.0.0-stage → 0.1.1

package/src/index.ts

@@ -0,0 +1,761 @@
+import { Plugin } from '@opencode/plugin';
+import { normalizeIntervalSeconds, type PanelPreferences, resolvePreferences } from './config';
+import { type ResolvedAccount, resolveAccount } from './core/account';
+import { canAttempt, nextRetryDelay } from './core/backoff';
+import { type HeaderUsage, normalizeSnapshot } from './core/snapshot';
+import { initialPanelState, type PanelRuntimeState, transitionPanelState } from './core/state';
+import { fetchUsage, type UsageClientError } from './core/usage-client';
+import { readUsageHeaders } from './core/usage-headers';
+import {
+  type PanelError,
+  type PanelSnapshot,
+  type RefreshNotice,
+  Usage,
+  type UsageUpdateEvent,
+} from './rpc';
+
+const PREFERENCES_KEY = 'preferences';
+const MAX_INSTANCE_ID_LENGTH = 128;
+const AUTH_CHECK_INTERVAL_MS = 60_000;
+
+interface HeaderObservation {
+  values: HeaderUsage;
+  accountIdentity: string;
+  requestSequence: number;
+}
+
+interface RequestOwner {
+  accountIdentity: string;
+  instanceIds: string[];
+  sequence: number;
+}
+
+interface TuiInstance {
+  id: string;
+  attached: boolean;
+  listening: boolean;
+  panelState: PanelRuntimeState;
+  activeIdentity: string | null;
+  activeAccount: ResolvedAccount | null;
+  latestHeaders: HeaderObservation | null;
+  lastHeaderSequence: number;
+  lastServiceData: unknown;
+  lastServiceFetchedAt: number | null;
+  lastAttemptAt: number | null;
+  failureCount: number;
+  authSuspended: boolean;
+  retryAt: number | null;
+  timer: ReturnType<typeof setTimeout> | undefined;
+  inFlight: Promise<PanelSnapshot> | null;
+  requestController: AbortController | null;
+  generation: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function responseHeaders(eventValue: unknown): Headers | Record<string, string | undefined> | null {
+  if (!isRecord(eventValue) || !isRecord(eventValue.response)) return null;
+  const response = eventValue.response;
+  if (response.headers instanceof Headers) return response.headers;
+  if (!isRecord(response.headers)) return null;
+  const result: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(response.headers)) {
+    if (typeof value === 'string') result[key] = value;
+  }
+  return result;
+}
+
+function requestFromEvent(eventValue: unknown): Request | null {
+  if (!isRecord(eventValue) || !isRecord(eventValue.request)) return null;
+  const request = eventValue.request;
+  return typeof request.url === 'string' ? (request as unknown as Request) : null;
+}
+
+function isOpenAIProviderRequest(eventValue: unknown, request: Request): boolean {
+  if (!isRecord(eventValue) || !isRecord(eventValue.model)) return false;
+  if (eventValue.model.providerID !== 'openai') return false;
+  try {
+    return new URL(request.url).hostname === 'api.openai.com';
+  } catch {
+    return false;
+  }
+}
+
+function requestedInstanceId(input: unknown): string | null {
+  if (!isRecord(input) || typeof input.instanceId !== 'string') return null;
+  const id = input.instanceId.trim();
+  return id.length > 0 && id.length <= MAX_INSTANCE_ID_LENGTH ? id : null;
+}
+
+function safeError(error: UsageClientError): PanelError {
+  const messages: Record<UsageClientError['kind'], string> = {
+    network: 'No se pudo consultar el consumo de la suscripción.',
+    rate_limited: 'OpenAI limitó temporalmente las consultas de consumo.',
+    unauthorized: 'La conexión de OpenAI necesita volver a autenticarse.',
+    forbidden: 'OpenAI no permitió consultar el consumo de esta cuenta.',
+    malformed: 'OpenAI devolvió datos de consumo con un formato no reconocido.',
+    unknown: 'No se pudo obtener el consumo de la suscripción.',
+  };
+  return {
+    kind: error.kind,
+    message: messages[error.kind],
+    action:
+      error.kind === 'unauthorized'
+        ? '/connect → OpenAI'
+        : error.kind === 'forbidden'
+          ? 'Comprueba que la cuenta tenga acceso a la suscripción.'
+          : error.kind === 'malformed'
+            ? 'Actualiza el plugin y vuelve a intentarlo.'
+            : 'Vuelve a intentarlo en unos momentos.',
+  };
+}
+
+function makeInstance(id: string): TuiInstance {
+  return {
+    id,
+    attached: false,
+    listening: false,
+    panelState: initialPanelState(),
+    activeIdentity: null,
+    activeAccount: null,
+    latestHeaders: null,
+    lastHeaderSequence: 0,
+    lastServiceData: null,
+    lastServiceFetchedAt: null,
+    lastAttemptAt: null,
+    failureCount: 0,
+    authSuspended: false,
+    retryAt: null,
+    timer: undefined,
+    inFlight: null,
+    requestController: null,
+    generation: 0,
+  };
+}
+
+export default Plugin.define({
+  id: 'openai-usage.server',
+  async setup(ctx) {
+    const stored = await ctx.storage.get(PREFERENCES_KEY);
+    let preferences: PanelPreferences = resolvePreferences(ctx.options, stored);
+    const instances = new Map<string, TuiInstance>();
+    const requestOwners = new WeakMap<Request, RequestOwner>();
+    let requestSequence = 0;
+    let emitRpcEvent: ((event: UsageUpdateEvent) => Promise<void>) | undefined;
+    let disposeRpc: (() => Promise<void>) | undefined;
+
+    const getInstance = (id: string | null): TuiInstance | null => {
+      if (!id) return null;
+      let instance = instances.get(id);
+      if (!instance) {
+        instance = makeInstance(id);
+        instances.set(id, instance);
+      }
+      return instance;
+    };
+
+    const panelSnapshot = (instance: TuiInstance): PanelSnapshot => {
+      const fetchedAt = instance.panelState.snapshot?.origin.fetchedAt;
+      return {
+        state: instance.panelState.state,
+        snapshot: instance.panelState.snapshot,
+        error: instance.panelState.error,
+        preferences: { ...preferences },
+        ...(typeof fetchedAt === 'number' ? { ageMs: Math.max(0, Date.now() - fetchedAt) } : {}),
+        ...(instance.retryAt !== null ? { retryAt: instance.retryAt } : {}),
+      };
+    };
+
+    const initialSnapshot = (): PanelSnapshot => ({
+      state: 'loading',
+      snapshot: null,
+      preferences: { ...preferences },
+    });
+
+    const emitUpdate = async (instance: TuiInstance, finalDisabledUpdate = false) => {
+      if (
+        !emitRpcEvent ||
+        instances.get(instance.id) !== instance ||
+        (finalDisabledUpdate ? !instance.attached : !instance.listening || !preferences.enabled)
+      ) {
+        return;
+      }
+      try {
+        await emitRpcEvent({ instanceId: instance.id, data: panelSnapshot(instance) });
+      } catch {
+        // A disconnected TUI has no listener; its next snapshot RPC reads its own state.
+      }
+    };
+
+    const clearTimer = (instance: TuiInstance, clearRetryAt = true) => {
+      if (instance.timer) clearTimeout(instance.timer);
+      instance.timer = undefined;
+      if (clearRetryAt) instance.retryAt = null;
+    };
+
+    const scheduleAuthCheck = (instance: TuiInstance) => {
+      clearTimer(instance, false);
+      if (!instance.listening || !preferences.enabled || !instance.authSuspended) {
+        instance.retryAt = null;
+        return;
+      }
+      instance.retryAt = null;
+      instance.timer = setTimeout(() => {
+        instance.timer = undefined;
+        void probeCredential(instance);
+      }, AUTH_CHECK_INTERVAL_MS);
+    };
+
+    const schedule = (
+      instance: TuiInstance,
+      delayMs: number | null,
+      retry: boolean,
+      fixedRetryAt?: number,
+    ) => {
+      clearTimer(instance, false);
+      if (!instance.listening || !preferences.enabled) {
+        instance.retryAt = null;
+        return;
+      }
+      if (instance.authSuspended) {
+        scheduleAuthCheck(instance);
+        return;
+      }
+      if (delayMs === null) {
+        instance.retryAt = null;
+        return;
+      }
+      const delay = Math.max(0, delayMs);
+      instance.retryAt = retry ? (fixedRetryAt ?? Date.now() + delay) : null;
+      instance.timer = setTimeout(() => {
+        instance.timer = undefined;
+        instance.retryAt = null;
+        void refresh(instance);
+      }, delay);
+    };
+
+    const resolveActiveAccount = async (): Promise<ResolvedAccount> => {
+      try {
+        const connection = await ctx.integration.connection.active('openai');
+        const credential = connection
+          ? await ctx.integration.connection.resolve(connection)
+          : undefined;
+        return resolveAccount(connection, credential);
+      } catch {
+        return resolveAccount(undefined, undefined);
+      }
+    };
+
+    const setAccount = (instance: TuiInstance, resolved: ResolvedAccount): boolean => {
+      const previousToken = instance.activeAccount?.accessToken ?? null;
+      const previousKind = instance.activeAccount?.account.credentialKind ?? null;
+      const changed =
+        (instance.activeIdentity !== null && instance.activeIdentity !== resolved.identity) ||
+        (instance.authSuspended &&
+          (previousToken !== resolved.accessToken ||
+            previousKind !== resolved.account.credentialKind));
+      if (changed) {
+        instance.latestHeaders = null;
+        instance.lastHeaderSequence = 0;
+        instance.lastServiceData = null;
+        instance.lastServiceFetchedAt = null;
+        instance.panelState = transitionPanelState(instance.panelState, {
+          type: 'account_changed',
+        });
+        instance.failureCount = 0;
+        instance.authSuspended = false;
+        instance.retryAt = null;
+      }
+      instance.activeIdentity = resolved.identity;
+      instance.activeAccount = resolved;
+      return changed;
+    };
+
+    const current = (instance: TuiInstance, generation?: number): boolean =>
+      instances.get(instance.id) === instance &&
+      instance.listening &&
+      preferences.enabled &&
+      (generation === undefined || instance.generation === generation);
+
+    const setFailure = (instance: TuiInstance, error: UsageClientError) => {
+      const safe = safeError(error);
+      if (error.kind === 'unauthorized') {
+        instance.panelState = transitionPanelState(instance.panelState, {
+          type: 'needs_auth',
+          error: safe,
+        });
+      } else {
+        instance.panelState = transitionPanelState(instance.panelState, {
+          type: 'failure',
+          error: safe,
+        });
+      }
+    };
+
+    async function doRefresh(instance: TuiInstance, signal?: AbortSignal): Promise<PanelSnapshot> {
+      if (!current(instance) || instance.authSuspended) return panelSnapshot(instance);
+      const now = Date.now();
+      if (!canAttempt(instance.lastAttemptAt, now)) return panelSnapshot(instance);
+      instance.lastAttemptAt = now;
+      instance.retryAt = null;
+
+      const requestGeneration = ++instance.generation;
+      const controller = new AbortController();
+      instance.requestController = controller;
+      const abortFromRpc = () => controller.abort(signal?.reason);
+      if (signal?.aborted) abortFromRpc();
+      else signal?.addEventListener('abort', abortFromRpc, { once: true });
+
+      try {
+        const account = await resolveActiveAccount();
+        if (!current(instance, requestGeneration) || controller.signal.aborted)
+          return panelSnapshot(instance);
+        const accountChanged = setAccount(instance, account);
+        if (accountChanged) await emitUpdate(instance);
+
+        if (account.account.credentialKind === 'key') {
+          instance.panelState = transitionPanelState(instance.panelState, {
+            type: 'no_subscription',
+          });
+          instance.failureCount = 0;
+          await emitUpdate(instance);
+          schedule(instance, preferences.intervalSeconds * 1000, false);
+          return panelSnapshot(instance);
+        }
+        if (account.account.credentialKind !== 'oauth' || !account.accessToken) {
+          instance.panelState = transitionPanelState(instance.panelState, {
+            type: 'needs_auth',
+            error: {
+              kind: 'unauthorized',
+              message: 'Conecta OpenAI con «Sign in with ChatGPT» para ver el consumo.',
+              action: '/connect → OpenAI',
+            },
+          });
+          instance.authSuspended = true;
+          schedule(instance, null, false);
+          await emitUpdate(instance);
+          return panelSnapshot(instance);
+        }
+
+        const result = await fetchUsage({
+          accessToken: account.accessToken,
+          accountId: account.usageAccountId,
+          signal: controller.signal,
+        });
+        if (!current(instance, requestGeneration) || controller.signal.aborted)
+          return panelSnapshot(instance);
+
+        const latestAccount = await resolveActiveAccount();
+        if (!current(instance, requestGeneration) || controller.signal.aborted)
+          return panelSnapshot(instance);
+        if (latestAccount.identity !== account.identity) {
+          setAccount(instance, latestAccount);
+          await emitUpdate(instance);
+          schedule(instance, preferences.intervalSeconds * 1000, false);
+          return panelSnapshot(instance);
+        }
+        setAccount(instance, latestAccount);
+
+        if (result.ok) {
+          instance.lastServiceData = result.data;
+          instance.lastServiceFetchedAt = result.fetchedAt;
+          const headers =
+            instance.latestHeaders?.accountIdentity === latestAccount.identity
+              ? instance.latestHeaders.values
+              : null;
+          const snapshot = normalizeSnapshot({
+            account: latestAccount.account,
+            service: result.data,
+            headers,
+            fetchedAt: result.fetchedAt,
+            serviceFetchedAt: result.fetchedAt,
+            sensitiveValues: [latestAccount.accessToken],
+            sensitiveAccountIds: [latestAccount.usageAccountId],
+          });
+          instance.panelState = transitionPanelState(instance.panelState, {
+            type: 'success',
+            snapshot,
+          });
+          instance.failureCount = 0;
+          instance.authSuspended = false;
+          await emitUpdate(instance);
+          schedule(instance, preferences.intervalSeconds * 1000, false);
+          return panelSnapshot(instance);
+        }
+
+        // An old header observation is not a successful refresh and must not mask this failure.
+        setFailure(instance, result.error);
+        instance.failureCount += 1;
+        const delay = nextRetryDelay(
+          instance.failureCount - 1,
+          result.error.kind,
+          result.error.retryAfterMs,
+        );
+        instance.authSuspended = delay === null;
+        schedule(instance, delay, true);
+        await emitUpdate(instance);
+        return panelSnapshot(instance);
+      } catch {
+        if (current(instance, requestGeneration)) {
+          const error: UsageClientError = {
+            kind: 'network',
+            message: 'No se pudo consultar el consumo de la suscripción.',
+          };
+          setFailure(instance, error);
+          instance.failureCount += 1;
+          const delay = nextRetryDelay(instance.failureCount - 1, 'network');
+          schedule(instance, delay, true);
+          await emitUpdate(instance);
+        }
+        return panelSnapshot(instance);
+      } finally {
+        signal?.removeEventListener('abort', abortFromRpc);
+        if (instance.requestController === controller) instance.requestController = null;
+      }
+    }
+
+    function refresh(instance: TuiInstance, signal?: AbortSignal): Promise<PanelSnapshot> {
+      if (instance.inFlight) return Promise.resolve(panelSnapshot(instance));
+      const currentRefresh = doRefresh(instance, signal);
+      instance.inFlight = currentRefresh;
+      void currentRefresh.finally(() => {
+        if (instance.inFlight === currentRefresh) instance.inFlight = null;
+      });
+      return currentRefresh;
+    }
+
+    async function probeCredential(instance: TuiInstance): Promise<void> {
+      if (!current(instance) || !instance.authSuspended) return;
+
+      const previousIdentity = instance.activeIdentity;
+      const previousToken = instance.activeAccount?.accessToken ?? null;
+      const previousKind = instance.activeAccount?.account.credentialKind ?? null;
+      const resolved = await resolveActiveAccount();
+      if (!current(instance) || !instance.authSuspended) return;
+
+      const credentialChanged =
+        resolved.identity !== previousIdentity ||
+        resolved.accessToken !== previousToken ||
+        resolved.account.credentialKind !== previousKind;
+      if (!credentialChanged) {
+        scheduleAuthCheck(instance);
+        return;
+      }
+
+      setAccount(instance, resolved);
+      instance.authSuspended = false;
+      instance.failureCount = 0;
+
+      if (resolved.account.credentialKind === 'key') {
+        instance.panelState = transitionPanelState(instance.panelState, {
+          type: 'no_subscription',
+        });
+        await emitUpdate(instance);
+        schedule(instance, preferences.intervalSeconds * 1000, false);
+        return;
+      }
+
+      if (resolved.account.credentialKind !== 'oauth' || !resolved.accessToken) {
+        instance.panelState = transitionPanelState(instance.panelState, {
+          type: 'needs_auth',
+          error: {
+            kind: 'unauthorized',
+            message: 'Conecta OpenAI con «Sign in with ChatGPT» para ver el consumo.',
+            action: '/connect → OpenAI',
+          },
+        });
+        instance.authSuspended = true;
+        scheduleAuthCheck(instance);
+        await emitUpdate(instance);
+        return;
+      }
+
+      await emitUpdate(instance);
+      if (canAttempt(instance.lastAttemptAt, Date.now())) {
+        void refresh(instance);
+        return;
+      }
+      const retryAt = (instance.lastAttemptAt ?? Date.now()) + 60_000;
+      schedule(instance, Math.max(0, retryAt - Date.now()), true, retryAt);
+    }
+
+    async function refreshManually(
+      instance: TuiInstance,
+      signal?: AbortSignal,
+    ): Promise<PanelSnapshot> {
+      if (!instance.listening || !preferences.enabled) return panelSnapshot(instance);
+
+      if (instance.authSuspended) {
+        const previousToken = instance.activeAccount?.accessToken;
+        const resolved = await resolveActiveAccount();
+        if (
+          resolved.identity !== instance.activeIdentity ||
+          (resolved.accessToken !== null && resolved.accessToken !== previousToken)
+        ) {
+          setAccount(instance, resolved);
+          instance.authSuspended = false;
+          instance.failureCount = 0;
+          if (!canAttempt(instance.lastAttemptAt, Date.now())) {
+            const retryAt = (instance.lastAttemptAt ?? Date.now()) + 60_000;
+            schedule(instance, Math.max(0, retryAt - Date.now()), true, retryAt);
+          }
+        } else {
+          return panelSnapshot(instance);
+        }
+      }
+
+      if (instance.inFlight) {
+        const retryAt = instance.retryAt ?? (instance.lastAttemptAt ?? Date.now()) + 60_000;
+        const notice: RefreshNotice = {
+          kind: 'in_progress',
+          retryAt,
+          message: 'Ya hay una consulta en curso; se conserva el dato actual.',
+        };
+        return { ...panelSnapshot(instance), refreshNotice: notice };
+      }
+
+      const now = Date.now();
+      const retryAt =
+        instance.retryAt ??
+        (instance.lastAttemptAt === null ? now : instance.lastAttemptAt + 60_000);
+      if (instance.retryAt !== null && now < instance.retryAt) {
+        const notice: RefreshNotice = {
+          kind: 'limited',
+          retryAt: instance.retryAt,
+          message: 'Se conserva el dato actual; se respeta la espera de reintento.',
+        };
+        return { ...panelSnapshot(instance), refreshNotice: notice };
+      }
+      if (!canAttempt(instance.lastAttemptAt, now)) {
+        const notice: RefreshNotice = {
+          kind: 'limited',
+          retryAt,
+          message: 'Se conserva el dato actual; se respeta el intervalo mínimo de 60 segundos.',
+        };
+        return { ...panelSnapshot(instance), refreshNotice: notice };
+      }
+      return refresh(instance, signal);
+    }
+
+    const deactivate = (instance: TuiInstance, detach: boolean) => {
+      instance.listening = false;
+      if (detach) instance.attached = false;
+      clearTimer(instance);
+      instance.generation += 1;
+      instance.requestController?.abort();
+      instance.requestController = null;
+      instance.inFlight = null;
+      instance.activeIdentity = null;
+      instance.activeAccount = null;
+      instance.latestHeaders = null;
+      instance.lastHeaderSequence = 0;
+      instance.lastServiceData = null;
+      instance.lastServiceFetchedAt = null;
+      instance.lastAttemptAt = null;
+      instance.failureCount = 0;
+      instance.authSuspended = false;
+      instance.panelState = transitionPanelState(instance.panelState, { type: 'stop' });
+    };
+
+    const startInstance = (instance: TuiInstance) => {
+      if (instance.attached) return;
+      instance.attached = true;
+      if (!preferences.enabled) return;
+      instance.listening = true;
+      void refresh(instance);
+    };
+
+    const registration = await ctx.rpc.register(Usage, {
+      snapshot: async (input) => {
+        const instance = getInstance(requestedInstanceId(input));
+        return instance ? panelSnapshot(instance) : initialSnapshot();
+      },
+      refresh: async (input, rpcContext) => {
+        const instance = getInstance(requestedInstanceId(input));
+        return instance ? refreshManually(instance, rpcContext?.signal) : initialSnapshot();
+      },
+      setPreferences: async (input) => {
+        const patch = isRecord(input) ? input : {};
+        const wasEnabled = preferences.enabled;
+        const intervalValue = Object.hasOwn(patch, 'intervalSeconds')
+          ? normalizeIntervalSeconds(patch.intervalSeconds)
+          : preferences.intervalSeconds;
+        preferences = {
+          enabled: typeof patch.enabled === 'boolean' ? patch.enabled : preferences.enabled,
+          intervalSeconds: intervalValue,
+          visible: typeof patch.visible === 'boolean' ? patch.visible : preferences.visible,
+        };
+        await ctx.storage.set(PREFERENCES_KEY, { ...preferences });
+
+        for (const instance of instances.values()) {
+          if (!preferences.enabled) {
+            deactivate(instance, false);
+            await emitUpdate(instance, true);
+            continue;
+          }
+          if (!wasEnabled && preferences.enabled) {
+            if (instance.attached) {
+              instance.listening = true;
+              void refresh(instance);
+            }
+            continue;
+          }
+          if (!instance.listening) continue;
+          if (instance.authSuspended) {
+            scheduleAuthCheck(instance);
+            await emitUpdate(instance);
+            continue;
+          }
+          if (instance.retryAt !== null) {
+            const retryAt = instance.retryAt;
+            schedule(instance, Math.max(0, retryAt - Date.now()), true, retryAt);
+          } else if (instance.lastAttemptAt !== null) {
+            schedule(
+              instance,
+              Math.max(0, instance.lastAttemptAt + preferences.intervalSeconds * 1000 - Date.now()),
+              false,
+            );
+          }
+          await emitUpdate(instance);
+        }
+
+        const active = [...instances.values()].find((instance) => instance.listening);
+        return active ? panelSnapshot(active) : initialSnapshot();
+      },
+      start: async (input) => {
+        const instance = getInstance(requestedInstanceId(input));
+        if (instance) startInstance(instance);
+        return {};
+      },
+      stop: async (input) => {
+        const id = requestedInstanceId(input);
+        const instance = id ? instances.get(id) : undefined;
+        if (instance) {
+          deactivate(instance, true);
+          instances.delete(instance.id);
+        }
+        return {};
+      },
+    });
+    emitRpcEvent = (event) => registration.events.emit('updated', { ...event });
+    disposeRpc = () => registration.dispose();
+
+    const requestHook = await ctx.session.hook(
+      'http.request',
+      async (event) => {
+        const request = requestFromEvent(event);
+        if (!request || !isOpenAIProviderRequest(event, request)) return;
+        const targets = [...instances.values()].filter((instance) => instance.listening);
+        if (targets.length === 0) return;
+        const resolved = await resolveActiveAccount();
+
+        const instanceIds: string[] = [];
+        for (const instance of targets) {
+          if (!current(instance)) continue;
+          const previousToken = instance.activeAccount?.accessToken;
+          const previousIdentity = instance.activeIdentity;
+          const wasSuspended = instance.authSuspended;
+          const accountChanged = setAccount(instance, resolved);
+          if (accountChanged) await emitUpdate(instance);
+          if (resolved.account.credentialKind !== 'oauth' || !resolved.accessToken) continue;
+          if (
+            wasSuspended &&
+            (resolved.identity !== previousIdentity || resolved.accessToken !== previousToken)
+          ) {
+            instance.authSuspended = false;
+            instance.failureCount = 0;
+            if (canAttempt(instance.lastAttemptAt, Date.now())) {
+              void refresh(instance);
+            } else {
+              const retryAt = (instance.lastAttemptAt ?? Date.now()) + 60_000;
+              schedule(instance, Math.max(0, retryAt - Date.now()), true, retryAt);
+            }
+          }
+          if (instance.authSuspended || instance.activeIdentity !== resolved.identity) continue;
+          instance.activeAccount = resolved;
+          instanceIds.push(instance.id);
+        }
+        if (instanceIds.length === 0) return;
+        requestOwners.set(request, {
+          accountIdentity: resolved.identity,
+          instanceIds,
+          sequence: ++requestSequence,
+        });
+      },
+      { providerID: 'openai' },
+    );
+
+    const responseHook = await ctx.session.hook(
+      'http.response',
+      async (event) => {
+        const request = requestFromEvent(event);
+        if (!request || !isOpenAIProviderRequest(event, request)) return;
+        const owner = requestOwners.get(request);
+        if (!owner) return;
+        requestOwners.delete(request);
+        const headers = readUsageHeaders(responseHeaders(event));
+        if (!headers) return;
+
+        const resolved = await resolveActiveAccount();
+        if (resolved.identity !== owner.accountIdentity) return;
+        for (const id of owner.instanceIds) {
+          const instance = instances.get(id);
+          if (
+            !instance ||
+            !current(instance) ||
+            instance.activeIdentity !== owner.accountIdentity ||
+            owner.sequence <= instance.lastHeaderSequence
+          ) {
+            continue;
+          }
+
+          instance.lastHeaderSequence = owner.sequence;
+          instance.latestHeaders = {
+            values: headers,
+            accountIdentity: owner.accountIdentity,
+            requestSequence: owner.sequence,
+          };
+          const account = instance.activeAccount;
+          if (!account) continue;
+
+          const previousError = instance.panelState.error;
+          const wasRecovering =
+            instance.panelState.state === 'stale' || instance.panelState.state === 'needs_auth';
+          const snapshot = normalizeSnapshot({
+            account: account.account,
+            service: instance.lastServiceData,
+            headers,
+            fetchedAt: Date.now(),
+            serviceFetchedAt: instance.lastServiceFetchedAt,
+            sensitiveValues: [account.accessToken],
+            sensitiveAccountIds: [account.usageAccountId],
+            detail:
+              'Porcentajes obtenidos de respuestas de OpenAI correlacionadas; el reinicio no está disponible por esta fuente.',
+          });
+          instance.panelState = transitionPanelState(instance.panelState, {
+            type: 'success',
+            snapshot,
+          });
+          if (wasRecovering && previousError) {
+            instance.panelState = transitionPanelState(instance.panelState, {
+              type: 'failure',
+              error: previousError,
+            });
+          }
+          await emitUpdate(instance);
+        }
+      },
+      { providerID: 'openai' },
+    );
+
+    return () => {
+      for (const instance of instances.values()) deactivate(instance, true);
+      instances.clear();
+      void requestHook.dispose();
+      void responseHook.dispose();
+      void disposeRpc?.();
+    };
+  },
+});