refactor: move to new api client

src/api/mutations/post.ts

···
 	shadow: () => PostShadowView,
 ) => {
 	const queryClient = useQueryClient();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const postUri = post().uri;
···
 					return prevLikeUri;
 				}
 
-				const result = await createRecord(rpc, {
+				const result = await createRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.like',
 					record: {
···
 			} else if (prevLikeUri) {
 				const uri = parseCanonicalResourceUri(prevLikeUri);
 
-				await deleteRecord(rpc, {
+				await deleteRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.like',
 					rkey: uri.rkey,
···
 	shadow: () => PostShadowView,
 ) => {
 	const queryClient = useQueryClient();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const postUri = post().uri;
···
 					return prevRepostUri;
 				}
 
-				const result = await createRecord(rpc, {
+				const result = await createRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.repost',
 					record: {
···
 			} else if (prevRepostUri) {
 				const uri = parseCanonicalResourceUri(prevRepostUri);
 
-				await deleteRecord(rpc, {
+				await deleteRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.repost',
 					rkey: uri.rkey,

src/api/mutations/profile.ts

···
 	shadow: () => ProfileShadowView,
 ) => {
 	const queryClient = useQueryClient();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const did = profile().did;
···
 					return prevFollowUri;
 				}
 
-				const result = await createRecord(rpc, {
+				const result = await createRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.graph.follow',
 					record: {
···
 			} else if (prevFollowUri) {
 				const uri = parseCanonicalResourceUri(prevFollowUri);
 
-				await deleteRecord(rpc, {
+				await deleteRecord(client, {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.graph.follow',
 					rkey: uri.rkey,

src/api/queries/blob.ts

···
-import type { XRPC } from '@atcute/client';
+import { type Client, ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 
-export const uploadBlob = async (rpc: XRPC, blob: Blob): Promise<At.Blob<any>> => {
-	const { data } = await rpc.call('com.atproto.repo.uploadBlob', { data: blob });
+export const uploadBlob = async (client: Client, blob: Blob): Promise<At.Blob<any>> => {
+	const data = await ok(
+		client.post('com.atproto.repo.uploadBlob', {
+			input: blob,
+		}),
+	);
+
 	return data.blob;
 };

src/api/queries/bookmark-feed.ts

···
 import { tokenize } from '@atcute/bluesky-search-parser';
+import { ok } from '@atcute/client';
 import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
 import { mapDefined } from '@mary/array-fns';
 import { filter, map, take, toArray } from '@mary/async-iterator-fns';
···
 
 export const createBookmarkFeedQuery = (tagId: () => string, search: () => string) => {
 	const bookmarks = inject(BookmarksService);
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const listing = createInfiniteQuery(() => {
 		const $tagId = tagId();
···
 					let map: Map<string, AppBskyFeedDefs.PostView>;
 
 					try {
-						const { data } = await rpc.get('app.bsky.feed.getPosts', {
-							signal: ctx.signal,
-							params: {
-								uris: raws.map((item) => item.view.uri),
-							},
-						});
+						const data = await ok(
+							client.get('app.bsky.feed.getPosts', {
+								signal: ctx.signal,
+								params: {
+									uris: raws.map((item) => item.view.uri),
+								},
+							}),
+						);
 
 						map = new Map(data.posts.map((view) => [view.uri, view]));
 					} catch {}

src/api/queries/feed.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import { ok } from '@atcute/client';
 import type { AppBskyFeedDefs, At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 import { resolveHandle } from './handle';
 
 export const createFeedMetaQuery = (feedUri: () => string) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	return createQuery((queryClient) => {
···
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {
-					did = await resolveHandle(rpc, uri.repo, ctx.signal);
+					did = await resolveHandle(client, uri.repo, ctx.signal);
 				}
 
-				const { data } = await rpc.get('app.bsky.feed.getFeedGenerator', {
-					signal: ctx.signal,
-					params: {
-						feed: makeAtUri(did, uri.collection, uri.rkey),
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getFeedGenerator', {
+						signal: ctx.signal,
+						params: {
+							feed: makeAtUri(did, uri.collection, uri.rkey),
+						},
+					}),
+				);
 
 				if (currentAccount) {
 					const found = currentAccount.preferences.feeds.find((item): item is SavedGeneratorFeed => {

src/api/queries/handle.ts

···
-import { XRPC } from '@atcute/client';
+import { type Client, ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const useResolveHandleQuery = (handle: () => At.Handle) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createQuery(() => {
 		const $handle = handle();
···
 		return {
 			queryKey: ['resolve-handle', $handle],
 			async queryFn(ctx) {
-				return resolveHandle(rpc, $handle, ctx.signal);
+				return resolveHandle(client, $handle, ctx.signal);
 			},
 		};
 	});
 };
 
-export const resolveHandle = async (rpc: XRPC, handle: At.Handle, signal?: AbortSignal) => {
-	const { data } = await rpc.get('com.atproto.identity.resolveHandle', {
-		signal: signal,
-		params: {
-			handle: handle,
-		},
-	});
+export const resolveHandle = async (client: Client, handle: At.Handle, signal?: AbortSignal) => {
+	const data = await ok(
+		client.get('com.atproto.identity.resolveHandle', {
+			signal: signal,
+			params: {
+				handle: handle,
+			},
+		}),
+	);
 
 	return data.did;
 };

src/api/queries/labeler.ts

···
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError, ok } from '@atcute/client';
 import type { AppBskyLabelerDefs, At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 import { interpretLabelerDefinition } from '../moderation/labeler';
 
 export const createLabelerMetaQuery = (did: () => At.Did) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const query = createQuery(() => {
 		const $did = did();
···
 		return {
 			queryKey: ['labeler-definition', $did],
 			async queryFn(ctx) {
-				const { data } = await rpc.get('app.bsky.labeler.getServices', {
-					signal: ctx.signal,
-					params: {
-						dids: [$did],
-						detailed: true,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.labeler.getServices', {
+						signal: ctx.signal,
+						params: {
+							dids: [$did],
+							detailed: true,
+						},
+					}),
+				);
 
 				const service = data.views[0] as AppBskyLabelerDefs.LabelerViewDetailed;
 
 				if (!service) {
-					throw new XRPCError(400, {
-						kind: 'NotFound',
-						description: `Labeler not found: ${$did}`,
+					throw new ClientResponseError({
+						status: 400,
+						data: { error: `NotFound`, message: `Labeler not found: ${$did}` },
 					});
 				}
 

src/api/queries/list-members.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const createListMembersQuery = (listUri: () => At.ResourceUri) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const $listUri = listUri();
···
 		return {
 			queryKey: ['list-members', $listUri],
 			async queryFn(ctx: QC<never, string | undefined>) {
-				const { data } = await rpc.get('app.bsky.graph.getList', {
-					signal: ctx.signal,
-					params: {
-						list: $listUri,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getList', {
+						signal: ctx.signal,
+						params: {
+							list: $listUri,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return {
 					cursor: data.cursor,

src/api/queries/list.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import { ok } from '@atcute/client';
 import type { AppBskyGraphDefs, At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 import { resolveHandle } from './handle';
 
 export const createListMetaQuery = (listUri: () => string) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	return createQuery((queryClient) => {
···
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {
-					did = await resolveHandle(rpc, uri.repo, ctx.signal);
+					did = await resolveHandle(client, uri.repo, ctx.signal);
 				}
 
-				const { data } = await rpc.get('app.bsky.graph.getList', {
-					signal: ctx.signal,
-					params: {
-						list: makeAtUri(did, uri.collection, uri.rkey),
-						limit: 1,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getList', {
+						signal: ctx.signal,
+						params: {
+							list: makeAtUri(did, uri.collection, uri.rkey),
+							limit: 1,
+						},
+					}),
+				);
 
 				if (currentAccount) {
 					const found = currentAccount.preferences.feeds.find((item): item is SavedListFeed => {

src/api/queries/my-lists.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 export type MyListsFilter = 'all' | 'curation' | 'moderation' | 'all-including-subscribed';
 
 export const createMyListsQuery = (filter: MyListsFilter) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	return createQuery(() => ({
···
 		async queryFn({ signal }) {
 			const promises = [
 				accumulate(async (cursor) => {
-					const { data } = await rpc.get('app.bsky.graph.getLists', {
-						signal,
-						params: {
-							actor: currentAccount!.did,
-							cursor,
-							limit: 100,
-						},
-					});
+					const data = await ok(
+						client.get('app.bsky.graph.getLists', {
+							signal,
+							params: {
+								actor: currentAccount!.did,
+								cursor,
+								limit: 100,
+							},
+						}),
+					);
 
 					return {
 						cursor: data.cursor,
···
 			if (filter === 'all-including-subscribed' || filter === 'moderation') {
 				promises.push(
 					accumulate(async (cursor) => {
-						const { data } = await rpc.get('app.bsky.graph.getListMutes', {
-							signal,
-							params: {
-								cursor,
-								limit: 100,
-							},
-						});
+						const data = await ok(
+							client.get('app.bsky.graph.getListMutes', {
+								signal,
+								params: {
+									cursor,
+									limit: 100,
+								},
+							}),
+						);
 
 						return {
 							cursor: data.cursor,
···
 
 				promises.push(
 					accumulate(async (cursor) => {
-						const { data } = await rpc.get('app.bsky.graph.getListBlocks', {
-							signal,
-							params: {
-								cursor,
-								limit: 100,
-							},
-						});
+						const data = await ok(
+							client.get('app.bsky.graph.getListBlocks', {
+								signal,
+								params: {
+									cursor,
+									limit: 100,
+								},
+							}),
+						);
 
 						return {
 							cursor: data.cursor,

src/api/queries/notification-count.tsx

···
+import { ok } from '@atcute/client';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 
 export const createNotificationCountQuery = (options?: { readonly disabled?: boolean }) => {
 	const { currentAccount } = useSession();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const query = createQuery(() => ({
 		queryKey: ['notification', 'count'],
 		enabled: currentAccount !== undefined && !options?.disabled,
 		async queryFn() {
-			const { data } = await rpc.get('app.bsky.notification.getUnreadCount', {
-				params: {},
-			});
+			const data = await ok(
+				client.get('app.bsky.notification.getUnreadCount', {
+					params: {},
+				}),
+			);
 
 			return data;
 		},

src/api/queries/notification-feed.tsx

···
 import { createSignal } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import type { AppBskyFeedDefs, AppBskyNotificationListNotifications } from '@atcute/client/lexicons';
 import { chunked, mapDefined } from '@mary/array-fns';
 import { type QueryFunctionContext as QC, createInfiniteQuery, useQueryClient } from '@mary/solid-query';
···
 export type NotificationsFilter = 'all' | 'mentions';
 
 export const createNotificationFeedQuery = (filter: () => NotificationsFilter) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const queryClient = useQueryClient();
 
 	const [firstFetchedAt, setFirstFetchedAt] = createSignal(0);
···
 					reasons = ['mention', 'reply', 'quote'];
 				}
 
-				const { data } = await rpc.get('app.bsky.notification.listNotifications', {
-					signal: signal,
-					params: {
-						limit: 40,
-						reasons: reasons,
-						cursor: pageParam?.cursor,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.notification.listNotifications', {
+						signal: signal,
+						params: {
+							limit: 40,
+							reasons: reasons,
+							cursor: pageParam?.cursor,
+						},
+					}),
+				);
 
 				const notifs = data.notifications;
 				const firstSeenAt = pageParam?.seenAt;
···
 								const subjectUri = item.reasonSubject;
 
 								// skip if they're not related to posts.
-								if (!subjectUri || parseCanonicalResourceUri(subjectUri).collection !== 'app.bsky.feed.post') {
+								if (
+									!subjectUri ||
+									parseCanonicalResourceUri(subjectUri).collection !== 'app.bsky.feed.post'
+								) {
 									return;
 								}
 
···
 
 					const chunkedPosts = await Promise.all(
 						chunked(Array.from(postUris), 25).map(async (uris) => {
-							const { data } = await rpc.get('app.bsky.feed.getPosts', {
-								params: {
-									uris: uris,
-								},
-							});
+							const data = await ok(
+								client.get('app.bsky.feed.getPosts', {
+									params: {
+										uris: uris,
+									},
+								}),
+							);
 
 							return data.posts;
 						}),
···
 						const indexedAt = new Date(notifs[0]?.indexedAt ?? 0).getTime();
 						const seenAt = Math.max(now, indexedAt);
 
-						const promise = rpc.call('app.bsky.notification.updateSeen', {
-							data: {
-								seenAt: new Date(seenAt).toISOString(),
-							},
-						});
+						const promise = ok(
+							client.post('app.bsky.notification.updateSeen', {
+								as: null,
+								input: {
+									seenAt: new Date(seenAt).toISOString(),
+								},
+							}),
+						);
 
 						queryClient.cancelQueries({
 							exact: true,

src/api/queries/post-quotes.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyFeedGetQuotes, At } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const createPostQuotesQuery = (uri: () => At.ResourceUri) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const $uri = uri();
···
 			queryKey: ['post-quotes', $uri],
 			structuralSharing: false,
 			async queryFn(ctx: QC<never, string | undefined>): Promise<AppBskyFeedGetQuotes.Output> {
-				const { data } = await rpc.get('app.bsky.feed.getQuotes', {
-					signal: ctx.signal,
-					params: {
-						uri: $uri,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getQuotes', {
+						signal: ctx.signal,
+						params: {
+							uri: $uri,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return data;
 			},

src/api/queries/post-thread.ts

···
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError, ok } from '@atcute/client';
 import type { AppBskyFeedDefs, At, Brand } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 type ThreadReturn = Brand.Union<AppBskyFeedDefs.ThreadViewPost | AppBskyFeedDefs.BlockedPost>;
 
 export const usePostThreadQuery = (uri: () => At.ResourceUri) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createQuery((queryClient) => {
 		const $uri = uri();
···
 			queryKey: ['post-thread', $uri],
 			structuralSharing: false,
 			async queryFn(ctx): Promise<ThreadReturn> {
-				const { data } = await rpc.get('app.bsky.feed.getPostThread', {
-					signal: ctx.signal,
-					params: {
-						uri: $uri,
-						depth: MAX_DEPTH,
-						parentHeight: MAX_HEIGHT,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getPostThread', {
+						signal: ctx.signal,
+						params: {
+							uri: $uri,
+							depth: MAX_DEPTH,
+							parentHeight: MAX_HEIGHT,
+						},
+					}),
+				);
 
 				const thread = data.thread;
 
 				if (thread.$type === 'app.bsky.feed.defs#notFoundPost') {
-					throw new XRPCError(400, {
-						kind: 'NotFound',
-						description: `Post not found: ${$uri}`,
+					throw new ClientResponseError({
+						status: 400,
+						data: {
+							error: `NotFound`,
+							message: `Post not found: ${$uri}`,
+						},
 					});
 				}
 

src/api/queries/post.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 import { resolveHandle } from './handle';
 
 export const createPostQuery = (postUri: () => string) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createQuery((queryClient) => {
 		const $postUri = postUri();
···
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {
-					did = await resolveHandle(rpc, uri.repo, ctx.signal);
+					did = await resolveHandle(client, uri.repo, ctx.signal);
 				}
 
-				const { data } = await rpc.get('app.bsky.feed.getPosts', {
-					signal: ctx.signal,
-					params: {
-						uris: [makeAtUri(did, uri.collection, uri.rkey)],
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getPosts', {
+						signal: ctx.signal,
+						params: {
+							uris: [makeAtUri(did, uri.collection, uri.rkey)],
+						},
+					}),
+				);
 
 				const post = data.posts[0];
 

src/api/queries/profile-autocomplete.ts

···
+import { ok } from '@atcute/client';
 import { createQuery, keepPreviousData } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 	query: () => string,
 	opts?: ProfileAutocompleteQueryOptions,
 ) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createQuery(() => {
 		const $query = query();
···
 			enabled: isEnabled,
 			placeholderData: isEnabled ? keepPreviousData : undefined,
 			async queryFn({ signal }) {
-				const { data } = await rpc.get('app.bsky.actor.searchActorsTypeahead', {
-					signal,
-					params: {
-						q: trimmed,
-						limit: 10,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.actor.searchActorsTypeahead', {
+						signal,
+						params: {
+							q: trimmed,
+							limit: 10,
+						},
+					}),
+				);
 
 				return data;
 			},

src/api/queries/profile-feeds.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const createProfileFeedsQuery = (didOrHandle: () => At.Identifier) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const $didOrHandle = didOrHandle();
···
 		return {
 			queryKey: ['profile-feeds', $didOrHandle],
 			async queryFn(ctx: QC<never, string | undefined>) {
-				const { data } = await rpc.get('app.bsky.feed.getActorFeeds', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle,
-						limit: 100,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getActorFeeds', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle,
+							limit: 100,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				data.feeds.sort((a, b) => (b.likeCount ?? 0) - (a.likeCount ?? 0));
 				return data;

src/api/queries/profile-followers.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
···
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
 export const createProfileFollowersQuery = (didOrHandle: () => At.Identifier) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {
 		const $didOrHandle = didOrHandle();
···
 		return {
 			queryKey: ['profile-followers', $didOrHandle],
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListWithSubjectPage> {
-				const { data } = await rpc.get('app.bsky.graph.getFollowers', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getFollowers', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return toProfilesListWithSubjectPage(data, 'followers');
 			},

src/api/queries/profile-following.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
···
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
 export const createProfileFollowingQuery = (didOrHandle: () => At.Identifier) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {
 		const $didOrHandle = didOrHandle();
···
 		return {
 			queryKey: ['profile-following', $didOrHandle],
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListWithSubjectPage> {
-				const { data } = await rpc.get('app.bsky.graph.getFollows', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getFollows', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return toProfilesListWithSubjectPage(data, 'follows');
 			},

src/api/queries/profile-known-followers.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
···
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
 export const createProfileKnownFollowersQuery = (didOrHandle: () => At.Identifier) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {
 		const $didOrHandle = didOrHandle();
···
 		return {
 			queryKey: ['profile-known-followers', $didOrHandle],
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListWithSubjectPage> {
-				const { data } = await rpc.get('app.bsky.graph.getKnownFollowers', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getKnownFollowers', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return toProfilesListWithSubjectPage(data, 'followers');
 			},

src/api/queries/profile-lists.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const createProfileListsQuery = (didOrHandle: () => At.Identifier) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const collator = new Intl.Collator('en-US');
 
···
 		return {
 			queryKey: ['profile-lists', $didOrHandle],
 			async queryFn(ctx: QC<never, string | undefined>) {
-				const { data } = await rpc.get('app.bsky.graph.getLists', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle,
-						limit: 100,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.graph.getLists', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle,
+							limit: 100,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				data.lists.sort((a, b) => collator.compare(a.name, b.name));
 				return data;

src/api/queries/profile.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
···
 }
 
 export const createProfileQuery = (didOrHandle: () => At.Identifier, opts: ProfileQueryOptions = {}) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	return createQuery((queryClient) => {
···
 			staleTime: opts.staleTime,
 			gcTime: opts.gcTime,
 			async queryFn(ctx): Promise<AppBskyActorDefs.ProfileViewDetailed> {
-				const { data } = await rpc.get('app.bsky.actor.getProfile', {
-					signal: ctx.signal,
-					params: {
-						actor: $didOrHandle!,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.actor.getProfile', {
+						signal: ctx.signal,
+						params: {
+							actor: $didOrHandle!,
+						},
+					}),
+				);
 
 				if (currentAccount !== undefined && currentAccount.did === data.did) {
 					// Unset `knownFollowers` as we don't need that on our own profile.

src/api/queries/search-feeds.ts

···
+import { ok } from '@atcute/client';
 import type { AppBskyUnspeccedGetPopularFeedGenerators } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 export const createSearchFeedsQuery = (query: () => string) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const q = query();
···
 			async queryFn(
 				ctx: QC<never, string | undefined>,
 			): Promise<AppBskyUnspeccedGetPopularFeedGenerators.Output> {
-				const { data } = await rpc.get('app.bsky.unspecced.getPopularFeedGenerators', {
-					signal: ctx.signal,
-					params: {
-						query: q,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.unspecced.getPopularFeedGenerators', {
+						signal: ctx.signal,
+						params: {
+							query: q,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return data;
 			},

src/api/queries/search-profiles.ts

···
+import { ok } from '@atcute/client';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 import { type ProfilesListPage, toProfilesListPage } from '../types/profile-response';
 
 export const createSearchProfilesQuery = (query: () => string) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const q = query();
···
 		return {
 			queryKey: ['search-profiles', q],
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListPage> {
-				const { data } = await rpc.get('app.bsky.actor.searchActors', {
-					signal: ctx.signal,
-					params: {
-						q: q,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.actor.searchActors', {
+						signal: ctx.signal,
+						params: {
+							q: q,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return toProfilesListPage(data, 'actors');
 			},

src/api/queries/subject-likers.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import type { QueryFunctionContext as QC } from '@mary/solid-query';
 import { createInfiniteQuery } from '@mary/solid-query';
···
 import type { ProfilesListPage } from '../types/profile-response';
 
 export const createSubjectLikersQuery = (uri: () => At.ResourceUri) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const $uri = uri();
···
 			queryKey: ['subject-likers', $uri],
 			structuralSharing: false,
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListPage> {
-				const { data } = await rpc.get('app.bsky.feed.getLikes', {
-					signal: ctx.signal,
-					params: {
-						uri: $uri,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getLikes', {
+						signal: ctx.signal,
+						params: {
+							uri: $uri,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return {
 					cursor: data.cursor,

src/api/queries/subject-reposters.ts

···
+import { ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import type { QueryFunctionContext as QC } from '@mary/solid-query';
 import { createInfiniteQuery } from '@mary/solid-query';
···
 import { type ProfilesListPage, toProfilesListPage } from '../types/profile-response';
 
 export const createSubjectRepostersQuery = (uri: () => At.ResourceUri) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
 		const $uri = uri();
···
 			queryKey: ['subject-reposters', $uri],
 			structuralSharing: false,
 			async queryFn(ctx: QC<never, string | undefined>): Promise<ProfilesListPage> {
-				const { data } = await rpc.get('app.bsky.feed.getRepostedBy', {
-					signal: ctx.signal,
-					params: {
-						uri: $uri,
-						limit: 50,
-						cursor: ctx.pageParam,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getRepostedBy', {
+						signal: ctx.signal,
+						params: {
+							uri: $uri,
+							limit: 50,
+							cursor: ctx.pageParam,
+						},
+					}),
+				);
 
 				return toProfilesListPage(data, 'repostedBy');
 			},

src/api/queries/timeline.ts

···
 import { createEffect, createMemo, createRenderEffect, onCleanup, untrack } from 'solid-js';
 
-import type { XRPC } from '@atcute/client';
+import { type Client, ok } from '@atcute/client';
 import type { AppBskyFeedDefs, AppBskyFeedGetTimeline, AppBskyFeedPost, At } from '@atcute/client/lexicons';
 import { type FalsyValue, definite } from '@mary/array-fns';
 import { type InfiniteData, createInfiniteQuery, createQuery, useQueryClient } from '@mary/solid-query';
···
 export const useTimelineQuery = (_params: () => TimelineParams) => {
 	const getParams = createMemo(() => _params(), EQUALS_DEQUAL);
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 	const queryClient = useQueryClient();
 
···
 					postFilter = createLabelPostFilter(moderation);
 				}
 
-				const timeline = await fetchPage(rpc, params, limit, cursor, ctx.signal);
+				const timeline = await fetchPage(client, params, limit, cursor, ctx.signal);
 
 				const feed = timeline.feed;
 				const newCursor = timeline.cursor;
···
 				// const offset = params.type !== 'profile' ? timelineData!.pages[0].pinAmount : 0;
 				const offset = timelineData!.pages[0].pinAmount;
 
-				const timeline = await fetchPage(rpc, params, offset + 1, undefined, ctx.signal);
+				const timeline = await fetchPage(client, params, offset + 1, undefined, ctx.signal);
 				const feed = timeline.feed;
 
 				return { hash: getTimelineHash(feed) };
···
 
 //// Raw fetch
 const fetchPage = async (
-	rpc: XRPC,
+	client: Client,
 	params: TimelineParams,
 	limit: number,
 	cursor: string | undefined,
···
 	const type = params.type;
 
 	if (type === 'following') {
-		const response = await rpc.get('app.bsky.feed.getTimeline', {
-			signal: signal,
-			params: {
-				algorithm: 'reverse-chronological',
-				cursor: cursor,
-				limit: limit,
-			},
-		});
+		const data = await ok(
+			client.get('app.bsky.feed.getTimeline', {
+				signal: signal,
+				params: {
+					algorithm: 'reverse-chronological',
+					cursor: cursor,
+					limit: limit,
+				},
+			}),
+		);
 
-		return response.data;
+		return data;
 	} else if (type === 'feed') {
-		const response = await rpc.get('app.bsky.feed.getFeed', {
-			signal: signal,
-			headers: {
-				'accent-language': navigator.languages.join(','),
-			},
-			params: {
-				feed: params.uri,
-				cursor: cursor,
-				limit: limit,
-			},
-		});
-
-		const data = response.data;
+		const data = await ok(
+			client.get('app.bsky.feed.getFeed', {
+				signal: signal,
+				headers: {
+					'accent-language': navigator.languages.join(','),
+				},
+				params: {
+					feed: params.uri,
+					cursor: cursor,
+					limit: limit,
+				},
+			}),
+		);
 
 		return {
 			// Discover feed, wooo.
···
 			feed: data.feed,
 		};
 	} else if (type === 'list') {
-		const response = await rpc.get('app.bsky.feed.getListFeed', {
-			signal: signal,
-			params: {
-				list: params.uri,
-				cursor: cursor,
-				limit: limit,
-			},
-		});
-
-		return response.data;
-	} else if (type === 'profile') {
-		if (params.tab === 'likes') {
-			const response = await rpc.get('app.bsky.feed.getActorLikes', {
+		const data = await ok(
+			client.get('app.bsky.feed.getListFeed', {
 				signal: signal,
 				params: {
-					actor: params.actor,
+					list: params.uri,
 					cursor: cursor,
 					limit: limit,
 				},
-			});
+			}),
+		);
 
-			return response.data;
+		return data;
+	} else if (type === 'profile') {
+		if (params.tab === 'likes') {
+			const data = await ok(
+				client.get('app.bsky.feed.getActorLikes', {
+					signal: signal,
+					params: {
+						actor: params.actor,
+						cursor: cursor,
+						limit: limit,
+					},
+				}),
+			);
+
+			return data;
 		} else {
-			const response = await rpc.get('app.bsky.feed.getAuthorFeed', {
+			const data = await ok(
+				client.get('app.bsky.feed.getAuthorFeed', {
+					signal: signal,
+					params: {
+						actor: params.actor,
+						cursor: cursor,
+						limit: limit,
+						includePins: params.tab !== 'media',
+						filter:
+							params.tab === 'media'
+								? 'posts_with_media'
+								: params.tab === 'replies'
+									? 'posts_with_replies'
+									: 'posts_and_author_threads',
+					},
+				}),
+			);
+
+			return data;
+		}
+	} else if (type === 'search') {
+		const data = await ok(
+			client.get('app.bsky.feed.searchPosts', {
 				signal: signal,
 				params: {
-					actor: params.actor,
+					sort: params.sort,
+					q: params.query,
 					cursor: cursor,
 					limit: limit,
-					includePins: params.tab !== 'media',
-					filter:
-						params.tab === 'media'
-							? 'posts_with_media'
-							: params.tab === 'replies'
-								? 'posts_with_replies'
-								: 'posts_and_author_threads',
 				},
-			});
-
-			return response.data;
-		}
-	} else if (type === 'search') {
-		const response = await rpc.get('app.bsky.feed.searchPosts', {
-			signal: signal,
-			params: {
-				sort: params.sort,
-				q: params.query,
-				cursor: cursor,
-				limit: limit,
-			},
-		});
-
-		const data = response.data;
+			}),
+		);
 
 		return { cursor: data.cursor, feed: data.posts.map((view) => ({ post: view })) };
 	} else {

src/api/utils/did.ts

···
-import type { XRPC } from '@atcute/client';
+import { type Client, ok } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 
 import { isDid } from '../types/identity';
 
-const getDid = async (rpc: XRPC, actor: At.Handle, signal?: AbortSignal) => {
+const getDid = async (client: Client, actor: At.Handle, signal?: AbortSignal) => {
 	let did: At.Did;
 	if (isDid(actor)) {
 		did = actor;
 	} else {
-		const response = await rpc.get('com.atproto.identity.resolveHandle', {
-			signal: signal,
-			params: { handle: actor },
-		});
+		const data = await ok(
+			client.get('com.atproto.identity.resolveHandle', {
+				signal: signal,
+				params: { handle: actor },
+			}),
+		);
 
-		did = response.data.did;
+		did = data.did;
 	}
 
 	return did;

src/api/utils/error.ts

···
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import { TokenRefreshError } from '@atcute/oauth-browser-client';
 
-export const formatXRPCError = (err: XRPCError): string => {
-	const name = err.kind;
+export const formatXRPCError = (err: ClientResponseError): string => {
+	const name = err.error;
 	return (name ? name + ': ' : '') + err.description;
 };
 
···
 		return `Account session is no longer valid`;
 	}
 
-	if (err instanceof XRPCError) {
-		const kind = err.kind;
+	if (err instanceof ClientResponseError) {
+		const kind = err.error;
 
 		if (kind === 'invalid_token') {
 			return `Account session is no longer valid`;

src/api/utils/records.ts

···
-import type { XRPC } from '@atcute/client';
+import { type Client, ok } from '@atcute/client';
 import type {
 	At,
 	ComAtprotoRepoGetRecord,
···
 	validate?: boolean;
 }
 
-export const createRecord = async <K extends RecordType>(rpc: XRPC, options: CreateRecordOptions<K>) => {
-	const { data } = await rpc.call('com.atproto.repo.createRecord', { data: options });
+export const createRecord = async <K extends RecordType>(client: Client, options: CreateRecordOptions<K>) => {
+	const data = await ok(
+		client.post('com.atproto.repo.createRecord', {
+			input: options,
+		}),
+	);
 
 	return data;
 };
···
 	validate?: boolean;
 }
 
-export const putRecord = async <K extends RecordType>(rpc: XRPC, options: PutRecordOptions<K>) => {
-	const { data } = await rpc.call('com.atproto.repo.putRecord', { data: options });
+export const putRecord = async <K extends RecordType>(client: Client, options: PutRecordOptions<K>) => {
+	const data = await ok(
+		client.post('com.atproto.repo.putRecord', {
+			input: options,
+		}),
+	);
 
 	return data;
 };
···
 	swapRecord?: string;
 }
 
-export const deleteRecord = async <K extends RecordType>(rpc: XRPC, options: DeleteRecordOptions<K>) => {
-	await rpc.call('com.atproto.repo.deleteRecord', {
-		data: options,
-	});
+export const deleteRecord = async <K extends RecordType>(client: Client, options: DeleteRecordOptions<K>) => {
+	await ok(
+		client.post('com.atproto.repo.deleteRecord', {
+			input: options,
+		}),
+	);
 };
 
 export interface GetRecordOptions<K extends RecordType> {
+	signal?: AbortSignal;
 	repo: At.Did;
 	collection: K;
 	rkey: string;
···
 }
 
 export const getRecord = async <K extends RecordType>(
-	rpc: XRPC,
+	client: Client,
 	options: GetRecordOptions<K>,
 ): Promise<GetRecordOutput<Records[K]>> => {
-	const { data } = await rpc.get('com.atproto.repo.getRecord', {
-		params: options,
-	});
+	const data = await ok(
+		client.get('com.atproto.repo.getRecord', {
+			signal: options.signal,
+			params: {
+				repo: options.repo,
+				collection: options.collection,
+				rkey: options.rkey,
+				cid: options.cid,
+			},
+		}),
+	);
 
 	return data as any;
 };
···
 }
 
 export const listRecords = async <K extends RecordType>(
-	rpc: XRPC,
+	client: Client,
 	options: ListRecordsOptions<K>,
 ): Promise<ListRecordsOutput<Records[K]>> => {
-	const { data } = await rpc.get('com.atproto.repo.listRecords', {
-		signal: options.signal,
-		params: {
-			repo: options.repo,
-			collection: options.collection,
-			limit: options.limit,
-			cursor: options.cursor,
-		},
-	});
+	const data = await ok(
+		client.get('com.atproto.repo.listRecords', {
+			signal: options.signal,
+			params: {
+				repo: options.repo,
+				collection: options.collection,
+				limit: options.limit,
+				cursor: options.cursor,
+			},
+		}),
+	);
 
 	return data as any;
 };

src/basa-env.d.ts

···
 
 	interface Queries {
 		'x.basa.describeServer': {
+			response: { json: XBasaDescribeServer.Output };
+			/** @deprecated */
 			output: XBasaDescribeServer.Output;
 		};
 		'x.basa.translate': {
 			params: XBasaTranslate.Params;
+			response: { json: XBasaTranslate.Output };
+			/** @deprecated */
 			output: XBasaTranslate.Output;
 		};
 	}

src/components/composer/composer-input.tsx

···
 	createSignal,
 } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 
 import { safeUrlParse } from '~/api/utils/strings';
···
 	const onChange = props.onChange;
 	const onSubmit = props.onSubmit;
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const [inputCursor, setInputCursor] = createSignal<number>();
 	const [menuSelection, setMenuSelection] = createSignal<number>();
···
 			const MATCH_LIMIT = 5;
 
 			if (type === Suggestion.MENTION) {
-				const response = await rpc.get('app.bsky.actor.searchActorsTypeahead', {
-					params: {
-						q: match.query,
-						limit: MATCH_LIMIT,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.actor.searchActorsTypeahead', {
+						params: {
+							q: match.query,
+							limit: MATCH_LIMIT,
+						},
+					}),
+				);
 
-				return response.data.actors.map((item) => ({ type: Suggestion.MENTION, data: item }));
+				return data.actors.map((item) => ({ type: Suggestion.MENTION, data: item }));
 			}
 
 			assert(false, `expected match`);

src/components/composer/lib/api.ts

···
 import { nanoid } from 'nanoid/non-secure';
 
-import { XRPC, XRPCError, simpleFetchHandler } from '@atcute/client';
+import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
 import type {
 	AppBskyEmbedImages,
 	AppBskyEmbedRecord,
···
 let cidPromise: Promise<typeof import('./cid')>;
 
 export const publish = async ({ agent, queryClient, state, onLog: log }: PublishOptions) => {
-	const rpc = agent.rpc;
+	const client = agent.client;
 	const did = agent.did!;
 
 	const now = new Date();
···
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {
-					did = await resolveHandle(rpc, uri.repo, ctx.signal);
+					did = await resolveHandle(client, uri.repo, ctx.signal);
 				}
 
-				const { data } = await rpc.get('app.bsky.feed.getPosts', {
-					signal: ctx.signal,
-					params: {
-						uris: [makeAtUri(did, uri.collection, uri.rkey)],
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.feed.getPosts', {
+						signal: ctx.signal,
+						params: {
+							uris: [makeAtUri(did, uri.collection, uri.rkey)],
+						},
+					}),
+				);
 
 				const post = data.posts[0];
 
···
 
 	log?.(`Posting`);
 
-	await rpc.call('com.atproto.repo.applyWrites', {
-		data: {
-			repo: did,
-			writes: writes,
-		},
-	});
+	await ok(
+		client.post('com.atproto.repo.applyWrites', {
+			input: {
+				repo: did,
+				writes: writes,
+			},
+		}),
+	);
 
 	if (state.redraftUri) {
 		updatePostShadow(queryClient, state.redraftUri, { deleted: true });
···
 
 						switch (source.type) {
 							case 'local': {
-								const uploaded = await uploadBlob(rpc, source.blob);
+								const uploaded = await uploadBlob(client, source.blob);
 
 								return {
 									image: uploaded,
···
 
 				const blob = source.blob;
 
-				const videoRpc = new XRPC({ handler: simpleFetchHandler({ service: 'https://video.bsky.app' }) });
+				const videoClient = new Client({
+					handler: simpleFetchHandler({ service: 'https://video.bsky.app' }),
+				});
 
 				// Get upload limit status
 				{
···
 					// GET https://porcini.us-east.host.bsky.network/xrpc/chat.bsky.convo.getLog
 					// atproto-proxy: did:web:api.bsky.chat#bsky_chat
 					//
-					const { data: tokenData } = await rpc.get('com.atproto.server.getServiceAuth', {
-						params: {
-							aud: 'did:web:video.bsky.app',
-							lxm: 'app.bsky.video.getUploadLimits',
-						},
-					});
+					const tokenData = await ok(
+						client.get('com.atproto.server.getServiceAuth', {
+							params: {
+								aud: 'did:web:video.bsky.app',
+								lxm: 'app.bsky.video.getUploadLimits',
+							},
+						}),
+					);
 
-					const { data } = await videoRpc.get('app.bsky.video.getUploadLimits', {
-						headers: {
-							authorization: `Bearer ${tokenData.token}`,
-						},
-					});
+					const data = await ok(
+						videoClient.get('app.bsky.video.getUploadLimits', {
+							headers: {
+								authorization: `Bearer ${tokenData.token}`,
+							},
+						}),
+					);
 
 					if (!data.canUpload) {
 						let message = data.message || `You've reached the limit on video uploads`;
···
 
 					// Create an access token *to the PDS*, allowing the video service to
 					// upload the final blobs to our repository on our behalf.
-					const { data: tokenData } = await rpc.get('com.atproto.server.getServiceAuth', {
-						params: {
-							// `did:web:porcini.us-east.host.bsky.network`
-							aud: `did:web:${new URL(session.info.aud).host}`,
-							lxm: 'com.atproto.repo.uploadBlob',
-							exp: Date.now() / 1000 + 60 * 30, // 30 minutes
-						},
-					});
+					const tokenData = await ok(
+						client.get('com.atproto.server.getServiceAuth', {
+							params: {
+								// `did:web:porcini.us-east.host.bsky.network`
+								aud: `did:web:${new URL(session.info.aud).host}`,
+								lxm: 'com.atproto.repo.uploadBlob',
+								exp: Date.now() / 1000 + 60 * 30, // 30 minutes
+							},
+						}),
+					);
 
 					jobId = await new Promise((resolve, reject) => {
 						const xhr = new XMLHttpRequest();
···
 						let status: AppBskyVideoDefs.JobStatus;
 
 						try {
-							const { data } = await videoRpc.get('app.bsky.video.getJobStatus', {
-								params: {
-									jobId: jobId,
-								},
-							});
+							const data = await ok(
+								videoClient.get('app.bsky.video.getJobStatus', {
+									params: {
+										jobId: jobId,
+									},
+								}),
+							);
 
 							status = data.jobStatus;
 							pollFailures = 0;
···
 
 					log?.(`Uploading GIF thumbnail`);
 					const compressed = await compressPostImage(gifBlob);
-					const blob = await uploadBlob(rpc, compressed.blob);
+					const blob = await uploadBlob(client, compressed.blob);
 
 					thumbBlob = blob;
 				}
···
 				log?.(`Uploading link thumbnail`);
 
 				const compressed = await compressPostImage(thumb);
-				const blob = await uploadBlob(rpc, compressed.blob);
+				const blob = await uploadBlob(client, compressed.blob);
 
 				thumbBlob = blob;
 			}
···
 				}
 
 				try {
-					const response = await rpc.get('com.atproto.identity.resolveHandle', {
-						params: {
-							handle: handle,
-						},
-					});
+					const data = await ok(
+						client.get('com.atproto.identity.resolveHandle', {
+							params: {
+								handle: handle,
+							},
+						}),
+					);
 
-					const did = response.data.did;
+					const did = data.did;
 
 					if (!hasSilent) {
 						facets.push({
···
 						});
 					}
 				} catch (err) {
-					if (err instanceof XRPCError && err.kind === 'InvalidRequest') {
+					if (err instanceof ClientResponseError && err.error === 'InvalidRequest') {
 						throw new InvalidHandleError(handle);
 					}
 
···
 					features: [{ $type: 'app.bsky.richtext.facet#tag', tag: token.name }],
 				});
 			} else if (type === 'emote') {
-				const { value } = await getRecord(rpc, {
+				const { value } = await getRecord(client, {
 					repo: did,
 					collection: 'blue.moji.collection.item',
 					rkey: token.name,

src/components/error-view.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 import { TokenRefreshError } from '@atcute/oauth-browser-client';
 import { useQueryClient } from '@mary/solid-query';
···
 export default ErrorView;
 
 const isInvalidTokenError = (err: unknown): boolean => {
-	return err instanceof TokenRefreshError || (err instanceof XRPCError && err.kind === 'invalid_token');
+	return (
+		err instanceof TokenRefreshError || (err instanceof ClientResponseError && err.error === 'invalid_token')
+	);
 };

src/components/moderation/block-account-prompt.tsx

···
 	const { close } = useModalContext();
 
 	const { currentAccount } = useSession();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const mutation = createMutation((queryClient) => ({
 		async mutationFn() {
-			return await createRecord(rpc, {
+			return await createRecord(client, {
 				repo: currentAccount!.did,
 				collection: 'app.bsky.graph.block',
 				record: {
···
 const UnblockPrompt = (props: BlockAccountPromptInnerProps) => {
 	const { close } = useModalContext();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const mutation = createMutation((queryClient) => ({
 		async mutationFn() {
 			const { repo, rkey } = parseCanonicalResourceUri(props.shadow.blockUri!);
 
-			return await deleteRecord(rpc, {
+			return await deleteRecord(client, {
 				repo: repo as At.Did,
 				collection: 'app.bsky.graph.block',
 				rkey: rkey,

src/components/moderation/mute-account-prompt.tsx

···
 import { Match, Switch, onMount } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 import { createMutation } from '@mary/solid-query';
 
···
 const MutePrompt = ({ profile }: MuteAccountPromptProps) => {
 	const { close } = useModalContext();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const mutation = createMutation((queryClient) => ({
 		async mutationFn() {
-			await rpc.call('app.bsky.graph.muteActor', {
-				data: {
-					actor: profile.did,
-				},
-			});
+			await ok(
+				client.post('app.bsky.graph.muteActor', {
+					as: null,
+					input: {
+						actor: profile.did,
+					},
+				}),
+			);
 		},
 		onSuccess() {
 			close();
···
 const UnmutePrompt = ({ profile }: MuteAccountPromptProps) => {
 	const { close } = useModalContext();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const mutation = createMutation((queryClient) => ({
 		async mutationFn() {
-			await rpc.call('app.bsky.graph.unmuteActor', {
-				data: {
-					actor: profile.did,
-				},
-			});
+			await ok(
+				client.post('app.bsky.graph.unmuteActor', {
+					as: null,
+					input: {
+						actor: profile.did,
+					},
+				}),
+			);
 		},
 		onSuccess() {
 			close();

src/components/profiles/edit-profile-dialog.tsx

···
 import { Show, createMemo, createSignal } from 'solid-js';
 
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { createMutation } from '@mary/solid-query';
 
···
 const EditProfileDialog = ({ profile }: EditProfileDialogProps) => {
 	const { close } = useModalContext();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const snapshot = {
···
 			let bannerPromise: Promise<At.Blob<any>> | undefined;
 
 			if ($avatar instanceof Blob) {
-				avatarPromise = compressProfileImage($avatar, 1000, 1000).then((res) => uploadBlob(rpc, res.blob));
+				avatarPromise = compressProfileImage($avatar, 1000, 1000).then((res) => uploadBlob(client, res.blob));
 			}
 			if ($banner instanceof Blob) {
-				bannerPromise = compressProfileImage($banner, 3000, 1000).then((res) => uploadBlob(rpc, res.blob));
+				bannerPromise = compressProfileImage($banner, 3000, 1000).then((res) => uploadBlob(client, res.blob));
 			}
 
 			let retriesRemaining = 3;
 			while (true) {
-				const existing = await getRecord(rpc, {
+				const existing = await getRecord(client, {
 					repo,
 					collection: 'app.bsky.actor.profile',
 					rkey: 'self',
···
 				}
 
 				try {
-					await putRecord(rpc, {
+					await putRecord(client, {
 						repo,
 						collection: 'app.bsky.actor.profile',
 						rkey: 'self',
···
 						swapRecord: existing?.cid ?? null,
 					});
 				} catch (err) {
-					if (err instanceof XRPCError && err.kind === 'InvalidSwapError') {
+					if (err instanceof ClientResponseError && err.error === 'InvalidSwapError') {
 						if (retriesRemaining--) {
 							continue;
 						}

src/components/search/suggestions/from-actor-autocompletion-view.tsx

···
 import { For, Show, createMemo } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import { createQuery, keepPreviousData } from '@mary/solid-query';
 
 import { createProfileQuery } from '~/api/queries/profile';
···
 }) => {
 	const { currentAccount } = useSession();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const isFocused = useIsFocused();
 
 	const match = createMemo(() => {
···
 			enabled: $match !== '' && isFocused(),
 			placeholderData: keepPreviousData,
 			async queryFn({ signal }) {
-				const { data } = await rpc.get('app.bsky.actor.searchActorsTypeahead', {
-					signal,
-					params: {
-						q: $match,
-						limit: 10,
-					},
-				});
+				const data = await ok(
+					client.get('app.bsky.actor.searchActorsTypeahead', {
+						signal,
+						params: {
+							q: $match,
+							limit: 10,
+						},
+					}),
+				);
 
 				return data;
 			},

src/components/settings/app-passwords/add-app-password-prompt.tsx

···
 import { Match, Switch, createSignal } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import { createMutation } from '@mary/solid-query';
 
 import { autofocusNode, modelChecked, modelText } from '~/lib/input-refs';
···
 export interface AddAppPasswordPromptProps {}
 
 const AddAppPasswordPrompt = ({}: AddAppPasswordPromptProps) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const [name, setName] = createSignal('');
 	const [privileged, setPrivileged] = createSignal(false);
···
 	const mutation = createMutation((queryClient) => {
 		return {
 			async mutationFn() {
-				const { data } = await rpc.call('com.atproto.server.createAppPassword', {
-					data: {
-						name: name().replace(/^\s+|\s+$|(?<=\s)\s+/g, ''),
-						privileged: privileged(),
-					},
-				});
+				const data = await ok(
+					client.post('com.atproto.server.createAppPassword', {
+						input: {
+							name: name().replace(/^\s+|\s+$|(?<=\s)\s+/g, ''),
+							privileged: privileged(),
+						},
+					}),
+				);
 
 				return data;
 			},

src/components/settings/bluemoji/add-emote-prompt.tsx

···
 const AddEmotePrompt = ({ blob, onAdd }: AddEmotePromptProps) => {
 	const { close } = useModalContext();
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const blobUrl = URL.createObjectURL(blob);
···
 
 			const { png_128, webp_128 } = await getCompressedEmotes(blob, cover() ? 'cover' : 'contain');
 
-			const orig_prom = uploadBlob(rpc, blob);
-			const png_prom = png_128 !== blob ? uploadBlob(rpc, png_128) : orig_prom;
-			const webp_prom = webp_128 !== blob ? uploadBlob(rpc, webp_128) : orig_prom;
+			const orig_prom = uploadBlob(client, blob);
+			const png_prom = png_128 !== blob ? uploadBlob(client, png_128) : orig_prom;
+			const webp_prom = webp_128 !== blob ? uploadBlob(client, webp_128) : orig_prom;
 
 			const [orig_blob, png_blob, webp_blob] = await Promise.all([orig_prom, png_prom, webp_prom]);
 
-			await createRecord(rpc, {
+			await createRecord(client, {
 				repo: currentAccount!.did,
 				collection: 'blue.moji.collection.item',
 				rkey: $name,

src/components/settings/content-translation/add-basa-instance-prompt.tsx

···
 import { createMemo, createSignal } from 'solid-js';
 
-import { XRPC, simpleFetchHandler } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 import { createMutation } from '@mary/solid-query';
 
 import { formatQueryError } from '~/api/utils/error';
···
 
 	const mutation = createMutation(() => ({
 		async mutationFn({ url }: { url: URL }) {
-			const rpc = new XRPC({ handler: simpleFetchHandler({ service: url }) });
-			await rpc.get('x.basa.describeServer', {});
+			const client = new Client({ handler: simpleFetchHandler({ service: url }) });
+			await ok(client.get('x.basa.describeServer'));
 		},
 		onSuccess(_data, { url }) {
 			const href = url.toString();

src/components/threads/post-translation.tsx

···
 import { Match, Switch, createMemo, createSignal } from 'solid-js';
 
-import { XRPC, simpleFetchHandler } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 import { sampleOne } from '@mary/array-fns';
 import { createQuery } from '@mary/solid-query';
 
···
 					targetLang = found;
 				}
 
-				console.log(targetLang);
-
-				const rpc = new XRPC({ handler: simpleFetchHandler({ service: $instanceUrl! }) });
-				const { data } = await rpc.get('x.basa.translate', {
-					params: {
-						engine: 'google',
-						text: $text,
-						from: $source,
-						to: targetLang,
-					},
-				});
+				const client = new Client({ handler: simpleFetchHandler({ service: $instanceUrl! }) });
+				const data = await ok(
+					client.get('x.basa.translate', {
+						params: {
+							engine: 'google',
+							text: $text,
+							from: $source,
+							to: targetLang,
+						},
+					}),
+				);
 
 				return data;
 			},

src/components/timeline/delete-post-prompt.tsx

···
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError, ok } from '@atcute/client';
 import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
···
 
 const DeletePostPrompt = ({ post, onPostDelete }: DeletePostPromptProps) => {
 	const { currentAccount } = useSession();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const queryClient = useQueryClient();
 
-	const onDelete = () => {
+	const onDelete = async () => {
 		const uri = parseCanonicalResourceUri(post.uri);
 
-		const promise = rpc.call('com.atproto.repo.applyWrites', {
-			data: {
+		const write = await client.post('com.atproto.repo.applyWrites', {
+			input: {
 				repo: currentAccount!.did,
 				writes: [
 					{
···
 			},
 		});
 
-		promise.then(
-			() => {
-				updatePostShadow(queryClient, post.uri, { deleted: true });
-				onPostDelete?.();
-			},
-			async (err) => {
-				if (err instanceof XRPCError && err.kind === 'InternalServerError') {
-					await rpc.call('com.atproto.repo.putRecord', {
-						data: {
-							repo: currentAccount!.did,
-							collection: 'app.bsky.feed.post',
-							rkey: uri.rkey,
-							validate: false,
-							record: {
-								$type: 'app.bsky.feed.post',
-								text: '',
-								createdAt: '1970-01-01T00:00:00.000Z',
-							} satisfies AppBskyFeedPost.Record,
-						},
-					});
+		if (write.ok) {
+			updatePostShadow(queryClient, post.uri, { deleted: true });
+			onPostDelete?.();
+			return;
+		}
 
-					await rpc.call('com.atproto.repo.deleteRecord', {
-						data: {
-							repo: currentAccount!.did,
-							collection: 'app.bsky.feed.post',
-							rkey: uri.rkey,
-						},
-					});
+		if (write.data.error !== 'InternalServerError') {
+			throw new ClientResponseError(write);
+		}
 
-					updatePostShadow(queryClient, post.uri, { deleted: true });
-					onPostDelete?.();
-					return;
-				}
+		await ok(
+			client.post('com.atproto.repo.putRecord', {
+				input: {
+					repo: currentAccount!.did,
+					collection: 'app.bsky.feed.post',
+					rkey: uri.rkey,
+					validate: false,
+					record: {
+						$type: 'app.bsky.feed.post',
+						text: '',
+						createdAt: '1970-01-01T00:00:00.000Z',
+					} satisfies AppBskyFeedPost.Record,
+				},
+			}),
+		);
 
-				throw err;
-			},
+		await ok(
+			client.post('com.atproto.repo.deleteRecord', {
+				input: {
+					repo: currentAccount!.did,
+					collection: 'app.bsky.feed.post',
+					rkey: uri.rkey,
+				},
+			}),
 		);
+
+		updatePostShadow(queryClient, post.uri, { deleted: true });
+		onPostDelete?.();
 	};
 
 	return (

src/components/timeline/pin-post-prompt.tsx

···
 import { Match, Show, Switch, batch } from 'solid-js';
 
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
 import { createMutation } from '@mary/solid-query';
 
···
 
 const PinPostPrompt = ({ post }: PinPostPromptProps) => {
 	const { currentAccount } = useSession();
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const { close } = useModalContext();
 
···
 				updatePostShadow(queryClient, post.uri, { pinned: next });
 
 				while (true) {
-					const existing = await getRecord(rpc, {
+					const existing = await getRecord(client, {
 						repo,
 						collection: 'app.bsky.actor.profile',
 						rkey: 'self',
···
 					record.pinnedPost = next ? { uri: post.uri, cid: post.cid } : undefined;
 
 					try {
-						await putRecord(rpc, {
+						await putRecord(client, {
 							repo,
 							collection: 'app.bsky.actor.profile',
 							rkey: 'self',
···
 							swapRecord: existing?.cid ?? null,
 						});
 					} catch (err) {
-						if (err instanceof XRPCError && err.kind === 'InvalidSwapError') {
+						if (err instanceof ClientResponseError && err.error === 'InvalidSwapError') {
 							if (retriesRemaining--) {
 								continue;
 							}

src/lib/states/agent.tsx

···
 import { type JSX, type ParentProps, createContext, createMemo, useContext } from 'solid-js';
 
-import { XRPC, simpleFetchHandler } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import type { OAuthUserAgent } from '@atcute/oauth-browser-client';
 import { QueryClient, QueryClientProvider } from '@mary/solid-query';
···
 
 export interface AgentContext {
 	did: At.Did | null;
-	rpc: XRPC;
+	client: Client;
 	handler: OAuthUserAgent | null;
 	persister: ReturnType<typeof createQueryPersister>;
 }
···
 			return {
 				did: currentAccount.did,
 				handler: currentAccount.agent ?? null,
-				rpc: currentAccount.rpc,
+				client: currentAccount.client,
 				persister: createQueryPersister({ name: `queryCache-${currentAccount.did}` }),
 			};
 		}
···
 		return {
 			did: null,
 			handler: null,
-			rpc: new XRPC({ handler: simpleFetchHandler({ service: DEFAULT_APPVIEW_URL }) }),
+			client: new Client({ handler: simpleFetchHandler({ service: DEFAULT_APPVIEW_URL }) }),
 			persister: createQueryPersister({ name: `queryCache-public` }),
 		};
 	});

src/lib/states/session.tsx

···
 	useContext,
 } from 'solid-js';
 
-import { type FetchHandler, type FetchHandlerObject, XRPC, XRPCError } from '@atcute/client';
+import { Client, ClientResponseError, type FetchHandler, type FetchHandlerObject } from '@atcute/client';
 import type { At } from '@atcute/client/lexicons';
 import { OAuthUserAgent, deleteStoredSession, getSession } from '@atcute/oauth-browser-client';
 import { mapDefined } from '@mary/array-fns';
···
 	readonly data: AccountData;
 	readonly preferences: PerAccountPreferenceSchema;
 
-	readonly rpc: XRPC;
+	readonly client: Client;
 	readonly agent: OAuthUserAgent | undefined;
 	readonly _cleanup: () => void;
 }
···
 	const createAccountState = (
 		did: At.Did,
 		session: OAuthUserAgent | undefined,
-		rpc: XRPC,
+		client: Client,
 	): CurrentAccountState => {
 		return createRoot((cleanup): CurrentAccountState => {
 			const preferences = createAccountPreferences(did);
···
 			});
 
 			// A bit of a hack, but works right now.
-			rpc.handle = attachLabelerHeaders(rpc.handle, labelers);
+			client.handler = attachLabelerHeaders(client.handler, labelers);
 
 			createEffect(() => {
 				const signal = abortable();
···
 					return $data;
 				},
 
-				rpc: rpc,
+				client: client,
 				agent: session,
 				_cleanup: cleanup,
 			};
···
 				// Dirty hack to account for the fact that we aren't dumping the user
 				// directly to the login modal.
 				handler = () => {
-					throw new XRPCError(400, { kind: 'invalid_token' });
+					throw new ClientResponseError({ status: 400, data: { error: 'invalid_token' } });
 				};
 			}
 
-			const rpc = new XRPC({ handler });
+			const rpc = new Client({ handler });
 
 			signal.throwIfAborted();
 

src/lib/states/singletons/moderation.ts

···
 import { createMemo } from 'solid-js';
 import { unwrap } from 'solid-js/store';
 
-import type { AppBskyLabelerDefs, At } from '@atcute/client/lexicons';
+import { ok } from '@atcute/client';
+import type { At } from '@atcute/client/lexicons';
 import { mapDefined } from '@mary/array-fns';
 import { createBatchedFetch } from '@mary/batch-fetch';
 import { type QueryFunctionContext as QC, createQueries } from '@mary/solid-query';
···
 import { useSession } from '../session';
 import { define } from '../singleton';
 
-type Labeler = AppBskyLabelerDefs.LabelerViewDetailed;
-
 const ModerationService = define('moderation', () => {
-	const { rpc, persister } = useAgent();
+	const { client, persister } = useAgent();
 	const { currentAccount } = useSession();
 
 	const modPreferences = createMemo((): ModerationPreferences => {
···
 		timeout: 1,
 		idFromResource: (labeler) => labeler.did,
 		async fetch(dids, signal) {
-			const { data } = await rpc.get('app.bsky.labeler.getServices', {
-				signal,
-				params: {
-					dids: dids,
-					detailed: true,
-				},
-			});
-
-			const views = data.views as Labeler[];
+			const data = await ok(
+				client.get('app.bsky.labeler.getServices', {
+					signal,
+					params: {
+						dids: dids,
+						detailed: true,
+					},
+				}),
+			);
 
+			const views = data.views.filter((view) => view.$type === 'app.bsky.labeler.defs#labelerViewDetailed');
 			return views.map((view) => interpretLabelerDefinition(view));
 		},
 	});

src/views/bluemoji-emotes.tsx

···
 		openModal(() => <AddEmotePrompt blob={blob} onAdd={() => {}} />);
 	};
 
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 	const { currentAccount } = useSession();
 
 	const query = createInfiniteQuery(() => ({
 		queryKey: ['bluemoji', 'emotes'],
 		async queryFn(ctx) {
-			return listRecords(rpc, {
+			return listRecords(client, {
 				repo: currentAccount!.did,
 				collection: 'blue.moji.collection.item',
 				limit: 100,

src/views/oauth-callback.tsx

···
 import { Match, Switch, createResource } from 'solid-js';
 
-import { XRPC } from '@atcute/client';
+import { Client, ok } from '@atcute/client';
 import {
 	AuthorizationError,
 	OAuthResponseError,
···
 		const did = session.info.sub;
 
 		const agent = new OAuthUserAgent(session);
-		const rpc = new XRPC({ handler: agent });
+		const client = new Client({ handler: agent });
 
-		const { data: profile } = await rpc.get('app.bsky.actor.getProfile', {
-			params: {
-				actor: did,
-			},
-		});
+		const profile = await ok(
+			client.get('app.bsky.actor.getProfile', {
+				params: {
+					actor: did,
+				},
+			}),
+		);
 
 		{
 			// Update UI preferences

src/views/post-thread.tsx

···
 import { For, Match, Switch, createEffect, createMemo, createSignal } from 'solid-js';
 
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { AppBskyFeedDefs, AppBskyFeedPost, At, Brand } from '@atcute/client/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
···
 
 			<Switch>
 				<Match when={query.error} keyed>
-					{(error) => {
-						if (error instanceof XRPCError) {
-							if (error.kind === 'NotFound') {
+					{(err) => {
+						if (err instanceof ClientResponseError) {
+							if (err.error === 'NotFound') {
 								return (
 									<div class="px-4 py-3">
 										<div class="rounded-md border border-outline p-3">
···
 							}
 						}
 
-						return <ErrorView error={error} onRetry={() => query.refetch()} />;
+						return <ErrorView error={err} onRetry={() => query.refetch()} />;
 					}}
 				</Match>
 

src/views/profile.tsx

···
 import { Match, Show, Switch, createMemo } from 'solid-js';
 
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
···
 				<Match when={profile.error} keyed>
 					{(err) => {
 						if (
-							err instanceof XRPCError &&
-							(err.kind === 'InvalidRequest' ||
-								err.kind === 'AccountTakedown' ||
-								err.kind === 'AccountDeactivated')
+							err instanceof ClientResponseError &&
+							(err.error === 'InvalidRequest' ||
+								err.error === 'AccountTakedown' ||
+								err.error === 'AccountDeactivated')
 						) {
 							const text =
-								err.kind === 'AccountTakedown'
+								err.error === 'AccountTakedown'
 									? `This account is taken down`
-									: err.kind === 'AccountDeactivated'
+									: err.error === 'AccountDeactivated'
 										? `This account has deactivated`
 										: `This account doesn't exist`;
 

src/views/settings-account.tsx

···
+import { ok } from '@atcute/client';
 import { createQuery } from '@mary/solid-query';
 
 import { useTitle } from '~/lib/navigation/router';
···
 import * as Page from '~/components/page';
 
 const AccountSettingsPage = () => {
-	const { did, rpc, persister } = useAgent();
+	const { did, client, persister } = useAgent();
 
 	const repo = createQuery(() => ({
 		queryKey: ['describe-repo'],
 		persister: persister as any,
 		async queryFn() {
-			const [repoResponse, serverResponse] = await Promise.all([
-				rpc.get('com.atproto.repo.describeRepo', { params: { repo: did! } }),
-				rpc.handle('/xrpc/com.atproto.server.describeServer', {}),
+			const [repo, server] = await Promise.all([
+				ok(client.get('com.atproto.repo.describeRepo', { params: { repo: did! } })),
+				ok(client.get('com.atproto.server.describeServer')),
 			]);
 
 			return {
-				handle: repoResponse.data.handle,
-				pds: new URL(serverResponse.url).host,
+				handle: repo.handle,
+				pds: server.did.replace(/^did:web:/, ''),
 			};
 		},
 	}));

src/views/settings-app-passwords.tsx

···
 import { For, Match, Show, Switch } from 'solid-js';
 
+import { ok } from '@atcute/client';
 import type { ComAtprotoServerListAppPasswords } from '@atcute/client/lexicons';
 import { createMutation, createQuery } from '@mary/solid-query';
 
···
 import AddAppPasswordPrompt from '~/components/settings/app-passwords/add-app-password-prompt';
 
 const AppPasswordsSettingsPage = () => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const passwords = createQuery(() => {
 		return {
 			queryKey: ['app-passwords'],
 			async queryFn() {
-				const { data } = await rpc.get('com.atproto.server.listAppPasswords', {});
+				const data = await ok(client.get('com.atproto.server.listAppPasswords'));
 
 				return data.passwords;
 			},
···
 }
 
 const PasswordEntry = ({ item }: PasswordEntryProps) => {
-	const { rpc } = useAgent();
+	const { client } = useAgent();
 
 	const isPrivileged = item.privileged;
 
 	const mutation = createMutation((queryClient) => {
 		return {
 			async mutationFn() {
-				await rpc.call('com.atproto.server.revokeAppPassword', {
-					data: { name: item.name },
-				});
+				await ok(
+					client.post('com.atproto.server.revokeAppPassword', {
+						as: null,
+						input: { name: item.name },
+					}),
+				);
 			},
 			async onSuccess() {
 				await queryClient.invalidateQueries({ queryKey: ['app-passwords'] });