@oxyhq/services 6.9.46 → 6.10.2

package/src/ui/hooks/queries/useAccountQueries.ts

@@ -1,8 +1,11 @@
-import { useQuery, useQueries } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { useQuery, useQueries, useQueryClient } from '@tanstack/react-query';
 import { authenticatedApiCall } from '@oxyhq/core';
 import type { User } from '@oxyhq/core';
 import { queryKeys } from './queryKeys';
+import { mutationKeys } from '../mutations/mutationKeys';
 import { useOxy } from '../../context/OxyContext';
+import { useAuthStore } from '../../stores/authStore';
 
 /**
  * Get user profile by session ID
@@ -45,12 +48,23 @@ export const useUserProfiles = (sessionIds: string[], options?: { enabled?: bool
 };
 
 /**
- * Get current authenticated user
+ * Get current authenticated user.
+ *
+ * The store-mirror effect must NOT overwrite the in-memory user while a
+ * write mutation is in flight — otherwise a stale background refetch
+ * landing between optimistic update and server-confirmed update would
+ * revert the optimistic value and flicker the UI.
+ *
+ * We gate the mirror on the mutation-cache state for any mutation that
+ * touches `User` shape (profile, avatar, settings, privacy). When any of
+ * those is in flight we skip the mirror entirely; the winning onSuccess
+ * handler is responsible for writing the final value to the store.
  */
 export const useCurrentUser = (options?: { enabled?: boolean }) => {
   const { oxyServices, activeSessionId, isAuthenticated } = useOxy();
+  const queryClient = useQueryClient();
 
-  return useQuery({
+  const query = useQuery({
     queryKey: queryKeys.accounts.current(),
     queryFn: async () => {
       if (!activeSessionId) {
@@ -62,8 +76,74 @@ export const useCurrentUser = (options?: { enabled?: boolean }) => {
     staleTime: 1 * 60 * 1000, // 1 minute for current user
     gcTime: 30 * 60 * 1000,
   });
+
+  // Mirror fresh server-side user into the auth store so consumers reading
+  // useOxy().user pick up newly-arriving fields (createdAt, updatedAt, etc.).
+  //
+  // Guard 1 (mutation in flight): skip if ANY user-shape mutation is in
+  // flight — the in-progress optimistic value must not be reverted by a
+  // background refetch.
+  // Guard 2 (staleness): if the existing store user has a strictly newer
+  // `updatedAt` than the incoming data, skip. Protects against late-
+  // arriving refetches that race with an already-completed mutation.
+  const data = query.data;
+  useEffect(() => {
+    if (!data) return;
+
+    // Check for any write mutation that mutates the user shape. Match by
+    // any prefix of the user-write mutation keys we own — `isMutating`
+    // matches mutations whose `mutationKey` starts with the provided key.
+    const userWriteMutationsInFlight =
+      queryClient.isMutating({ mutationKey: mutationKeys.account.updateProfile }) +
+      queryClient.isMutating({ mutationKey: mutationKeys.account.uploadAvatar }) +
+      queryClient.isMutating({ mutationKey: mutationKeys.account.updateSettings }) +
+      queryClient.isMutating({ mutationKey: mutationKeys.account.updatePrivacySettings });
+
+    if (userWriteMutationsInFlight > 0) {
+      return;
+    }
+
+    // updatedAt-based staleness gate. Tolerates missing fields on either
+    // side: when the server response or stored user omits `updatedAt`
+    // (partial updates, legacy users), fall through to the mirror — the
+    // mutation-in-flight guard above is the primary defense.
+    const storedUser = useAuthStore.getState().user;
+    const incomingUpdatedAt = parseUpdatedAt(data.updatedAt);
+    const storedUpdatedAt = parseUpdatedAt(storedUser?.updatedAt);
+    if (
+      incomingUpdatedAt !== null &&
+      storedUpdatedAt !== null &&
+      incomingUpdatedAt < storedUpdatedAt
+    ) {
+      return;
+    }
+
+    useAuthStore.getState().setUser(data);
+  }, [data, queryClient]);
+
+  return query;
 };
 
+/**
+ * Best-effort parser for the various `updatedAt` representations the API
+ * returns (ISO string, epoch number, Date instance, undefined). Returns
+ * `null` when the value can't be interpreted as a finite timestamp — the
+ * caller then falls back to the mutation-in-flight guard.
+ */
+function parseUpdatedAt(value: unknown): number | null {
+  if (value == null) return null;
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (value instanceof Date) {
+    const t = value.getTime();
+    return Number.isFinite(t) ? t : null;
+  }
+  if (typeof value === 'string') {
+    const t = Date.parse(value);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+
 /**
  * Get user by ID
  */

package/src/ui/hooks/queries/useSecurityQueries.ts

@@ -1,7 +1,7 @@
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, useInfiniteQuery } from '@tanstack/react-query';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
-import type { SecurityActivity, SecurityEventType } from '@oxyhq/core';
+import type { SecurityActivity, SecurityActivityResponse, SecurityEventType } from '@oxyhq/core';
 
 /**
  * Get user's security activity with pagination
@@ -62,3 +62,43 @@ export const useRecentSecurityActivity = (limit = 10) => {
   });
 };
 
+/**
+ * Get user's security activity with infinite pagination.
+ * Each page returns up to `limit` events; `getNextPageParam` walks the
+ * `offset` cursor until the API reports `hasMore: false`.
+ */
+export const useInfiniteSecurityActivity = (
+  options?: {
+    limit?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+  }
+) => {
+  const { oxyServices, activeSessionId } = useOxy();
+  const limit = options?.limit ?? 30;
+
+  return useInfiniteQuery<SecurityActivityResponse, Error>({
+    queryKey: queryKeys.security.infinite(limit, options?.eventType),
+    queryFn: async ({ pageParam }) => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+
+      const offset = typeof pageParam === 'number' ? pageParam : 0;
+      return await oxyServices.getSecurityActivity(
+        limit,
+        offset,
+        options?.eventType
+      );
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      if (!lastPage.hasMore) return undefined;
+      return lastPage.offset + lastPage.limit;
+    },
+    enabled: (options?.enabled !== false) && !!activeSessionId,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

package/src/ui/hooks/queryClient.ts

@@ -1,74 +1,115 @@
-import { QueryClient } from '@tanstack/react-query';
+/**
+ * Offline-first QueryClient with cross-restart persistence.
+ *
+ * Wires together:
+ * - TanStack Query with `networkMode: 'offlineFirst'` for queries and mutations
+ *   so cached data is served immediately and mutations are queued (paused) while
+ *   the browser/device reports offline.
+ * - `persistQueryClient(...)` from `@tanstack/react-query-persist-client` so that
+ *   query results AND paused mutations survive a cold restart (kill-and-relaunch).
+ * - `onlineManager` resume hook so paused mutations replay the moment the
+ *   network is reported back, even if the host app swapped in a custom
+ *   onlineManager implementation.
+ *
+ * Storage layer:
+ * - React Native -> AsyncStorage via `createAsyncStoragePersister`.
+ * - Web -> localStorage via `createSyncStoragePersister` (wrapped in the
+ *   async persister API for a single call site).
+ * - Both adapters are content-shape compatible with our `StorageInterface`.
+ *
+ * Whitelist policy:
+ * - Persist every account/user/session/privacy query and every queued mutation.
+ * - DO NOT persist large list queries (e.g. activity feeds) — they go stale
+ *   fast and would balloon storage. Add new keys to `PERSISTED_QUERY_PREFIXES`
+ *   when introducing reads that should survive restart.
+ */
+
+import { QueryClient, onlineManager, type Query, type Mutation } from '@tanstack/react-query';
+import {
+  persistQueryClient,
+  type PersistedClient,
+} from '@tanstack/react-query-persist-client';
+import { createAsyncStoragePersister } from '@tanstack/query-async-storage-persister';
 import { isDev } from '@oxyhq/core';
 import type { StorageInterface } from '../utils/storageHelpers';
 
-const QUERY_CACHE_KEY = 'oxy_query_cache';
-const QUERY_CACHE_VERSION = '1';
+const QUERY_CACHE_KEY = 'oxy_query_cache_v2';
+const QUERY_CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000; // 30 days
+const QUERY_PERSIST_THROTTLE_MS = 1_000;
+
+/**
+ * Query-key prefixes that should survive cold restart. Anything not listed
+ * is dropped during dehydration so the persisted blob stays small.
+ *
+ * Mutations are persisted independently (always) so the offline write queue
+ * works regardless of the read whitelist.
+ */
+const PERSISTED_QUERY_PREFIXES: ReadonlyArray<string> = [
+  'accounts',
+  'users',
+  'sessions',
+  'devices',
+  'privacy',
+];
 
 /**
- * Custom persistence adapter for TanStack Query using our StorageInterface
+ * Adapt our `StorageInterface` (which always returns `null` for missing keys)
+ * to TanStack's `AsyncStorage` shape. The two are structurally identical
+ * apart from naming; this also gives us a single place to add error
+ * suppression if a host platform's storage throws.
  */
-export const createPersistenceAdapter = (storage: StorageInterface) => {
+function adaptStorage(storage: StorageInterface): {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+} {
   return {
-    persistClient: async (client: any) => {
-      try {
-        const serialized = JSON.stringify({
-          clientState: client,
-          timestamp: Date.now(),
-          version: QUERY_CACHE_VERSION,
-        });
-        await storage.setItem(QUERY_CACHE_KEY, serialized);
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to persist cache:', error);
-        }
-      }
-    },
-    restoreClient: async () => {
-      try {
-        const cached = await storage.getItem(QUERY_CACHE_KEY);
-        if (!cached) return undefined;
-
-        const parsed = JSON.parse(cached);
-        
-        // Check version compatibility
-        if (parsed.version !== QUERY_CACHE_VERSION) {
-          // Clear old cache on version mismatch
-          await storage.removeItem(QUERY_CACHE_KEY);
-          return undefined;
-        }
+    getItem: (key) => storage.getItem(key),
+    setItem: (key, value) => storage.setItem(key, value),
+    removeItem: (key) => storage.removeItem(key),
+  };
+}
 
-        // Check if cache is too old (30 days)
-        const maxAge = 30 * 24 * 60 * 60 * 1000;
-        if (parsed.timestamp && Date.now() - parsed.timestamp > maxAge) {
-          await storage.removeItem(QUERY_CACHE_KEY);
-          return undefined;
-        }
+/**
+ * Decide whether a given query should be written to persistent storage.
+ *
+ * Two gates:
+ * 1. The query must be in our prefix whitelist.
+ * 2. The query must have completed successfully at least once — there's no
+ *    point persisting a `pending`/`error` state, and persisting `error` would
+ *    leak failure objects across restarts.
+ */
+function shouldDehydrateQuery(query: Query): boolean {
+  if (query.state.status !== 'success') {
+    return false;
+  }
+  const head = query.queryKey[0];
+  if (typeof head !== 'string') {
+    return false;
+  }
+  return PERSISTED_QUERY_PREFIXES.includes(head);
+}
 
-        return parsed.clientState;
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to restore cache:', error);
-        }
-        return undefined;
-      }
-    },
-    removeClient: async () => {
-      try {
-        await storage.removeItem(QUERY_CACHE_KEY);
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to remove cache:', error);
-        }
-      }
-    },
-  };
-};
+/**
+ * Persist every mutation regardless of status — paused mutations are
+ * exactly the ones that must survive restart to replay when online.
+ */
+function shouldDehydrateMutation(_mutation: Mutation): boolean {
+  return true;
+}
 
 /**
- * Create a QueryClient with offline-first configuration
+ * Create a QueryClient with offline-first defaults.
+ *
+ * Mutations marked with `networkMode: 'offlineFirst'` are queued by TanStack
+ * Query when offline (status "paused") and resumed automatically when
+ * `onlineManager` transitions back to online. Network monitoring wiring lives
+ * in `OxyProvider.tsx`.
+ *
+ * Persistence is attached separately via `attachQueryPersistence(...)`.
+ * Splitting the steps lets test/SSR callers create a stateless client.
  */
-export const createQueryClient = (storage?: StorageInterface | null): QueryClient => {
+export const createQueryClient = (): QueryClient => {
   const client = new QueryClient({
     defaultOptions: {
       queries: {
@@ -79,35 +120,119 @@ export const createQueryClient = (storage?: StorageInterface | null): QueryClien
         // Retry 3 times with exponential backoff
         retry: 3,
         retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-        // Refetch on reconnect
+        // Refetch on reconnect so stale data is refreshed once online again.
         refetchOnReconnect: true,
         // Don't refetch on window focus (better for mobile)
         refetchOnWindowFocus: false,
-        // Offline-first: use cache when offline
+        // Offline-first: serve cached data immediately, refetch in background.
         networkMode: 'offlineFirst',
       },
       mutations: {
         // Retry once for mutations
         retry: 1,
-        // Offline-first: queue mutations when offline
+        // Offline-first: pause and queue mutations when offline.
         networkMode: 'offlineFirst',
       },
     },
   });
 
-  // Note: Persistence is handled by TanStack Query's built-in persistence
-  // For now, we rely on the query client's default behavior with networkMode: 'offlineFirst'
-  // The cache will be available in memory and queries will use cached data when offline
-  // Full persistence to AsyncStorage can be added later with @tanstack/react-query-persist-client if needed
+  // Defensive: explicitly resume paused mutations whenever the network
+  // transitions back to online. TanStack Query does this internally too,
+  // but wiring it here keeps the behaviour robust if a custom onlineManager
+  // implementation is swapped in by the host app.
+  const unsubscribe = onlineManager.subscribe((isOnline) => {
+    if (isOnline) {
+      void client.getMutationCache().resumePausedMutations();
+    }
+  });
+
+  Object.defineProperty(client, '__oxyOnlineUnsubscribe', {
+    value: unsubscribe,
+    enumerable: false,
+    configurable: true,
+    writable: false,
+  });
 
   return client;
 };
 
+export interface AttachPersistenceResult {
+  /** Promise that resolves once the persisted cache has been restored. */
+  restored: Promise<void>;
+  /** Detach the persistence subscription (tests + teardown). */
+  unsubscribe: () => void;
+}
+
+/**
+ * Wire `persistQueryClient` to the supplied storage adapter.
+ *
+ * Returns once the in-flight restore promise is available so callers can
+ * `await result.restored` before rendering UI that depends on cached data.
+ *
+ * Safe to no-op if `storage` is null/undefined (e.g. server-side render
+ * with no host storage).
+ */
+export const attachQueryPersistence = (
+  queryClient: QueryClient,
+  storage: StorageInterface | null | undefined,
+): AttachPersistenceResult => {
+  if (!storage) {
+    return {
+      restored: Promise.resolve(),
+      unsubscribe: () => {},
+    };
+  }
+
+  const persister = createAsyncStoragePersister({
+    storage: adaptStorage(storage),
+    key: QUERY_CACHE_KEY,
+    throttleTime: QUERY_PERSIST_THROTTLE_MS,
+  });
+
+  const [unsubscribe, restored] = persistQueryClient({
+    queryClient,
+    persister,
+    maxAge: QUERY_CACHE_MAX_AGE,
+    dehydrateOptions: {
+      shouldDehydrateQuery,
+      shouldDehydrateMutation,
+    },
+  });
+
+  restored.catch((error) => {
+    if (isDev()) {
+      console.warn('[QueryClient] Failed to restore persisted cache', error);
+    }
+  });
+
+  return { unsubscribe, restored };
+};
+
+// Legacy v1 cache key — kept so we can opportunistically purge stale blobs
+// written by older builds. Safe to drop after a few releases.
+const LEGACY_QUERY_CACHE_KEYS: ReadonlyArray<string> = ['oxy_query_cache'];
+
 /**
- * Clear persisted query cache
+ * Remove the persisted query+mutation cache (used on full sign-out / data
+ * reset). Safe to call even if persistence was never attached. Also clears
+ * legacy cache keys from older builds.
  */
 export const clearQueryCache = async (storage: StorageInterface): Promise<void> => {
-  const adapter = createPersistenceAdapter(storage);
-  await adapter.removeClient();
+  const keys = [QUERY_CACHE_KEY, ...LEGACY_QUERY_CACHE_KEYS];
+  await Promise.all(
+    keys.map(async (key) => {
+      try {
+        await storage.removeItem(key);
+      } catch (error) {
+        if (isDev()) {
+          console.warn(`[QueryClient] Failed to clear persisted query cache (${key})`, error);
+        }
+      }
+    }),
+  );
 };
 
+/**
+ * Re-export the persisted client shape so callers can type custom persisters.
+ */
+export type { PersistedClient };

package/src/ui/hooks/useAsyncAction.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback } from 'react';
-import { toast } from '../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 
 interface UseAsyncActionOptions<T> {
     /** Function to execute */
@@ -63,7 +63,7 @@ export function useAsyncAction<T = void>(
         setError(null);
 
         if (showLoadingToast && loadingMessage) {
-            toast.loading(loadingMessage);
+            toast.info(loadingMessage);
         }
 
         try {
@@ -111,7 +111,7 @@ export async function executeWithToast<T>(
     const { successMessage, errorMessage, loadingMessage } = options || {};
 
     if (loadingMessage) {
-        toast.loading(loadingMessage);
+        toast.info(loadingMessage);
     }
 
     try {

package/src/ui/hooks/useAuth.ts

@@ -215,5 +215,3 @@ export function useAuth(): UseAuthReturn {
   };
 }
 
-// Re-export useOxy for backward compatibility and advanced usage
-export { useOxy } from '../context/OxyContext';

package/src/ui/hooks/useAvatarPicker.ts

@@ -2,18 +2,26 @@
  * Avatar Picker Hook
  *
  * Extracts avatar selection logic from OxyContext for better modularity.
- * Opens the FileManagement bottom sheet in select mode for image files,
- * then updates the user's profile avatar.
+ *
+ * Flow:
+ *   1. Open the FileManagement bottom sheet in select mode for image files.
+ *   2. After the user picks an image, route to the AvatarCrop screen so they
+ *      can square-crop + zoom before the avatar is set.
+ *   3. The cropped JPEG is uploaded as a NEW file via `oxyServices.assetUpload`
+ *      and that file becomes the user's avatar.
+ *
+ * `expo-image-manipulator` is required for the crop step (declared as an
+ * optional peer in the consuming app) — see AvatarCropScreen.
  */
 
 import { useCallback } from 'react';
-import type { OxyServices } from '@oxyhq/core';
-import { translate } from '@oxyhq/core';
+import type { FileMetadata, OxyServices } from '@oxyhq/core';
+import { translate, updateAvatarVisibility } from '@oxyhq/core';
 import type { QueryClient } from '@tanstack/react-query';
-import { toast } from '../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 import type { RouteName } from '../navigation/routes';
-import { updateAvatarVisibility } from '@oxyhq/core';
 import { updateProfileWithAvatar } from '../utils/avatarUtils';
+import type { AvatarCropResult } from '../screens/AvatarCropScreen';
 
 interface UseAvatarPickerOptions {
   oxyServices: OxyServices;
@@ -23,6 +31,22 @@ interface UseAvatarPickerOptions {
   showBottomSheet: (config: { screen: RouteName; props?: Record<string, unknown> }) => void;
 }
 
+/** Upload result shape returned by oxyServices.assetUpload (single-file path). */
+interface AssetUploadResult {
+  file?: { id?: string };
+  files?: Array<{ id?: string }>;
+  id?: string;
+}
+
+function extractUploadedFileId(result: AssetUploadResult | undefined): string | undefined {
+  if (!result) return undefined;
+  if (typeof result.id === 'string') return result.id;
+  if (result.file?.id) return result.file.id;
+  const first = result.files?.[0];
+  if (first?.id) return first.id;
+  return undefined;
+}
+
 export function useAvatarPicker({
   oxyServices,
   currentLanguage,
@@ -30,36 +54,93 @@ export function useAvatarPicker({
   queryClient,
   showBottomSheet,
 }: UseAvatarPickerOptions) {
+  /**
+   * Final step: take the cropped JPEG, upload it as a new public file, then
+   * set it as the user's avatar. Fires success/error toasts.
+   */
+  const finalizeCroppedAvatar = useCallback(
+    async (cropped: AvatarCropResult) => {
+      try {
+        const uploadResult = (await oxyServices.assetUpload(
+          {
+            uri: cropped.uri,
+            type: cropped.mime,
+            name: `avatar-${Date.now()}.jpg`,
+          },
+          'public',
+        )) as AssetUploadResult;
+
+        const newFileId = extractUploadedFileId(uploadResult);
+        if (!newFileId) {
+          throw new Error('Avatar upload succeeded but no file ID was returned');
+        }
+
+        await updateAvatarVisibility(newFileId, oxyServices, 'useAvatarPicker');
+        await updateProfileWithAvatar(
+          { avatar: newFileId },
+          oxyServices,
+          activeSessionId,
+          queryClient,
+        );
+
+        toast.success(
+          translate(currentLanguage ?? undefined, 'editProfile.toasts.avatarUpdated') ||
+            'Avatar updated',
+        );
+      } catch (e: unknown) {
+        const message = e instanceof Error ? e.message : undefined;
+        toast.error(
+          message ||
+            translate(currentLanguage ?? undefined, 'editProfile.toasts.updateAvatarFailed') ||
+            'Failed to update avatar',
+        );
+      }
+    },
+    [activeSessionId, currentLanguage, oxyServices, queryClient],
+  );
+
+  /**
+   * After the user picks a file in the FileManagement sheet, route to the
+   * crop screen with the file's download URL as the source image.
+   */
+  const handleFilePicked = useCallback(
+    (file: FileMetadata) => {
+      if (!file.contentType?.startsWith('image/')) {
+        toast.error(
+          translate(currentLanguage ?? undefined, 'editProfile.toasts.selectImage') ||
+            'Please select an image file',
+        );
+        return;
+      }
+
+      // Use the public download URL of the picked file as the crop source.
+      // The OxyServices file URL endpoints accept image variants, but for
+      // cropping we want the original — passing no variant returns it.
+      const sourceUri = oxyServices.getFileDownloadUrl(file.id);
+
+      showBottomSheet({
+        screen: 'AvatarCrop',
+        props: {
+          imageUri: sourceUri,
+          onConfirm: finalizeCroppedAvatar,
+        },
+      });
+    },
+    [currentLanguage, finalizeCroppedAvatar, oxyServices, showBottomSheet],
+  );
+
   const openAvatarPicker = useCallback(() => {
     showBottomSheet({
-      screen: 'FileManagement' as RouteName,
+      screen: 'FileManagement',
       props: {
         selectMode: true,
         multiSelect: false,
         disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
         afterSelect: 'none',
-        onSelect: async (file: any) => {
-          if (!file.contentType.startsWith('image/')) {
-            toast.error(translate(currentLanguage ?? undefined, 'editProfile.toasts.selectImage') || 'Please select an image file');
-            return;
-          }
-          try {
-            await updateAvatarVisibility(file.id, oxyServices, 'OxyContext');
-            await updateProfileWithAvatar(
-              { avatar: file.id },
-              oxyServices,
-              activeSessionId,
-              queryClient
-            );
-            toast.success(translate(currentLanguage ?? undefined, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
-          } catch (e: unknown) {
-            const message = e instanceof Error ? e.message : undefined;
-            toast.error(message || translate(currentLanguage ?? undefined, 'editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
-          }
-        },
+        onSelect: handleFilePicked,
       },
     });
-  }, [oxyServices, currentLanguage, showBottomSheet, activeSessionId, queryClient]);
+  }, [handleFilePicked, showBottomSheet]);
 
   return { openAvatarPicker };
 }