@modelprofile.com/flexharness-providers 7.0.0

package/ts_openai_account/smartai.providers.openai.ts

@@ -0,0 +1,1209 @@
+// OpenAI protocol portions are adapted in TypeScript; see third-party-notices.md.
+import * as plugins from './plugins.js';
+import {
+  OPENAI_CHATGPT_CODEX_BASE_URL,
+  OPENAI_CHATGPT_DEFAULT_ORIGINATOR,
+  completeOpenAiChatGptDeviceCodeLogin,
+  createOpenAiChatGptBrowserAuthorization,
+  exchangeOpenAiChatGptBrowserAuthorizationCode,
+  parseOpenAiChatGptBrowserCallback,
+  parseOpenAiChatGptTokenInfo,
+  refreshOpenAiChatGptTokenData,
+  requestOpenAiChatGptDeviceCode,
+  revokeOpenAiChatGptToken,
+} from '@modelprofile.com/flexharness-providers/auth';
+import { createSmartAiProviderError, SmartAiProviderError } from './smartai.providers.error.js';
+import type {
+  IOpenAiChatGptOAuthCredential,
+  IOpenAiProviderAdapterOptions,
+  ISmartAiProviderAccountSummary,
+  ISmartAiProviderAccountRateLimits,
+  ISmartAiProviderAdapter,
+  ISmartAiProviderApiKeyCredential,
+  ISmartAiProviderDescriptor,
+  ISmartAiProviderLoginHandle,
+  ISmartAiProviderLoginOptions,
+  ISmartAiProviderLoginResult,
+  ISmartAiProviderModel,
+  ISmartAiProviderModelListOptions,
+  ISmartAiProviderOperationOptions,
+  ISmartAiProviderRateLimitDetails,
+  ISmartAiProviderRateLimitWindow,
+  TSmartAiProviderCancelStatus,
+  TSmartAiProviderAccountRateLimitsResult,
+  TSmartAiProviderCredential,
+  TSmartAiProviderModelListResult,
+  TSmartAiProviderRefreshResult,
+} from './smartai.providers.interfaces.js';
+import type { IOpenAiChatGptTokenData } from '@modelprofile.com/flexharness-providers/auth';
+
+const defaultBrowserLoginTimeoutMs = 11 * 60 * 1000;
+const defaultDeviceLoginTimeoutMs = 15 * 60 * 1000;
+const defaultOperationTimeoutMs = 30_000;
+const maximumOperationTimeoutMs = 20 * 60 * 1000;
+const maximumCatalogBytes = 2 * 1024 * 1024;
+const maximumAccountRateLimitsBytes = 256 * 1024;
+const maximumCatalogModels = 256;
+const maximumAdditionalRateLimits = 128;
+const maximumCursorBytes = 4096;
+const maximumModelPageSize = 50;
+const defaultClientVersion = '0.146.1';
+const maximumHeaderBytes = 16 * 1024;
+const maximumCallbackUrlBytes = 4096;
+const accountRateLimitsUrl = 'https://chatgpt.com/backend-api/wham/usage';
+
+interface IOperation {
+  controller: AbortController;
+  signal: AbortSignal;
+  readonly timedOut: boolean;
+  cleanup(): void;
+}
+
+interface ISharedRefresh {
+  controller: AbortController;
+  promise: Promise<TSmartAiProviderRefreshResult>;
+  waiters: number;
+  settled: boolean;
+}
+
+interface IBrowserCallbackServer {
+  port: number;
+  waitForCallback(
+    authorization: Awaited<ReturnType<typeof createOpenAiChatGptBrowserAuthorization>>,
+  ): Promise<string>;
+  close(): Promise<void>;
+}
+
+interface ICursorPayload {
+  version: 1;
+  projectionVersion: 1;
+  digest: string;
+  includeHidden: boolean;
+  offset: number;
+}
+
+class ModelHttpError extends Error {
+  constructor(public readonly status: number) {
+    super('Model catalog request failed.');
+  }
+}
+
+class AccountRateLimitsHttpError extends Error {
+  constructor(public readonly status: number) {
+    super('Account rate-limits request failed.');
+  }
+}
+
+const isRecord = (valueArg: unknown): valueArg is Record<string, unknown> =>
+  typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+
+const boundedString = (
+  valueArg: unknown,
+  maximumBytesArg: number,
+  allowEmptyArg = false,
+): string => {
+  if (
+    typeof valueArg !== 'string'
+    || (!allowEmptyArg && valueArg.length === 0)
+    || plugins.Buffer.byteLength(valueArg, 'utf8') > maximumBytesArg
+  ) {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  return valueArg;
+};
+
+const createOperation = (
+  optionsArg: ISmartAiProviderOperationOptions,
+  defaultTimeoutMsArg: number,
+): IOperation => {
+  const timeoutMs = optionsArg.timeoutMs ?? defaultTimeoutMsArg;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > maximumOperationTimeoutMs) {
+    throw createSmartAiProviderError('INVALID_ARGUMENT');
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  const onExternalAbort = (): void => controller.abort();
+  optionsArg.signal?.addEventListener('abort', onExternalAbort, { once: true });
+  if (optionsArg.signal?.aborted) controller.abort();
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  return {
+    controller,
+    signal: controller.signal,
+    get timedOut() {
+      return timedOut;
+    },
+    cleanup: () => {
+      clearTimeout(timer);
+      optionsArg.signal?.removeEventListener('abort', onExternalAbort);
+    },
+  };
+};
+
+const classifyOperationError = <TFallback extends
+  | 'ACCOUNT_RATE_LIMITS_FAILED'
+  | 'LOGIN_FAILED'
+  | 'MODEL_LIST_FAILED'
+  | 'REFRESH_FAILED'>(
+  errorArg: unknown,
+  operationArg: IOperation,
+  fallbackArg: TFallback,
+): 'ABORTED' | 'TIMEOUT' | TFallback => {
+  if (operationArg.timedOut) return 'TIMEOUT';
+  if (operationArg.signal.aborted) return 'ABORTED';
+  if (errorArg instanceof SmartAiProviderError && errorArg.code === 'ABORTED') return 'ABORTED';
+  if (errorArg instanceof SmartAiProviderError && errorArg.code === 'TIMEOUT') return 'TIMEOUT';
+  return fallbackArg;
+};
+
+const toTokenData = (credentialArg: IOpenAiChatGptOAuthCredential): IOpenAiChatGptTokenData => {
+  if (
+    credentialArg.kind !== 'chatgptOAuth'
+    || credentialArg.providerId !== 'openai'
+    || !credentialArg.accessToken
+    || !credentialArg.refreshToken
+    || !credentialArg.idToken
+  ) {
+    throw createSmartAiProviderError('CREDENTIAL_INVALID');
+  }
+  let tokenInfo;
+  try {
+    tokenInfo = parseOpenAiChatGptTokenInfo(credentialArg.idToken);
+  } catch {
+    throw createSmartAiProviderError('CREDENTIAL_INVALID');
+  }
+  return {
+    accessToken: credentialArg.accessToken,
+    refreshToken: credentialArg.refreshToken,
+    idToken: credentialArg.idToken,
+    accountId: tokenInfo.chatgptAccountId,
+    tokenInfo,
+  };
+};
+
+const toCredential = (
+  tokenDataArg: IOpenAiChatGptTokenData,
+  lastRefreshAtArg?: string,
+): IOpenAiChatGptOAuthCredential => {
+  if (!tokenDataArg.idToken) throw createSmartAiProviderError('CREDENTIAL_INVALID');
+  return {
+    kind: 'chatgptOAuth',
+    providerId: 'openai',
+    accessToken: tokenDataArg.accessToken,
+    refreshToken: tokenDataArg.refreshToken,
+    idToken: tokenDataArg.idToken,
+    ...(lastRefreshAtArg === undefined ? {} : { lastRefreshAt: lastRefreshAtArg }),
+  };
+};
+
+const toSummary = (
+  credentialArg: IOpenAiChatGptOAuthCredential,
+): ISmartAiProviderAccountSummary => {
+  const tokenData = toTokenData(credentialArg);
+  return {
+    providerId: 'openai',
+    authKind: 'chatgptOAuth',
+    ...(tokenData.tokenInfo.chatgptAccountId
+      ? { accountId: tokenData.tokenInfo.chatgptAccountId }
+      : {}),
+    ...(tokenData.tokenInfo.email ? { email: tokenData.tokenInfo.email } : {}),
+    ...(tokenData.tokenInfo.chatgptPlanType ? { plan: tokenData.tokenInfo.chatgptPlanType } : {}),
+  };
+};
+
+const closeServer = async (
+  serverArg: plugins.Server,
+  socketsArg: Set<plugins.Socket>,
+): Promise<void> => {
+  await new Promise<void>((resolve, reject) => {
+    if (!serverArg.listening) {
+      resolve();
+      return;
+    }
+    serverArg.close((errorArg) => {
+      if ((errorArg as NodeJS.ErrnoException | undefined)?.code === 'ERR_SERVER_NOT_RUNNING') {
+        resolve();
+      } else if (errorArg) {
+        reject(errorArg);
+      } else {
+        resolve();
+      }
+    });
+    for (const socket of socketsArg) socket.destroy();
+  });
+};
+
+const bindBrowserCallbackServer = async (
+  portsArg: readonly number[],
+  signalArg: AbortSignal,
+): Promise<IBrowserCallbackServer> => {
+  if (
+    portsArg.length === 0
+    || portsArg.some((port) => !Number.isSafeInteger(port) || port < 1 || port > 65535)
+  ) {
+    throw createSmartAiProviderError('INVALID_ARGUMENT');
+  }
+  let lastError: unknown;
+  for (let index = 0; index < portsArg.length; index++) {
+    const port = portsArg[index];
+    const sockets = new Set<plugins.Socket>();
+    let authorization: Awaited<ReturnType<typeof createOpenAiChatGptBrowserAuthorization>> | undefined;
+    let settled = false;
+    let resolveCallback!: (url: string) => void;
+    let rejectCallback!: (error: SmartAiProviderError) => void;
+    const callback = new Promise<string>((resolve, reject) => {
+      resolveCallback = resolve;
+      rejectCallback = reject;
+    });
+    void callback.catch(() => undefined);
+    const server = plugins.http.createServer({ maxHeaderSize: maximumHeaderBytes }, (request, response) => {
+      const rejectRequest = (status: number): void => {
+        response.writeHead(status, {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Cache-Control': 'no-store',
+          'X-Content-Type-Options': 'nosniff',
+        });
+        response.end('OpenAI login callback rejected.');
+      };
+      const host = request.headers.host;
+      const requestUrl = request.url;
+      const headerBytes = request.rawHeaders.reduce(
+        (total, entry) => total + plugins.Buffer.byteLength(entry, 'utf8'),
+        0,
+      );
+      if (
+        settled
+        || !authorization
+        || request.method !== 'GET'
+        || host !== `localhost:${port}`
+        || typeof requestUrl !== 'string'
+        || plugins.Buffer.byteLength(requestUrl, 'utf8') > maximumCallbackUrlBytes
+        || headerBytes > maximumHeaderBytes
+      ) {
+        rejectRequest(settled ? 410 : 400);
+        return;
+      }
+      const callbackUrl = `http://${host}${requestUrl}`;
+      let providerDenied = false;
+      try {
+        const callback = parseOpenAiChatGptBrowserCallback(callbackUrl, {
+          expectedState: authorization.state,
+          expectedRedirectUri: authorization.redirectUri,
+        });
+        providerDenied = 'providerError' in callback;
+      } catch {
+        rejectRequest(400);
+        return;
+      }
+      settled = true;
+      response.writeHead(200, {
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+      });
+      response.end(providerDenied
+        ? 'OpenAI login was not authorized. You may close this window.'
+        : 'OpenAI login completed. You may close this window.');
+      resolveCallback(callbackUrl);
+    });
+    server.on('connection', (socket) => {
+      sockets.add(socket);
+      socket.once('close', () => sockets.delete(socket));
+    });
+    let serverClosePromise: Promise<void> | undefined;
+    const ensureServerClosed = (): Promise<void> => {
+      if (!serverClosePromise) {
+        serverClosePromise = closeServer(server, sockets).finally(() => {
+          serverClosePromise = undefined;
+        });
+      }
+      return serverClosePromise;
+    };
+    const onAbort = (): void => {
+      if (!settled) {
+        settled = true;
+        rejectCallback(createSmartAiProviderError('ABORTED'));
+      }
+      void ensureServerClosed().catch(() => undefined);
+    };
+    signalArg.addEventListener('abort', onAbort, { once: true });
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const onError = (errorArg: Error): void => {
+          server.removeListener('listening', onListening);
+          reject(errorArg);
+        };
+        const onListening = (): void => {
+          server.removeListener('error', onError);
+          resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, '127.0.0.1');
+      });
+      if (signalArg.aborted) onAbort();
+      return {
+        port,
+        waitForCallback: async (authorizationArg) => {
+          authorization = authorizationArg;
+          return callback;
+        },
+        close: async () => {
+          signalArg.removeEventListener('abort', onAbort);
+          if (!settled) {
+            settled = true;
+            rejectCallback(createSmartAiProviderError('LOGIN_CANCELED'));
+          }
+          await ensureServerClosed();
+        },
+      };
+    } catch (errorArg) {
+      signalArg.removeEventListener('abort', onAbort);
+      await ensureServerClosed().catch(() => undefined);
+      lastError = errorArg;
+      const code = (errorArg as NodeJS.ErrnoException).code;
+      if (code !== 'EADDRINUSE' || index === portsArg.length - 1) break;
+    }
+  }
+  throw createSmartAiProviderError(
+    (lastError as NodeJS.ErrnoException | undefined)?.code === 'EADDRINUSE'
+      ? 'LOGIN_BUSY'
+      : 'LOGIN_FAILED',
+  );
+};
+
+class OpenAiProviderLoginHandle implements ISmartAiProviderLoginHandle {
+  public readonly completion: Promise<ISmartAiProviderLoginResult>;
+  private closePromise?: Promise<void>;
+  private done = false;
+
+  constructor(
+    public readonly prompt: ISmartAiProviderLoginHandle['prompt'],
+    completionArg: Promise<ISmartAiProviderLoginResult>,
+    private readonly abortController: AbortController,
+    private readonly cleanup: () => Promise<void>,
+    private readonly onDone: () => void,
+  ) {
+    this.completion = completionArg.finally(async () => {
+      this.done = true;
+      try {
+        await this.cleanup();
+      } finally {
+        this.onDone();
+      }
+    });
+    void this.completion.catch(() => undefined);
+  }
+
+  public async cancel(): Promise<TSmartAiProviderCancelStatus> {
+    if (this.done || this.abortController.signal.aborted) return 'notFound';
+    this.abortController.abort();
+    return 'canceled';
+  }
+
+  public async close(): Promise<void> {
+    if (this.closePromise) return this.closePromise;
+    const closeAttempt = (async () => {
+      await this.cancel();
+      await this.completion.catch(() => undefined);
+      await this.cleanup();
+    })();
+    this.closePromise = closeAttempt;
+    try {
+      await closeAttempt;
+    } catch (error) {
+      this.closePromise = undefined;
+      throw error;
+    }
+  }
+}
+
+const normalizeModelListOptions = (
+  optionsArg: ISmartAiProviderModelListOptions,
+): Required<Pick<ISmartAiProviderModelListOptions, 'limit' | 'includeHidden'>>
+  & ISmartAiProviderModelListOptions => {
+  const limit = optionsArg.limit ?? maximumModelPageSize;
+  if (
+    !Number.isSafeInteger(limit)
+    || limit < 1
+    || limit > maximumModelPageSize
+    || (optionsArg.cursor !== undefined
+      && (optionsArg.cursor.length === 0
+        || plugins.Buffer.byteLength(optionsArg.cursor, 'utf8') > maximumCursorBytes))
+    || (optionsArg.includeHidden !== undefined && typeof optionsArg.includeHidden !== 'boolean')
+  ) {
+    throw createSmartAiProviderError('INVALID_ARGUMENT');
+  }
+  return { ...optionsArg, limit, includeHidden: optionsArg.includeHidden ?? false };
+};
+
+const readBoundedJson = async (
+  responseArg: Response,
+  signalArg: AbortSignal,
+  maximumBytesArg: number,
+): Promise<unknown> => {
+  const declared = responseArg.headers.get('content-length');
+  if (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > maximumBytesArg)) {
+    await responseArg.body?.cancel().catch(() => undefined);
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  if (!responseArg.body) throw createSmartAiProviderError('PROTOCOL_ERROR');
+  const reader = responseArg.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  let completed = false;
+  const onAbort = (): void => {
+    void reader.cancel().catch(() => undefined);
+  };
+  signalArg.addEventListener('abort', onAbort, { once: true });
+  if (signalArg.aborted) onAbort();
+  try {
+    while (true) {
+      if (signalArg.aborted) throw createSmartAiProviderError('ABORTED');
+      const { done, value } = await reader.read();
+      if (signalArg.aborted) throw createSmartAiProviderError('ABORTED');
+      if (done) break;
+      size += value.byteLength;
+      if (size > maximumBytesArg) {
+        await reader.cancel().catch(() => undefined);
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+      }
+      chunks.push(value);
+    }
+    completed = true;
+  } finally {
+    signalArg.removeEventListener('abort', onAbort);
+    if (!completed) void reader.cancel().catch(() => undefined);
+    reader.releaseLock();
+  }
+  const body = plugins.Buffer.allocUnsafe(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(body.toString('utf8')) as unknown;
+  } catch {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+};
+
+const boundedInteger = (
+  valueArg: unknown,
+  minimumArg: number,
+  maximumArg = Number.MAX_SAFE_INTEGER,
+): number => {
+  if (
+    !Number.isSafeInteger(valueArg)
+    || (valueArg as number) < minimumArg
+    || (valueArg as number) > maximumArg
+  ) {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  return valueArg as number;
+};
+
+const projectRateLimitWindow = (
+  valueArg: unknown,
+): ISmartAiProviderRateLimitWindow => {
+  if (!isRecord(valueArg)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+  return {
+    usedPercent: boundedInteger(valueArg.used_percent, 0, 100),
+    limitWindowSeconds: boundedInteger(valueArg.limit_window_seconds, 1),
+    resetAfterSeconds: boundedInteger(valueArg.reset_after_seconds, 0),
+    resetsAt: boundedInteger(valueArg.reset_at, 0),
+  };
+};
+
+const projectRateLimitDetails = (valueArg: unknown): ISmartAiProviderRateLimitDetails => {
+  if (
+    !isRecord(valueArg)
+    || typeof valueArg.allowed !== 'boolean'
+    || typeof valueArg.limit_reached !== 'boolean'
+  ) {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  return {
+    allowed: valueArg.allowed,
+    limitReached: valueArg.limit_reached,
+    ...(valueArg.primary_window === null || valueArg.primary_window === undefined
+      ? {}
+      : { primaryWindow: projectRateLimitWindow(valueArg.primary_window) }),
+    ...(valueArg.secondary_window === null || valueArg.secondary_window === undefined
+      ? {}
+      : { secondaryWindow: projectRateLimitWindow(valueArg.secondary_window) }),
+  };
+};
+
+const projectAccountRateLimits = (
+  valueArg: unknown,
+  observedAtArg: string,
+): ISmartAiProviderAccountRateLimits => {
+  if (!isRecord(valueArg)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+  const rawAdditionalRateLimits = valueArg.additional_rate_limits ?? [];
+  if (
+    !Array.isArray(rawAdditionalRateLimits)
+    || rawAdditionalRateLimits.length > maximumAdditionalRateLimits
+  ) {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  const additionalRateLimits = rawAdditionalRateLimits.map((rawLimit) => {
+    if (!isRecord(rawLimit)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+    return {
+      limitName: boundedString(rawLimit.limit_name, 256),
+      meteredFeature: boundedString(rawLimit.metered_feature, 256),
+      ...(rawLimit.rate_limit === null || rawLimit.rate_limit === undefined
+        ? {}
+        : { rateLimit: projectRateLimitDetails(rawLimit.rate_limit) }),
+    };
+  });
+  let rateLimitReachedType: string | undefined;
+  if (valueArg.rate_limit_reached_type !== null && valueArg.rate_limit_reached_type !== undefined) {
+    if (!isRecord(valueArg.rate_limit_reached_type)) {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    rateLimitReachedType = boundedString(valueArg.rate_limit_reached_type.type, 256);
+  }
+  let rateLimitResetCreditsAvailableCount: number | undefined;
+  if (valueArg.rate_limit_reset_credits !== null && valueArg.rate_limit_reset_credits !== undefined) {
+    if (!isRecord(valueArg.rate_limit_reset_credits)) {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    rateLimitResetCreditsAvailableCount = boundedInteger(
+      valueArg.rate_limit_reset_credits.available_count,
+      0,
+    );
+  }
+  return {
+    providerId: 'openai',
+    plan: boundedString(valueArg.plan_type, 256),
+    observedAt: observedAtArg,
+    ...(valueArg.rate_limit === null || valueArg.rate_limit === undefined
+      ? {}
+      : { rateLimit: projectRateLimitDetails(valueArg.rate_limit) }),
+    additionalRateLimits,
+    ...(rateLimitReachedType === undefined ? {} : { rateLimitReachedType }),
+    ...(rateLimitResetCreditsAvailableCount === undefined
+      ? {}
+      : { rateLimitResetCreditsAvailableCount }),
+  };
+};
+
+const projectCatalog = (valueArg: unknown): ISmartAiProviderModel[] => {
+  if (!isRecord(valueArg) || !Array.isArray(valueArg.models) || valueArg.models.length > maximumCatalogModels) {
+    throw createSmartAiProviderError('PROTOCOL_ERROR');
+  }
+  const modelIds = new Set<string>();
+  const entries = valueArg.models.map((rawModel, sourceIndex) => {
+    if (!isRecord(rawModel)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+    const modelId = boundedString(rawModel.slug, 256);
+    if (modelIds.has(modelId)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+    modelIds.add(modelId);
+    const visibility = rawModel.visibility;
+    if (visibility !== 'list' && visibility !== 'hide' && visibility !== 'none') {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    if (!Number.isSafeInteger(rawModel.priority)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+    if (!Array.isArray(rawModel.supported_reasoning_levels) || rawModel.supported_reasoning_levels.length > 16) {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    const reasoningEfforts = rawModel.supported_reasoning_levels.map((rawEffort) => {
+      if (!isRecord(rawEffort)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+      return {
+        effort: boundedString(rawEffort.effort, 128),
+        description: boundedString(rawEffort.description, 1024, true),
+      };
+    });
+    const modalities = rawModel.input_modalities ?? ['text', 'image'];
+    if (
+      !Array.isArray(modalities)
+      || modalities.length > 3
+      || modalities.some((entry) => entry !== 'text' && entry !== 'image' && entry !== 'audio')
+      || new Set(modalities).size !== modalities.length
+    ) {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    const rawServiceTiers = rawModel.service_tiers ?? [];
+    if (!Array.isArray(rawServiceTiers) || rawServiceTiers.length > 16) {
+      throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    const serviceTiers = rawServiceTiers.map((rawTier) => {
+      if (!isRecord(rawTier)) throw createSmartAiProviderError('PROTOCOL_ERROR');
+      return {
+        id: boundedString(rawTier.id, 128),
+        name: boundedString(rawTier.name, 256),
+        description: boundedString(rawTier.description, 1024, true),
+      };
+    });
+    const modelMessages = isRecord(rawModel.model_messages) ? rawModel.model_messages : undefined;
+    const variables = isRecord(modelMessages?.instructions_variables)
+      ? modelMessages.instructions_variables
+      : undefined;
+    const supportsPersonality = typeof modelMessages?.instructions_template === 'string'
+      && modelMessages.instructions_template.includes('{{ personality }}')
+      && typeof variables?.personality_default === 'string'
+      && typeof variables.personality_friendly === 'string'
+      && typeof variables.personality_pragmatic === 'string';
+    return {
+      priority: rawModel.priority as number,
+      sourceIndex,
+      model: {
+        providerId: 'openai' as const,
+        modelId,
+        wireModel: modelId,
+        displayName: boundedString(rawModel.display_name, 512),
+        description: rawModel.description === null || rawModel.description === undefined
+          ? ''
+          : boundedString(rawModel.description, 4096, true),
+        hidden: visibility !== 'list',
+        reasoningEfforts,
+        defaultReasoningEffort: rawModel.default_reasoning_level === null
+          || rawModel.default_reasoning_level === undefined
+          ? 'none'
+          : boundedString(rawModel.default_reasoning_level, 128),
+        inputModalities: modalities as ISmartAiProviderModel['inputModalities'],
+        supportsPersonality,
+        serviceTiers,
+        ...(rawModel.default_service_tier === null || rawModel.default_service_tier === undefined
+          ? {}
+          : { defaultServiceTier: boundedString(rawModel.default_service_tier, 128) }),
+        isDefault: false,
+      },
+    };
+  });
+  entries.sort((left, right) => left.priority - right.priority || left.sourceIndex - right.sourceIndex);
+  const models = entries.map((entry) => entry.model);
+  const defaultModel = models.find((model) => !model.hidden) ?? models[0];
+  if (defaultModel) defaultModel.isDefault = true;
+  return models;
+};
+
+export class OpenAiProviderAdapter implements ISmartAiProviderAdapter {
+  public readonly descriptor: ISmartAiProviderDescriptor = {
+    providerId: 'openai',
+    displayName: 'OpenAI',
+    loginFlows: ['browser', 'device'],
+    supportsApiKey: true,
+  };
+
+  private readonly fetchImplementation: typeof fetch;
+  private readonly originator: string;
+  private readonly now: () => Date;
+  private readonly cursorKey = plugins.crypto.randomBytes(32);
+  private readonly handles = new Set<OpenAiProviderLoginHandle>();
+  private readonly operations = new Set<AbortController>();
+  private readonly refreshes = new Map<string, ISharedRefresh>();
+  private closed = false;
+  private disposePromise?: Promise<void>;
+
+  constructor(optionsArg: IOpenAiProviderAdapterOptions = {}) {
+    this.fetchImplementation = optionsArg.fetch ?? globalThis.fetch;
+    if (!this.fetchImplementation) throw createSmartAiProviderError('INVALID_ARGUMENT');
+    this.originator = optionsArg.originator ?? OPENAI_CHATGPT_DEFAULT_ORIGINATOR;
+    this.now = optionsArg.now ?? (() => new Date());
+  }
+
+  private requireOpen(): void {
+    if (this.closed) throw createSmartAiProviderError('CLOSED');
+  }
+
+  private authOptions(signalArg: AbortSignal) {
+    return {
+      fetch: this.fetchImplementation,
+      signal: signalArg,
+      safeErrors: true,
+    } as const;
+  }
+
+  public createApiKeyCredential(apiKeyArg: string): ISmartAiProviderApiKeyCredential {
+    this.requireOpen();
+    if (typeof apiKeyArg !== 'string' || apiKeyArg.length === 0) {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    return { kind: 'apiKey', providerId: 'openai', apiKey: apiKeyArg };
+  }
+
+  public inspectCredential(
+    credentialArg: TSmartAiProviderCredential,
+  ): ISmartAiProviderAccountSummary {
+    this.requireOpen();
+    if (credentialArg.kind === 'apiKey') {
+      if (credentialArg.providerId !== 'openai' || !credentialArg.apiKey) {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+      }
+      return { providerId: 'openai', authKind: 'apiKey' };
+    }
+    return toSummary(credentialArg);
+  }
+
+  public async beginLogin(
+    optionsArg: ISmartAiProviderLoginOptions,
+  ): Promise<ISmartAiProviderLoginHandle> {
+    this.requireOpen();
+    if (optionsArg.flow !== 'browser' && optionsArg.flow !== 'device') {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    const defaultTimeoutMs = optionsArg.flow === 'browser'
+      ? defaultBrowserLoginTimeoutMs
+      : defaultDeviceLoginTimeoutMs;
+    if (
+      optionsArg.flow === 'device'
+      && (optionsArg.timeoutMs ?? defaultTimeoutMs) > defaultDeviceLoginTimeoutMs
+    ) {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    const operation = createOperation(optionsArg, defaultTimeoutMs);
+    const abortController = operation.controller;
+    this.operations.add(abortController);
+    const timeoutMs = optionsArg.timeoutMs ?? defaultTimeoutMs;
+    let callbackServer: IBrowserCallbackServer | undefined;
+    const cleanup = async (): Promise<void> => {
+      this.operations.delete(abortController);
+      operation.cleanup();
+      await callbackServer?.close();
+    };
+    try {
+      let prompt: ISmartAiProviderLoginHandle['prompt'];
+      let completion: Promise<ISmartAiProviderLoginResult>;
+      if (optionsArg.flow === 'device') {
+        const deviceCode = await requestOpenAiChatGptDeviceCode(this.authOptions(abortController.signal));
+        prompt = {
+          flow: 'device',
+          verificationUrl: deviceCode.verificationUrl,
+          userCode: deviceCode.userCode,
+        };
+        completion = completeOpenAiChatGptDeviceCodeLogin(deviceCode, {
+          ...this.authOptions(abortController.signal),
+          timeoutMs,
+        }).then((tokenData) => {
+          const credential = toCredential(tokenData);
+          return { credential, account: toSummary(credential) };
+        });
+      } else {
+        callbackServer = await bindBrowserCallbackServer([1455, 1457], abortController.signal);
+        const authorization = await createOpenAiChatGptBrowserAuthorization({
+          ...this.authOptions(abortController.signal),
+          redirectUri: `http://localhost:${callbackServer.port}/auth/callback`,
+          originator: this.originator,
+        });
+        prompt = { flow: 'browser', authUrl: authorization.authUrl };
+        completion = callbackServer.waitForCallback(authorization).then(async (callbackUrl) => {
+          const callback = parseOpenAiChatGptBrowserCallback(callbackUrl, {
+            expectedState: authorization.state,
+            expectedRedirectUri: authorization.redirectUri,
+          });
+          if ('providerError' in callback) {
+            throw createSmartAiProviderError('LOGIN_CANCELED');
+          }
+          const tokenData = await exchangeOpenAiChatGptBrowserAuthorizationCode(
+            callback.authorizationCode,
+            {
+              ...this.authOptions(abortController.signal),
+              redirectUri: authorization.redirectUri,
+              codeVerifier: authorization.codeVerifier,
+            },
+          );
+          const credential = toCredential(tokenData);
+          return { credential, account: toSummary(credential) };
+        });
+      }
+      this.requireOpen();
+      if (abortController.signal.aborted) throw createSmartAiProviderError('ABORTED');
+      const handle = new OpenAiProviderLoginHandle(
+        prompt,
+        completion.catch((errorArg) => {
+          if (operation.timedOut) throw createSmartAiProviderError('TIMEOUT');
+          if (optionsArg.signal?.aborted) throw createSmartAiProviderError('ABORTED');
+          if (abortController.signal.aborted) throw createSmartAiProviderError('LOGIN_CANCELED');
+          if (errorArg instanceof SmartAiProviderError) throw errorArg;
+          throw createSmartAiProviderError('LOGIN_FAILED');
+        }),
+        abortController,
+        cleanup,
+        () => this.handles.delete(handle),
+      );
+      this.handles.add(handle);
+      return handle;
+    } catch (errorArg) {
+      abortController.abort();
+      await cleanup().catch(() => undefined);
+      if (operation.timedOut) throw createSmartAiProviderError('TIMEOUT');
+      if (optionsArg.signal?.aborted) throw createSmartAiProviderError('ABORTED');
+      if (errorArg instanceof SmartAiProviderError) throw errorArg;
+      throw createSmartAiProviderError('LOGIN_FAILED');
+    }
+  }
+
+  public async refreshCredential(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    optionsArg: ISmartAiProviderOperationOptions = {},
+  ): Promise<TSmartAiProviderRefreshResult> {
+    this.requireOpen();
+    toTokenData(credentialArg);
+    const waitOperation = createOperation(optionsArg, defaultOperationTimeoutMs);
+    if (waitOperation.signal.aborted) {
+      const failure: TSmartAiProviderRefreshResult = {
+        success: false,
+        credential: credentialArg,
+        errorCode: waitOperation.timedOut ? 'TIMEOUT' : 'ABORTED',
+      };
+      waitOperation.cleanup();
+      return failure;
+    }
+    let sharedRefresh: ISharedRefresh | undefined;
+    let joinedRefresh = false;
+    let onAbort: (() => void) | undefined;
+    try {
+      const refreshKey = plugins.crypto.createHash('sha256')
+        .update(credentialArg.refreshToken, 'utf8')
+        .digest('base64url');
+      sharedRefresh = this.refreshes.get(refreshKey);
+      if (!sharedRefresh) {
+        const controller = new AbortController();
+        let createdRefresh!: ISharedRefresh;
+        const promise = this.performRefreshCredential(credentialArg, {
+          signal: controller.signal,
+        }).finally(() => {
+          createdRefresh.settled = true;
+          if (this.refreshes.get(refreshKey) === createdRefresh) {
+            this.refreshes.delete(refreshKey);
+          }
+        });
+        createdRefresh = {
+          controller,
+          promise,
+          waiters: 0,
+          settled: false,
+        };
+        this.refreshes.set(refreshKey, createdRefresh);
+        sharedRefresh = createdRefresh;
+      }
+      sharedRefresh.waiters++;
+      joinedRefresh = true;
+      const aborted = new Promise<TSmartAiProviderRefreshResult>((resolve) => {
+        onAbort = () => resolve({
+          success: false,
+          credential: credentialArg,
+          errorCode: waitOperation.timedOut ? 'TIMEOUT' : 'ABORTED',
+        });
+        waitOperation.signal.addEventListener('abort', onAbort, { once: true });
+      });
+      return await Promise.race([sharedRefresh.promise, aborted]);
+    } finally {
+      if (onAbort) waitOperation.signal.removeEventListener('abort', onAbort);
+      waitOperation.cleanup();
+      if (sharedRefresh && joinedRefresh) sharedRefresh.waiters--;
+      if (sharedRefresh && joinedRefresh && sharedRefresh.waiters === 0 && !sharedRefresh.settled) {
+        sharedRefresh.controller.abort();
+      }
+    }
+  }
+
+  private async performRefreshCredential(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    optionsArg: ISmartAiProviderOperationOptions,
+  ): Promise<TSmartAiProviderRefreshResult> {
+    const input = toTokenData(credentialArg);
+    const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+    this.operations.add(operation.controller);
+    try {
+      const refreshed = await refreshOpenAiChatGptTokenData(input, this.authOptions(operation.signal));
+      const tokenChanged = refreshed.accessToken !== input.accessToken
+        || refreshed.refreshToken !== input.refreshToken;
+      if (!tokenChanged || !refreshed.idToken) {
+        return { success: false, credential: credentialArg, errorCode: 'REFRESH_FAILED' };
+      }
+      const previous = credentialArg.lastRefreshAt === undefined
+        ? 0
+        : Date.parse(credentialArg.lastRefreshAt);
+      const now = this.now().getTime();
+      const lastRefreshAt = new Date(Math.max(now, Number.isFinite(previous) ? previous + 1 : now))
+        .toISOString();
+      const credential = toCredential(refreshed, lastRefreshAt);
+      return { success: true, credential, account: toSummary(credential) };
+    } catch (errorArg) {
+      return {
+        success: false,
+        credential: credentialArg,
+        errorCode: classifyOperationError(errorArg, operation, 'REFRESH_FAILED'),
+      };
+    } finally {
+      this.operations.delete(operation.controller);
+      operation.cleanup();
+    }
+  }
+
+  private async fetchCatalog(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    signalArg: AbortSignal,
+  ): Promise<ISmartAiProviderModel[]> {
+    const tokenData = toTokenData(credentialArg);
+    const accountId = tokenData.tokenInfo.chatgptAccountId;
+    const url = `${OPENAI_CHATGPT_CODEX_BASE_URL}/models?client_version=${encodeURIComponent(defaultClientVersion)}`;
+    let response: Response;
+    let onAbort!: () => void;
+    try {
+      const fetchPromise = this.fetchImplementation(url, {
+        method: 'GET',
+        redirect: 'error',
+        signal: signalArg,
+        headers: {
+          Accept: 'application/json',
+          Authorization: `Bearer ${credentialArg.accessToken}`,
+          ...(accountId ? { 'ChatGPT-Account-ID': accountId } : {}),
+          ...(tokenData.tokenInfo.chatgptAccountIsFedramp ? { 'X-OpenAI-Fedramp': 'true' } : {}),
+          originator: this.originator,
+          version: defaultClientVersion,
+        },
+      });
+      void fetchPromise.then((lateResponse) => {
+        if (signalArg.aborted) void lateResponse.body?.cancel().catch(() => undefined);
+      }).catch(() => undefined);
+      const aborted = new Promise<never>((_resolve, reject) => {
+        onAbort = () => reject(createSmartAiProviderError('ABORTED'));
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        if (signalArg.aborted) onAbort();
+      });
+      response = await Promise.race([fetchPromise, aborted]);
+    } catch {
+      if (signalArg.aborted) throw createSmartAiProviderError('ABORTED');
+      throw createSmartAiProviderError('NETWORK_FAILED');
+    } finally {
+      if (onAbort) signalArg.removeEventListener('abort', onAbort);
+    }
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => undefined);
+      throw new ModelHttpError(response.status);
+    }
+    return projectCatalog(await readBoundedJson(response, signalArg, maximumCatalogBytes));
+  }
+
+  private encodeCursor(payloadArg: ICursorPayload): string {
+    const body = plugins.Buffer.from(JSON.stringify(payloadArg), 'utf8').toString('base64url');
+    const mac = plugins.crypto.createHmac('sha256', this.cursorKey).update(body, 'ascii').digest('base64url');
+    return `v1.${body}.${mac}`;
+  }
+
+  private decodeCursor(cursorArg: string): ICursorPayload {
+    const parts = cursorArg.split('.');
+    if (parts.length !== 3 || parts[0] !== 'v1') {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    const expectedMac = plugins.crypto.createHmac('sha256', this.cursorKey)
+      .update(parts[1], 'ascii')
+      .digest();
+    let actualMac: plugins.Buffer;
+    let payload: unknown;
+    try {
+      actualMac = plugins.Buffer.from(parts[2], 'base64url');
+      payload = JSON.parse(plugins.Buffer.from(parts[1], 'base64url').toString('utf8')) as unknown;
+    } catch {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    if (actualMac.byteLength !== expectedMac.byteLength || !plugins.crypto.timingSafeEqual(actualMac, expectedMac)) {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    if (
+      !isRecord(payload)
+      || Object.keys(payload).length !== 5
+      || payload.version !== 1
+      || payload.projectionVersion !== 1
+      || typeof payload.digest !== 'string'
+      || !/^[A-Za-z0-9_-]{43}$/.test(payload.digest)
+      || typeof payload.includeHidden !== 'boolean'
+      || !Number.isSafeInteger(payload.offset)
+      || (payload.offset as number) < 0
+    ) {
+      throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    return payload as unknown as ICursorPayload;
+  }
+
+  public async listModels(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    optionsArg: ISmartAiProviderModelListOptions = {},
+  ): Promise<TSmartAiProviderModelListResult> {
+    this.requireOpen();
+    toTokenData(credentialArg);
+    const options = normalizeModelListOptions(optionsArg);
+    const operation = createOperation(options, defaultOperationTimeoutMs);
+    this.operations.add(operation.controller);
+    try {
+      let catalog: ISmartAiProviderModel[];
+      try {
+        catalog = await this.fetchCatalog(credentialArg, operation.signal);
+      } catch (errorArg) {
+        if (!(errorArg instanceof ModelHttpError) || errorArg.status !== 401) throw errorArg;
+        return { success: false, errorCode: 'CREDENTIAL_REFRESH_REQUIRED' };
+      }
+      const filtered = options.includeHidden ? catalog : catalog.filter((model) => !model.hidden);
+      const digest = plugins.crypto.createHash('sha256').update(JSON.stringify(filtered)).digest('base64url');
+      let offset = 0;
+      if (options.cursor !== undefined) {
+        const cursor = this.decodeCursor(options.cursor);
+        if (
+          cursor.digest !== digest
+          || cursor.includeHidden !== options.includeHidden
+          || cursor.offset > filtered.length
+        ) {
+          throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        offset = cursor.offset;
+      }
+      const models = filtered.slice(offset, offset + options.limit);
+      const nextOffset = offset + models.length;
+      const nextCursor = nextOffset < filtered.length
+        ? this.encodeCursor({
+            version: 1,
+            projectionVersion: 1,
+            digest,
+            includeHidden: options.includeHidden,
+            offset: nextOffset,
+          })
+        : undefined;
+      return {
+        success: true,
+        models,
+        ...(nextCursor === undefined ? {} : { nextCursor }),
+      };
+    } catch (errorArg) {
+      if (errorArg instanceof SmartAiProviderError && errorArg.code === 'INVALID_ARGUMENT') {
+        throw errorArg;
+      }
+      return {
+        success: false,
+        errorCode: classifyOperationError(errorArg, operation, 'MODEL_LIST_FAILED'),
+      };
+    } finally {
+      this.operations.delete(operation.controller);
+      operation.cleanup();
+    }
+  }
+
+  private async fetchAccountRateLimits(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    signalArg: AbortSignal,
+  ): Promise<ISmartAiProviderAccountRateLimits> {
+    const tokenData = toTokenData(credentialArg);
+    const accountId = tokenData.tokenInfo.chatgptAccountId;
+    let response: Response;
+    let onAbort!: () => void;
+    try {
+      const fetchPromise = this.fetchImplementation(accountRateLimitsUrl, {
+        method: 'GET',
+        redirect: 'error',
+        signal: signalArg,
+        headers: {
+          Accept: 'application/json',
+          Authorization: `Bearer ${credentialArg.accessToken}`,
+          ...(accountId ? { 'ChatGPT-Account-Id': accountId } : {}),
+          ...(tokenData.tokenInfo.chatgptAccountIsFedramp ? { 'X-OpenAI-Fedramp': 'true' } : {}),
+          'User-Agent': this.originator,
+        },
+      });
+      void fetchPromise.then((lateResponse) => {
+        if (signalArg.aborted) void lateResponse.body?.cancel().catch(() => undefined);
+      }).catch(() => undefined);
+      const aborted = new Promise<never>((_resolve, reject) => {
+        onAbort = () => reject(createSmartAiProviderError('ABORTED'));
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        if (signalArg.aborted) onAbort();
+      });
+      response = await Promise.race([fetchPromise, aborted]);
+    } catch {
+      if (signalArg.aborted) throw createSmartAiProviderError('ABORTED');
+      throw createSmartAiProviderError('NETWORK_FAILED');
+    } finally {
+      if (onAbort) signalArg.removeEventListener('abort', onAbort);
+    }
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => undefined);
+      throw new AccountRateLimitsHttpError(response.status);
+    }
+    return projectAccountRateLimits(
+      await readBoundedJson(response, signalArg, maximumAccountRateLimitsBytes),
+      this.now().toISOString(),
+    );
+  }
+
+  public async getAccountRateLimits(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    optionsArg: ISmartAiProviderOperationOptions = {},
+  ): Promise<TSmartAiProviderAccountRateLimitsResult> {
+    this.requireOpen();
+    toTokenData(credentialArg);
+    const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+    this.operations.add(operation.controller);
+    try {
+      try {
+        const rateLimits = await this.fetchAccountRateLimits(credentialArg, operation.signal);
+        return { success: true, rateLimits };
+      } catch (errorArg) {
+        if (!(errorArg instanceof AccountRateLimitsHttpError) || errorArg.status !== 401) {
+          throw errorArg;
+        }
+        return { success: false, errorCode: 'CREDENTIAL_REFRESH_REQUIRED' };
+      }
+    } catch (errorArg) {
+      return {
+        success: false,
+        errorCode: classifyOperationError(errorArg, operation, 'ACCOUNT_RATE_LIMITS_FAILED'),
+      };
+    } finally {
+      this.operations.delete(operation.controller);
+      operation.cleanup();
+    }
+  }
+
+  public async logoutCredential(
+    credentialArg: IOpenAiChatGptOAuthCredential,
+    optionsArg: ISmartAiProviderOperationOptions = {},
+  ): Promise<void> {
+    this.requireOpen();
+    toTokenData(credentialArg);
+    const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+    this.operations.add(operation.controller);
+    try {
+      await revokeOpenAiChatGptToken(credentialArg.refreshToken, {
+        ...this.authOptions(operation.signal),
+        tokenTypeHint: 'refresh_token',
+      });
+    } catch {
+      throw createSmartAiProviderError(
+        operation.timedOut ? 'TIMEOUT' : operation.signal.aborted ? 'ABORTED' : 'NETWORK_FAILED',
+      );
+    } finally {
+      this.operations.delete(operation.controller);
+      operation.cleanup();
+    }
+  }
+
+  public async dispose(): Promise<void> {
+    if (this.disposePromise) return this.disposePromise;
+    this.closed = true;
+    const disposeAttempt = (async () => {
+      for (const operation of this.operations) operation.abort();
+      const results = await Promise.allSettled([...this.handles].map((handle) => handle.close()));
+      const operationDeadline = Date.now() + 5_000;
+      while (this.operations.size > 0 && Date.now() < operationDeadline) {
+        await new Promise<void>((resolve) => setTimeout(resolve, 10));
+      }
+      if (results.some((result) => result.status === 'rejected')) {
+        throw createSmartAiProviderError('CLOSED');
+      }
+      if (this.operations.size > 0) throw createSmartAiProviderError('CLOSED');
+      this.handles.clear();
+      this.cursorKey.fill(0);
+    })();
+    this.disposePromise = disposeAttempt;
+    try {
+      await disposeAttempt;
+    } catch (error) {
+      this.disposePromise = undefined;
+      throw error;
+    }
+  }
+}