@oxyhq/services 14.1.0 → 15.0.0

package/src/ui/context/inSessionTokenRefresh.ts

@@ -1,264 +0,0 @@
-/**
- * In-session access-token refresh for the React Native / Expo SDK.
- *
- * THE GAP THIS CLOSES: the services `OxyContext` owns the session but never
- * installed an `authRefreshHandler` on the owner `HttpService`, so
- * `HttpService.refreshAccessToken` short-circuited to `null` — there was NO
- * in-session token refresh on the RN path at all. A 15-minute access token
- * expired with the tab/app open and nothing re-minted one; cross-apex RP feeds
- * (mention.earth, …) then 401'd in a loop while `isAuthenticated` stayed `true`
- * (a zombie logged-in state), because the `Domain=oxy.so` refresh cookie can't
- * reach `api.<apex>`. (`AuthManager`, which installs a refresh handler on the
- * web path, is only ever constructed by `WebOxyProvider` in `@oxyhq/auth`.)
- *
- * THE FIX, two cooperating pieces both wired from `OxyContext`:
- *
- *  1. {@link createInSessionRefreshHandler} — an `AuthRefreshHandler` installed
- *     on the owner client. It re-mints a fresh access token WITHOUT a page
- *     reload by composing the SAME silent-restore primitive cold boot uses
- *     ({@link mintSessionViaPerApexIframe}) — not a copy. The linked client
- *     (`createLinkedClient`) inherits the fix for free: its refresh delegates
- *     back to the owner's `refreshAccessToken`.
- *
- *  2. {@link startTokenRefreshScheduler} — a proactive scheduler that refreshes
- *     ~{@link TOKEN_REFRESH_LEAD_MS} before expiry (and on web tab-focus / native
- *     app-foreground), so the common case never even reaches the reactive
- *     401-then-recover flash.
- *
- * Concurrency/cooldown/dedup are owned by `HttpService.refreshAccessToken`
- * (single in-flight `tokenRefreshPromise` + cooldown) — this module does not
- * reimplement them, so the timer / foreground / per-request triggers collapse to
- * one network attempt (no refresh storm).
- *
- * NOTE (session-sync cutover, Task 5): the web arm chain used to fall through
- * to a same-apex `oxy_rt` refresh-cookie arm (`refreshAllSessions` +
- * `selectActiveRefreshAccount`). That arm is DELETED — the device account set
- * is now server-authoritative via `SessionClient` (`@oxyhq/core`), which
- * `OxyContext` bootstraps/reprojects independently of in-session token
- * refresh. `selectActiveRefreshAccount` had no other caller and was deleted
- * with it.
- */
-import type {
-  OxyServices,
-  AuthRefreshHandler,
-  AuthRefreshReason,
-} from '@oxyhq/core';
-import { logger as loggerUtil } from '@oxyhq/core';
-import { AppState, type AppStateStatus } from 'react-native';
-import { isWebBrowser } from '../hooks/useWebSSO';
-import { mintSessionViaPerApexIframe } from './silentSessionRestore';
-
-/**
- * Per-arm fail-fast budget (ms) for the web first-party `/auth/silent` iframe
- * arm. Slightly more generous than the cold-boot iframe budget (2.5s) because an
- * in-session refresh is NOT in the first-paint critical path — a couple hundred
- * ms of extra headroom for the same-origin handshake is worth a higher success
- * rate. `silentSignIn` still fail-fasts on `iframe.onerror`, so a hard failure
- * returns well before this.
- */
-const SILENT_IFRAME_REFRESH_TIMEOUT = 4000;
-
-/**
- * Lead time (ms) before access-token expiry at which the proactive scheduler
- * refreshes. Mirrors `HttpService`'s per-request `TOKEN_REFRESH_LEAD_SECONDS`
- * (60s) so the scheduled refresh and the request-time preflight refresh use the
- * same window — the scheduler simply fires it during idle/background instead of
- * waiting for the next request.
- */
-export const TOKEN_REFRESH_LEAD_MS = 60_000;
-
-/**
- * A single refresh arm: attempts one silent-restore mechanism and resolves to
- * the freshly planted access token, or `null` to fall through to the next arm.
- */
-type RefreshArm = () => Promise<string | null>;
-
-/**
- * Build the in-session `AuthRefreshHandler` for the owner client.
- *
- * Arms run in an explicit order; the first to plant a token wins. Each arm
- * resolves to the planted token (read back via `getAccessToken()` — the
- * underlying SDK call plants it internally) or `null`. A throw in one arm is
- * logged and treated as `null` so the chain continues.
- *
- *   NATIVE (Expo): shared cross-app identity key re-mint
- *     (`signInWithSharedIdentity` → challenge→sign→verify plants the tokens).
- *     The ONLY silent native arm (mirrors cold boot's `shared-key-signin`); the
- *     `/auth/silent` web iframe is NEVER attempted on native. Resolves to `null`
- *     when the device holds no shared identity (e.g. a password-only native
- *     sign-in) so a genuinely dead session reconciles to logged-out rather than
- *     staying a zombie.
- *
- *   WEB: Per-apex `/auth/silent` iframe — {@link mintSessionViaPerApexIframe}
- *     (shared verbatim with cold boot). The durable cross-apex path; also
- *     covers `*.oxy.so` (the per-apex host IS the central host there). There
- *     is no FedCM arm — FedCM was removed from the client sign-in/refresh path
- *     entirely (Chrome-only; see `CrossDomainAuth`'s doc comment in
- *     `@oxyhq/core` for the production sign-in loop that motivated the
- *     removal).
- *
- * NO RECURSION: no arm issues a request through the authed client's
- * `refreshAccessToken` path. The iframe transport is postMessage-based; the
- * follow-up `/session/user` fetch inside `silentSignIn`
- * runs against the just-planted FULL-TTL token (≫ the preflight lead), so it
- * never re-enters the refresh path.
- */
-export function createInSessionRefreshHandler(oxyServices: OxyServices): AuthRefreshHandler {
-  const runArm = async (label: string, reason: AuthRefreshReason, arm: RefreshArm): Promise<string | null> => {
-    try {
-      return await arm();
-    } catch (error) {
-      if (__DEV__) {
-        loggerUtil.debug(
-          `In-session refresh arm "${label}" failed (falling through)`,
-          { component: 'inSessionTokenRefresh', method: 'authRefreshHandler', reason },
-          error,
-        );
-      }
-      return null;
-    }
-  };
-
-  const webArms: Array<[string, RefreshArm]> = [
-    ['silent-iframe', async () =>
-      (await mintSessionViaPerApexIframe(oxyServices, SILENT_IFRAME_REFRESH_TIMEOUT))
-        ? oxyServices.getAccessToken()
-        : null,
-    ],
-  ];
-
-  return async (reason: AuthRefreshReason): Promise<string | null> => {
-    if (!isWebBrowser()) {
-      return runArm('native-shared-key', reason, async () =>
-        (await oxyServices.signInWithSharedIdentity?.()) ? oxyServices.getAccessToken() : null,
-      );
-    }
-
-    for (const [label, arm] of webArms) {
-      const token = await runArm(label, reason, arm);
-      if (token) {
-        return token;
-      }
-    }
-    return null;
-  };
-}
-
-/**
- * Handle returned by {@link startTokenRefreshScheduler}; call `dispose()` to tear
- * down the timer and the foreground listener.
- */
-export interface TokenRefreshSchedulerHandle {
-  dispose(): void;
-}
-
-/**
- * Start the proactive in-session refresh scheduler against `oxyServices`.
- *
- * Schedules a single timer to fire {@link TOKEN_REFRESH_LEAD_MS} before the
- * current access token's `exp`, calling `httpService.refreshAccessToken`
- * ('preflight') — which runs the installed handler and is deduped + cooldown-
- * guarded. After every attempt it reschedules from the (possibly rotated) token.
- * It also reschedules whenever the token changes (`onTokensChanged` — so a
- * sign-out that clears the token cancels the timer) and, on web tab-focus /
- * native app-foreground, refreshes immediately if already inside the lead window
- * (a long-hidden tab throttles timers, so the token can be expired on return).
- *
- * The `exp` is derived directly from the JWT via `getAccessTokenExpiry()`. No-ops
- * cleanly when there is no token, an opaque/no-`exp` token, or the host lacks
- * `getAccessTokenExpiry` (older stubs) — the reactive 401 path stays the only
- * refresh trigger in those cases.
- */
-export function startTokenRefreshScheduler(oxyServices: OxyServices): TokenRefreshSchedulerHandle {
-  let disposed = false;
-  let timer: ReturnType<typeof setTimeout> | null = null;
-
-  const clearTimer = (): void => {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-
-  const runRefresh = (): void => {
-    // `refreshAccessToken` is deduped + cooldown-guarded internally, so this is
-    // safe to call from the timer, the foreground listener, and request-time
-    // preflight concurrently — they collapse to one network attempt.
-    const refresh = oxyServices.httpService.refreshAccessToken?.('preflight');
-    if (!refresh) {
-      return;
-    }
-    void refresh
-      .catch(() => null)
-      .finally(() => {
-        if (!disposed) {
-          schedule();
-        }
-      });
-  };
-
-  const schedule = (): void => {
-    clearTimer();
-    if (disposed || !oxyServices.getAccessToken()) {
-      return;
-    }
-    const expSeconds = oxyServices.getAccessTokenExpiry?.() ?? null;
-    if (expSeconds === null) {
-      return;
-    }
-    const fireInMs = expSeconds * 1000 - Date.now() - TOKEN_REFRESH_LEAD_MS;
-    timer = setTimeout(runRefresh, Math.max(fireInMs, 0));
-  };
-
-  const onForeground = (): void => {
-    if (disposed || !oxyServices.getAccessToken()) {
-      return;
-    }
-    const expSeconds = oxyServices.getAccessTokenExpiry?.() ?? null;
-    if (expSeconds === null) {
-      return;
-    }
-    const remainingMs = expSeconds * 1000 - Date.now();
-    if (remainingMs <= TOKEN_REFRESH_LEAD_MS) {
-      runRefresh();
-    } else {
-      schedule();
-    }
-  };
-
-  const unsubscribeTokens = oxyServices.onTokensChanged(() => {
-    if (!disposed) {
-      schedule();
-    }
-  });
-
-  let removeForeground: (() => void) | null = null;
-  if (isWebBrowser() && typeof document !== 'undefined') {
-    const handler = (): void => {
-      if (document.visibilityState === 'visible') {
-        onForeground();
-      }
-    };
-    document.addEventListener('visibilitychange', handler);
-    removeForeground = () => document.removeEventListener('visibilitychange', handler);
-  } else if (!isWebBrowser() && AppState && typeof AppState.addEventListener === 'function') {
-    const subscription = AppState.addEventListener('change', (state: AppStateStatus) => {
-      if (state === 'active') {
-        onForeground();
-      }
-    });
-    removeForeground = () => subscription.remove();
-  }
-
-  schedule();
-
-  return {
-    dispose(): void {
-      disposed = true;
-      clearTimer();
-      unsubscribeTokens();
-      removeForeground?.();
-      removeForeground = null;
-    },
-  };
-}

package/src/ui/context/silentSessionRestore.ts

@@ -1,53 +0,0 @@
-/**
- * Silent, no-reload session-restore PRIMITIVE — the single shared
- * implementation used by BOTH cold boot (`OxyContext.restoreSessionsFromStorage`)
- * and in-session token refresh (`createInSessionRefreshHandler`). Neither caller
- * re-implements it; they compose it. Keeping one home avoids the two paths
- * drifting on "how do we mint a first-party token without a page reload".
- *
- * Platform-agnostic at the type level and returns plain data; the callers own
- * the side effects that differ between them (cold boot COMMITS the recovered
- * session into provider state; refresh only reads the freshly planted bearer).
- *
- * NOTE (session-sync cutover, Task 5): this file used to also export
- * `selectActiveRefreshAccount`, which picked the active account out of a
- * `refreshAllSessions` (`oxy_rt` refresh-cookie) snapshot. Deleted — its only
- * caller was the in-session refresh handler's now-deleted `refresh-cookie`
- * arm. The device account SET is server-authoritative via `SessionClient`
- * (`@oxyhq/core`) now.
- */
-import type { OxyServices, SessionLoginResponse } from '@oxyhq/core';
-import { autoDetectAuthWebUrl } from '@oxyhq/core';
-
-/**
- * Mint a fresh first-party session via the PER-APEX `/auth/silent` iframe — the
- * durable cross-domain restore path that works WITHOUT a top-level navigation
- * (so it succeeds under Safari ITP / Firefox TCP and in a backgrounded tab).
- *
- * The instance is configured with the CENTRAL auth URL, so we explicitly point
- * the iframe at the per-apex host (`auth.<rp-apex>`) via `autoDetectAuthWebUrl()`
- * + `silentSignIn`'s `authWebUrlOverride`. On a `*.oxy.so` app the per-apex host
- * IS the central host, so this also covers same-apex. When auto-detection bails
- * (localhost / IP / single-label / off-browser) there is no per-apex IdP and we
- * return `null`. `silentSignIn` plants the access token internally on success.
- *
- * @returns the recovered session (token already planted) when complete, else
- * `null` (no per-apex IdP, no session, or an incomplete iframe response).
- */
-export async function mintSessionViaPerApexIframe(
-  oxyServices: OxyServices,
-  timeoutMs: number,
-): Promise<SessionLoginResponse | null> {
-  const perApexAuthUrl = autoDetectAuthWebUrl();
-  if (!perApexAuthUrl) {
-    return null;
-  }
-  const session = await oxyServices.silentSignIn?.({
-    authWebUrlOverride: perApexAuthUrl,
-    timeout: timeoutMs,
-  });
-  if (!session?.user || !session.sessionId) {
-    return null;
-  }
-  return session;
-}

package/src/ui/hooks/useWebSSO.ts

@@ -1,23 +0,0 @@
-/**
- * Platform detection helper for the web auth/session-sync surfaces.
- *
- * This module previously hosted a FedCM-based `useWebSSO` hook (Federated
- * Credential Management — Chrome-only). It was removed: FedCM is no longer
- * used anywhere in the client sign-in/cold-boot path (see `CrossDomainAuth`'s
- * doc comment in `@oxyhq/core` for the production sign-in loop that motivated
- * the removal). Cross-domain silent SSO is owned entirely by the
- * `silent-iframe` cold-boot step (per-apex `/auth/silent`) plus the terminal
- * `/sso` bounce in `OxyContext`.
- *
- * `isWebBrowser` is kept here (rather than moved) so every existing consumer
- * import path stays valid.
- */
-
-/**
- * Check if we're running in a web browser environment (not React Native)
- */
-export function isWebBrowser(): boolean {
-  return typeof window !== 'undefined' &&
-         typeof document !== 'undefined' &&
-         typeof document.documentElement !== 'undefined';
-}

package/src/ui/session/__tests__/projectSessionState.test.ts

@@ -1,114 +0,0 @@
-import type { DeviceSessionState } from '@oxyhq/contracts';
-import type { User } from '@oxyhq/core';
-import {
-  accountIdsOf,
-  activeSessionIdOf,
-  activeUserOf,
-  deviceStateToClientSessions,
-} from '../projectSessionState';
-
-function makeUser(id: string): User {
-  return {
-    id,
-    publicKey: `pk-${id}`,
-    username: `user-${id}`,
-    name: {},
-  };
-}
-
-// DeviceSessionState.updatedAt is an epoch-ms number on the wire (see
-// packages/contracts/src/deviceSession.ts: `updatedAt: z.number()`), not an
-// ISO string.
-const UPDATED_AT_MS = Date.UTC(2026, 6, 1, 0, 0, 0, 0);
-const UPDATED_AT_ISO = new Date(UPDATED_AT_MS).toISOString();
-
-const state: DeviceSessionState = {
-  deviceId: 'device-1',
-  accounts: [
-    { accountId: 'a1', sessionId: 'sess-a1', authuser: 0 },
-    { accountId: 'a2', sessionId: 'sess-a2', authuser: 1 },
-  ],
-  activeAccountId: 'a2',
-  revision: 1,
-  updatedAt: UPDATED_AT_MS,
-};
-
-const usersById = new Map<string, User>([
-  ['a1', makeUser('a1')],
-  ['a2', makeUser('a2')],
-]);
-
-describe('projectSessionState', () => {
-  describe('activeSessionIdOf', () => {
-    test('returns the active account sessionId', () => {
-      expect(activeSessionIdOf(state)).toBe('sess-a2');
-    });
-
-    test('returns null for null state', () => {
-      expect(activeSessionIdOf(null)).toBeNull();
-    });
-
-    test('returns null when activeAccountId is null', () => {
-      expect(activeSessionIdOf({ ...state, activeAccountId: null })).toBeNull();
-    });
-  });
-
-  describe('deviceStateToClientSessions', () => {
-    test('maps every account in order with isCurrent + authuser', () => {
-      const sessions = deviceStateToClientSessions(state, usersById);
-      expect(sessions).toHaveLength(2);
-      expect(sessions[0]).toEqual({
-        sessionId: 'sess-a1',
-        deviceId: 'device-1',
-        expiresAt: UPDATED_AT_ISO,
-        lastActive: UPDATED_AT_ISO,
-        userId: 'a1',
-        isCurrent: false,
-        authuser: 0,
-      });
-      expect(sessions[1]).toEqual({
-        sessionId: 'sess-a2',
-        deviceId: 'device-1',
-        expiresAt: UPDATED_AT_ISO,
-        lastActive: UPDATED_AT_ISO,
-        userId: 'a2',
-        isCurrent: true,
-        authuser: 1,
-      });
-    });
-
-    test('still projects a session for an account absent from usersById', () => {
-      const sessions = deviceStateToClientSessions(state, new Map());
-      expect(sessions).toHaveLength(2);
-      expect(sessions.map((session) => session.userId)).toEqual(['a1', 'a2']);
-    });
-  });
-
-  describe('activeUserOf', () => {
-    test('returns the active account user', () => {
-      expect(activeUserOf(state, usersById)).toEqual(makeUser('a2'));
-    });
-
-    test('returns null for null state', () => {
-      expect(activeUserOf(null, usersById)).toBeNull();
-    });
-
-    test('returns null when activeAccountId is null', () => {
-      expect(activeUserOf({ ...state, activeAccountId: null }, usersById)).toBeNull();
-    });
-
-    test('returns null when the active account id is absent from usersById', () => {
-      expect(activeUserOf(state, new Map())).toBeNull();
-    });
-  });
-
-  describe('accountIdsOf', () => {
-    test('returns every account id in order', () => {
-      expect(accountIdsOf(state)).toEqual(['a1', 'a2']);
-    });
-
-    test('returns [] for null state', () => {
-      expect(accountIdsOf(null)).toEqual([]);
-    });
-  });
-});

package/src/ui/session/__tests__/sessionClientHost.test.ts

@@ -1,43 +0,0 @@
-import { createSessionClientHost } from '../sessionClientHost';
-
-function fakeOxy() {
-  const listeners = new Set<(t: string | null) => void>();
-  return {
-    makeRequest: jest.fn().mockResolvedValue({ ok: true }),
-    getBaseURL: jest.fn().mockReturnValue('https://api.oxy.so'),
-    getAccessToken: jest.fn().mockReturnValue('tok'),
-    setTokens: jest.fn(),
-    onTokensChanged: jest.fn((l: (t: string | null) => void) => { listeners.add(l); return () => listeners.delete(l); }),
-    _emit: (t: string | null) => listeners.forEach((l) => l(t)),
-  };
-}
-
-test('delegates REST + token methods to oxyServices', async () => {
-  const oxy = fakeOxy();
-  const host = createSessionClientHost(oxy as never);
-  await host.makeRequest('GET', '/session/device/state', undefined, { cache: false });
-  expect(oxy.makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-  expect(host.getBaseURL()).toBe('https://api.oxy.so');
-  expect(host.getAccessToken()).toBe('tok');
-  host.setTokens('new');
-  expect(oxy.setTokens).toHaveBeenCalledWith('new');
-});
-
-test('getCurrentAccountId reflects setCurrentAccountId', () => {
-  const host = createSessionClientHost(fakeOxy() as never);
-  expect(host.getCurrentAccountId()).toBeNull();
-  host.setCurrentAccountId('u1');
-  expect(host.getCurrentAccountId()).toBe('u1');
-});
-
-test('onTokensChanged forwards to oxyServices and unsubscribes', () => {
-  const oxy = fakeOxy();
-  const host = createSessionClientHost(oxy as never);
-  const cb = jest.fn();
-  const unsub = host.onTokensChanged(cb);
-  oxy._emit(null);
-  expect(cb).toHaveBeenCalledWith(null);
-  unsub();
-  oxy._emit('x');
-  expect(cb).toHaveBeenCalledTimes(1);
-});

package/src/ui/session/projectSessionState.ts

@@ -1,85 +0,0 @@
-import type { DeviceSessionState } from '@oxyhq/contracts';
-import type { ClientSession, User } from '@oxyhq/core';
-
-/**
- * Pure projection helpers: `DeviceSessionState` (the device-scoped
- * multi-account session-sync state produced by `@oxyhq/core`'s
- * `SessionClient`) -> the shapes `OxyContext` renders today
- * (`ClientSession[]`, an active session id, an active `User`).
- *
- * No I/O. The caller fetches profiles via
- * `oxyServices.getUsersByIds(accountIdsOf(state))` and builds `usersById`
- * from the result before calling `deviceStateToClientSessions` /
- * `activeUserOf`.
- */
-
-/**
- * Maps every `SessionAccount` in `state.accounts` to a `ClientSession`.
- *
- * `DeviceSessionState` carries no per-account `expiresAt` / `lastActive` —
- * both are set to `state.updatedAt` (converted to an ISO-8601 string; the
- * wire value is an epoch-ms number) as a provisional value. Fase 3-B
- * rewrites `ClientSession` to make `expiresAt`/`lastActive` optional (they
- * are not derivable from `DeviceSessionState`).
- *
- * `usersById` is accepted for signature symmetry with `activeUserOf` even
- * though `ClientSession` only stores `userId` — a session is still
- * projected for an account whose id is absent from `usersById` (no
- * placeholder user is fabricated).
- */
-export function deviceStateToClientSessions(
-  state: DeviceSessionState,
-  usersById: Map<string, User>,
-): ClientSession[] {
-  const provisionalTimestamp = new Date(state.updatedAt).toISOString();
-  return state.accounts.map((account) => ({
-    sessionId: account.sessionId,
-    deviceId: state.deviceId,
-    // provisional: Fase 3-B rewrites ClientSession to make expiresAt/lastActive
-    // optional (they are not in DeviceSessionState)
-    expiresAt: provisionalTimestamp,
-    lastActive: provisionalTimestamp,
-    userId: account.accountId,
-    isCurrent: account.accountId === state.activeAccountId,
-    authuser: account.authuser,
-  }));
-}
-
-/**
- * The active account's `sessionId`, or `null` when there is no state or no
- * active account is set.
- */
-export function activeSessionIdOf(state: DeviceSessionState | null): string | null {
-  if (state === null || state.activeAccountId === null) {
-    return null;
-  }
-  const activeAccountId = state.activeAccountId;
-  const activeAccount = state.accounts.find((account) => account.accountId === activeAccountId);
-  return activeAccount?.sessionId ?? null;
-}
-
-/**
- * The active account's `User`, resolved from `usersById`. `null` when there
- * is no state, no active account is set, or the active account id is absent
- * from `usersById`.
- */
-export function activeUserOf(
-  state: DeviceSessionState | null,
-  usersById: Map<string, User>,
-): User | null {
-  if (state === null || state.activeAccountId === null) {
-    return null;
-  }
-  return usersById.get(state.activeAccountId) ?? null;
-}
-
-/**
- * All account ids in `state`, suitable for an `oxyServices.getUsersByIds(...)`
- * fetch. `[]` for `null` state.
- */
-export function accountIdsOf(state: DeviceSessionState | null): string[] {
-  if (state === null) {
-    return [];
-  }
-  return state.accounts.map((account) => account.accountId);
-}

package/src/ui/session/sessionClientHost.ts

@@ -1,27 +0,0 @@
-import type { OxyServices, SessionClientHost } from '@oxyhq/core';
-
-/**
- * Thin `SessionClientHost` adapter over an `OxyServices` instance.
- *
- * `SessionClient` (in `@oxyhq/core`) is host-agnostic: it only needs a REST +
- * token surface. `OxyServices` already exposes all of that except
- * `getCurrentAccountId`, which has no direct equivalent — the adapter holds a
- * mutable ref set by the caller (`OxyContext`, in Fase 3-B) via
- * `setCurrentAccountId`.
- */
-export function createSessionClientHost(
-  oxyServices: OxyServices,
-): SessionClientHost & { setCurrentAccountId(id: string | null): void } {
-  let currentAccountId: string | null = null;
-  return {
-    makeRequest: (method, url, data, options) => oxyServices.makeRequest(method, url, data, options),
-    getBaseURL: () => oxyServices.getBaseURL(),
-    getAccessToken: () => oxyServices.getAccessToken(),
-    onTokensChanged: (listener) => oxyServices.onTokensChanged(listener),
-    setTokens: (accessToken) => oxyServices.setTokens(accessToken),
-    getCurrentAccountId: () => currentAccountId,
-    setCurrentAccountId: (id) => {
-      currentAccountId = id;
-    },
-  };
-}