fix: use a seperate agent instead for alternative atproto-proxy header; avoids what I assume was a race condition

src/state/queries/notifications/settings.ts

···
   useQueryClient,
 } from '@tanstack/react-query'
 
-import {BLUESKY_PROXY_HEADER, PBLLC_BLUESKY_PROXY_HEADER} from '#/lib/constants'
 import {logger} from '#/logger'
-import {useAgent} from '#/state/session'
+import {getBskyAppviewAgent as getBskyAppviewAgent} from '#/state/session/appview-agent'
 import * as Toast from '#/view/com/util/Toast'
 
 const RQKEY_ROOT = 'notification-settings'
···
 export function useNotificationSettingsQuery({
   enabled,
 }: {enabled?: boolean} = {}) {
-  const agent = useAgent()
-
   return useQuery({
     queryKey: RQKEY,
     queryFn: async () => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      const response = await agent.app.bsky.notification.getPreferences()
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      // Use appview agent which already has PBLLC proxy configured
+      const bskyAppviewAgent = getBskyAppviewAgent()
+      const response =
+        await bskyAppviewAgent.app.bsky.notification.getPreferences()
       return response.data.preferences
     },
     enabled,
   })
 }
 export function useNotificationSettingsUpdateMutation() {
-  const agent = useAgent()
   const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (
       update: Partial<AppBskyNotificationDefs.Preferences>,
     ) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
+      // Use appview agent which already has PBLLC proxy configured
+      const appviewAgent = getBskyAppviewAgent()
       const response =
-        await agent.app.bsky.notification.putPreferencesV2(update)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+        await appviewAgent.app.bsky.notification.putPreferencesV2(update)
       return response.data.preferences
     },
     onMutate: update => {

src/state/queries/preferences/index.ts

···
 } from '@atproto/api'
 import {useMutation, useQuery, useQueryClient} from '@tanstack/react-query'
 
-import {
-  BLUESKY_PROXY_HEADER,
-  PBLLC_BLUESKY_PROXY_HEADER,
-  PROD_DEFAULT_FEED,
-} from '#/lib/constants'
+import {PROD_DEFAULT_FEED} from '#/lib/constants'
 import {replaceEqualDeep} from '#/lib/functions'
 import {getAge} from '#/lib/strings/time'
 import {logger} from '#/logger'
···
 } from '#/state/queries/preferences/types'
 import {useAgent} from '#/state/session'
 import {saveLabelers} from '#/state/session/agent-config'
+import {getBskyAppviewAgent} from '#/state/session/appview-agent'
 
 export * from '#/state/queries/preferences/const'
 export * from '#/state/queries/preferences/moderation'
···
       if (!agent.did) {
         return DEFAULT_LOGGED_OUT_PREFERENCES
       } else {
-        agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-        const res = await agent.getPreferences()
-        agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+        const appviewAgent = getBskyAppviewAgent()
+        const res = await appviewAgent.getPreferences()
 
         // save to local storage to ensure there are labels on initial requests
         saveLabelers(
···
 
 export function useClearPreferencesMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async () => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.app.bsky.actor.putPreferences({preferences: []})
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.app.bsky.actor.putPreferences({preferences: []})
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 }
 
 export function usePreferencesSetContentLabelMutation() {
-  const agent = useAgent()
   const queryClient = useQueryClient()
 
   return useMutation<
···
     {label: string; visibility: LabelPreference; labelerDid: string | undefined}
   >({
     mutationFn: async ({label, visibility, labelerDid}) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setContentLabelPref(label, visibility, labelerDid)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setContentLabelPref(label, visibility, labelerDid)
       logger.metric(
         'moderation:changeLabelPreference',
         {preference: visibility},
···
 
 export function useSetContentLabelMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async ({
···
       visibility: LabelPreference
       labelerDid?: string
     }) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setContentLabelPref(label, visibility, labelerDid)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setContentLabelPref(label, visibility, labelerDid)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function usePreferencesSetAdultContentMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, {enabled: boolean}>({
     mutationFn: async ({enabled}) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setAdultContentEnabled(enabled)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setAdultContentEnabled(enabled)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function usePreferencesSetBirthDateMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, {birthDate: Date}>({
     mutationFn: async ({birthDate}: {birthDate: Date}) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setPersonalDetails({birthDate: birthDate.toISOString()})
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setPersonalDetails({
+        birthDate: birthDate.toISOString(),
+      })
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useSetFeedViewPreferencesMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, Partial<BskyFeedViewPreference>>({
     mutationFn: async prefs => {
···
        * special handling here, merged into `feedViewPrefs` above, since
        * following was previously called `home`
        */
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setFeedViewPrefs('home', prefs)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setFeedViewPrefs('home', prefs)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useSetThreadViewPreferencesMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, Partial<ThreadViewPreferences>>({
     mutationFn: async prefs => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setThreadViewPrefs(prefs)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setThreadViewPrefs(prefs)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useOverwriteSavedFeedsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, AppBskyActorDefs.SavedFeed[]>({
     mutationFn: async savedFeeds => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.overwriteSavedFeeds(savedFeeds)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.overwriteSavedFeeds(savedFeeds)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useAddSavedFeedsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<
     void,
···
     Pick<AppBskyActorDefs.SavedFeed, 'type' | 'value' | 'pinned'>[]
   >({
     mutationFn: async savedFeeds => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.addSavedFeeds(savedFeeds)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.addSavedFeeds(savedFeeds)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useRemoveFeedMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, Pick<AppBskyActorDefs.SavedFeed, 'id'>>({
     mutationFn: async savedFeed => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.removeSavedFeeds([savedFeed.id])
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.removeSavedFeeds([savedFeed.id])
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useReplaceForYouWithDiscoverFeedMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async ({
···
       forYouFeedConfig: AppBskyActorDefs.SavedFeed | undefined
       discoverFeedConfig: AppBskyActorDefs.SavedFeed | undefined
     }) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
       if (forYouFeedConfig) {
-        await agent.removeSavedFeeds([forYouFeedConfig.id])
+        await appviewAgent.removeSavedFeeds([forYouFeedConfig.id])
       }
       if (!discoverFeedConfig) {
-        await agent.addSavedFeeds([
+        await appviewAgent.addSavedFeeds([
           {
             type: 'feed',
             value: PROD_DEFAULT_FEED('Discover'),
···
           },
         ])
       } else {
-        await agent.updateSavedFeeds([
+        await appviewAgent.updateSavedFeeds([
           {
             ...discoverFeedConfig,
             pinned: true,
           },
         ])
       }
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useUpdateSavedFeedsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, AppBskyActorDefs.SavedFeed[]>({
     mutationFn: async feeds => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.updateSavedFeeds(feeds)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.updateSavedFeeds(feeds)
 
       // triggers a refetch
       await queryClient.invalidateQueries({
···
 
 export function useUpsertMutedWordsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (mutedWords: AppBskyActorDefs.MutedWord[]) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.upsertMutedWords(mutedWords)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.upsertMutedWords(mutedWords)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useUpdateMutedWordMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (mutedWord: AppBskyActorDefs.MutedWord) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.updateMutedWord(mutedWord)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.updateMutedWord(mutedWord)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useRemoveMutedWordMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (mutedWord: AppBskyActorDefs.MutedWord) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.removeMutedWord(mutedWord)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.removeMutedWord(mutedWord)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useRemoveMutedWordsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (mutedWords: AppBskyActorDefs.MutedWord[]) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.removeMutedWords(mutedWords)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.removeMutedWords(mutedWords)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useQueueNudgesMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (nudges: string | string[]) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.bskyAppQueueNudges(nudges)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.bskyAppQueueNudges(nudges)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useDismissNudgesMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (nudges: string | string[]) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.bskyAppDismissNudges(nudges)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.bskyAppDismissNudges(nudges)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useSetActiveProgressGuideMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation({
     mutationFn: async (
       guide: AppBskyActorDefs.BskyAppProgressGuide | undefined,
     ) => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.bskyAppSetActiveProgressGuide(guide)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.bskyAppSetActiveProgressGuide(guide)
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,
···
 
 export function useSetVerificationPrefsMutation() {
   const queryClient = useQueryClient()
-  const agent = useAgent()
 
   return useMutation<void, unknown, AppBskyActorDefs.VerificationPrefs>({
     mutationFn: async prefs => {
-      agent.configureProxy(PBLLC_BLUESKY_PROXY_HEADER.get())
-      await agent.setVerificationPrefs(prefs)
-      agent.configureProxy(BLUESKY_PROXY_HEADER.get())
+      const appviewAgent = getBskyAppviewAgent()
+      await appviewAgent.setVerificationPrefs(prefs)
       if (prefs.hideBadges) {
         logger.metric('verification:settings:hideBadges', {}, {statsig: true})
       } else {

src/state/session/index.tsx

···
   createAgentAndResume,
   sessionAccountToSession,
 } from './agent'
+import {getBskyAppviewAgent} from './appview-agent'
 import {type Action, getInitialState, reducer, type State} from './reducer'
 
 export {isSignupQueued} from './util'
···
       if (signal.aborted) {
         return
       }
+
+      // Initialize the appview agent with the account
+      getBskyAppviewAgent().initializeWithAccount(account)
+
       store.dispatch({
         type: 'switched-to-account',
         newAgent: agent,
···
       if (signal.aborted) {
         return
       }
+
+      // Initialize the appview agent with the account
+      getBskyAppviewAgent().initializeWithAccount(account)
+
       store.dispatch({
         type: 'switched-to-account',
         newAgent: agent,
···
     logContext => {
       addSessionDebugLog({type: 'method:start', method: 'logout'})
       cancelPendingTask()
+
+      // Clear the appview agent session
+      getBskyAppviewAgent().clearSession()
+
       store.dispatch({
         type: 'logged-out-current-account',
       })
···
     logContext => {
       addSessionDebugLog({type: 'method:start', method: 'logout'})
       cancelPendingTask()
+
+      // Clear the appview agent session
+      getBskyAppviewAgent().clearSession()
+
       store.dispatch({
         type: 'logged-out-every-account',
       })
···
       if (signal.aborted) {
         return
       }
+
+      // Initialize the appview agent with the account
+      getBskyAppviewAgent().initializeWithAccount(account)
+
       store.dispatch({
         type: 'switched-to-account',
         newAgent: agent,
···
           const agent = state.currentAgentState.agent as BskyAgent
           const prevSession = agent.session
           agent.sessionManager.session = sessionAccountToSession(syncedAccount)
+
+          // Also update the appview agent with the current session
+          getBskyAppviewAgent().initializeWithAccount(syncedAccount)
+
           addSessionDebugLog({
             type: 'agent:patch',
             agent,
···
   }
   return agent
 }
+
+// No need to export anything, getAppviewAgent is already imported directly where needed