@recursiv/sdk 0.7.82 → 0.7.83

package/dist/resources/agents.js

@@ -1,4 +1,4 @@
-import { RecursivError } from '../errors.js';
+import { RateLimitError, rateLimitDetailsFromResponse, RecursivError } from '../errors.js';
 import { parseSSE } from '../lib/sse.js';
 // ── Agent directory (GET /agents/discover) ──
 /** The orders the agent directory serves (server: features/agents/agentDirectory.ts). */
@@ -83,7 +83,10 @@ export class AgentsResource {
     delete(id) {
         return this.client.delete(`/agents/${id}`);
     }
-    /** Send a message to an agent (async — agent responds asynchronously) */
+    /**
+     * Send a message to an agent (async — agent responds asynchronously).
+     * `turn: { safe: true }` makes it a safe turn in the caller's Asks thread (see `AgentChatTurn`).
+     */
     chat(id, input) {
         return this.client.post(`/agents/${id}/chat`, input);
     }
@@ -224,6 +227,8 @@ export class AgentsResource {
      *
      * Requires `ReadableStream` support (Node.js, modern browsers).
      * For React Native, use `chatStreamText()` instead.
+     * `turn: { safe: true }` streams a safe turn in the caller's Asks thread (see `AgentChatTurn`); a refusal throws a
+     * `RecursivError` whose code is a `SafeTurnRefusalCode`, before anything streams.
      */
     async *chatStream(id, input) {
         yield* this.streamChunks(id, input);
@@ -286,6 +291,11 @@ export class AgentsResource {
                     code: 'stream_error',
                 });
             }
+            // A 429 is a RateLimitError, as on every other request: with its scope and reset (a safe turn's daily cap is
+            // `scope: 'action'`, see SafeTurnRefusalCode).
+            if (response.status === 429 && errorBody?.error && typeof errorBody.error === 'object') {
+                throw new RateLimitError(errorBody.error, rateLimitDetailsFromResponse(response.headers, errorBody.error));
+            }
             throw new RecursivError(response.status, errorBody.error);
         }
         return response;

package/dist/resources/e2ee.d.ts

@@ -68,6 +68,38 @@ export interface E2eeAccountReset {
  * - `conflict` (409): the device name or key was used before; start the device again with fresh ones.
  */
 export type E2eeResetErrorCode = 'confirmation_failed' | 'code_limit' | 'no_email_on_file' | 'email_delivery_unavailable' | 'reset_required' | 'conflict';
+/**
+ * One account whose main device a reset of encrypted chat replaced (`peerChanges`): `at` is when the new main
+ * device was registered (the relay's clock). Look at its devices again (`devices({ user_id })`).
+ */
+export interface E2eePeerChange {
+    userId: string;
+    at: string;
+}
+/**
+ * The realtime `e2ee:peer` event (`r.realtime.onE2eePeer`), sent to each member of an encrypted conversation the
+ * account `userId` shares with them, once per such conversation, when that account reset encrypted chat
+ * (`reason: 'root_changed'`): its security code changed there. Only to sockets whose credential can read that
+ * conversation over the relay. A hint: look at the account's devices again. An app in the background catches up
+ * with `peerChanges` when it comes to the foreground.
+ */
+export interface E2eePeerRealtimeEvent {
+    userId: string;
+    reason: 'root_changed';
+    conversationId: string;
+}
+/**
+ * Codes a message that declares `trust_change` can be refused with in a direct chat whose other person reset
+ * encrypted chat, where `status().accountReset` is on (409 `ConflictError` for both):
+ * - `peer_not_joined`: no device of this account has added the other person's new device to the chat yet, so the
+ *   message would be unreadable on it. `details: { userId }` names the person. Add the device, then send again.
+ * - `stale_epoch`: encrypted under a key generation before the chat's last key update. Sync, then encrypt it again.
+ */
+export type E2eePeerErrorCode = 'peer_not_joined' | 'stale_epoch';
+/** The `details` of a `peer_not_joined` refusal. */
+export interface E2eePeerNotJoinedDetails {
+    userId: string;
+}
 /** Opaque `recursiv-mls-v2-draft1` envelope with base64 MLS bytes. */
 export interface E2eeEnvelope {
     profile: 'recursiv-mls-v2-draft1';
@@ -367,6 +399,15 @@ export declare class E2eeResource {
      * delete. A commit ignores the flag. The relay learns only that the event
      * is quiet; the flag is not stored. A relay that predates it drops the
      * key, so the event is simply not quiet there.
+     *
+     * `trust_change: true` says this device's engine can accept a contact's new
+     * main device after they reset encrypted chat. Where `status().accountReset`
+     * is on, such a message in a direct chat whose other person reset is refused
+     * 409 `peer_not_joined` (`details: { userId }`) until a device of this
+     * account added their new device, and 409 `stale_epoch` when encrypted under
+     * a key generation before the chat's last key update (E2eePeerErrorCode). A
+     * message without it is accepted as before. Never stored; relays without it
+     * ignore it.
      */
     appendEvent(conversationId: string, input: {
         device_id: string;
@@ -375,11 +416,26 @@ export declare class E2eeResource {
         welcome_for_device_id?: string;
         expected_commit_seq?: number;
         silent?: boolean;
+        trust_change?: boolean;
     }): Promise<SingleResponse<{
         seq: number;
         duplicate: boolean;
         commitSeq: number;
     }>>;
+    /**
+     * The accounts sharing an encrypted conversation with this account (a direct
+     * chat, or a group both accepted) whose main device a reset of encrypted chat
+     * replaced after `since` (ISO 8601; default and floor: 7 days ago), oldest
+     * first, at most 200 (ask again from the last `at` for more). Read it when the
+     * app comes to the foreground, then look at each account's devices again; the
+     * live form is `r.realtime.onE2eePeer`. Empty where `status().accountReset` is
+     * off. Relays without it answer 404 (`NotFoundError`): treat that as no changes.
+     */
+    peerChanges(params?: {
+        since?: string;
+    }): Promise<{
+        data: E2eePeerChange[];
+    }>;
     events(conversationId: string, params: {
         device_id: string;
         after_seq?: number;

package/dist/resources/e2ee.js

@@ -96,11 +96,32 @@ export class E2eeResource {
      * delete. A commit ignores the flag. The relay learns only that the event
      * is quiet; the flag is not stored. A relay that predates it drops the
      * key, so the event is simply not quiet there.
+     *
+     * `trust_change: true` says this device's engine can accept a contact's new
+     * main device after they reset encrypted chat. Where `status().accountReset`
+     * is on, such a message in a direct chat whose other person reset is refused
+     * 409 `peer_not_joined` (`details: { userId }`) until a device of this
+     * account added their new device, and 409 `stale_epoch` when encrypted under
+     * a key generation before the chat's last key update (E2eePeerErrorCode). A
+     * message without it is accepted as before. Never stored; relays without it
+     * ignore it.
      */
     appendEvent(conversationId, input) {
         // Retries are safe: the server is idempotent on (conversation, device, event id).
         return this.client.post(`/e2ee/conversations/${encodeURIComponent(conversationId)}/events`, input, { retry: true });
     }
+    /**
+     * The accounts sharing an encrypted conversation with this account (a direct
+     * chat, or a group both accepted) whose main device a reset of encrypted chat
+     * replaced after `since` (ISO 8601; default and floor: 7 days ago), oldest
+     * first, at most 200 (ask again from the last `at` for more). Read it when the
+     * app comes to the foreground, then look at each account's devices again; the
+     * live form is `r.realtime.onE2eePeer`. Empty where `status().accountReset` is
+     * off. Relays without it answer 404 (`NotFoundError`): treat that as no changes.
+     */
+    peerChanges(params) {
+        return this.client.get('/e2ee/peer-changes', params);
+    }
     events(conversationId, params) {
         return this.client.get(`/e2ee/conversations/${encodeURIComponent(conversationId)}/events`, params);
     }

package/dist/resources/link-preview.d.ts

@@ -17,6 +17,30 @@ export interface LinkPreviewResponse {
      */
     data: LinkPreview | null;
     cached?: boolean;
+    /**
+     * `'ai_link'`: the link is not in the named message in a person's own words,
+     * and the caller did not write the same address in that conversation, so the
+     * server did not fetch it (it may be an AI's). Show the plain link, and do not
+     * ask again for this message. Only on a request that named its message or
+     * conversation (`source`).
+     */
+    refused?: 'ai_link';
+}
+/**
+ * Where a chat link came from. Name the message when you have its id; the
+ * conversation alone when you do not have it yet (an AI reply still being
+ * saved). With the conversation alone, a link is previewed only when the caller
+ * wrote it there, so another member's message not yet saved waits for its id.
+ * At least one of the two must be a non-empty id: `get` rejects otherwise and
+ * never falls back to a request without a source.
+ *
+ * Not for an encrypted conversation: the server has no readable messages there,
+ * so every link would be refused, the member's own included. There the app
+ * decides by its own rule (no preview of a link the member did not write).
+ */
+export interface LinkPreviewSource {
+    messageId?: string;
+    conversationId?: string;
 }
 export declare class LinkPreviewResource {
     private client;
@@ -27,6 +51,23 @@ export declare class LinkPreviewResource {
      * preview (`data: null`). No auth required — the endpoint is intentionally
      * public so unauthenticated UIs can render link previews. A URL that is not
      * http(s), or points at a private or internal address, still rejects (422).
+     *
+     * For a link in a chat message, pass `source`: the server then previews the
+     * link only when it is in the named message and a person wrote that message,
+     * or when the caller wrote the same address in that conversation (in a
+     * message, or as the card link of a Minds post they shared there). Otherwise
+     * it answers `{ data: null, refused: 'ai_link' }` without fetching it. A
+     * request with `source` is the caller's own: make it on a signed-in client
+     * whose key has `chat:read` (a keyless one gets 401). A message or
+     * conversation the caller cannot read rejects with 404. A `source` with no
+     * id in it (an AI reply whose id is not known yet, say) rejects with a
+     * ValidationError and sends nothing. Do not pass `source` in an encrypted
+     * conversation (see LinkPreviewSource). Servers before this change ignore
+     * `source` and preview the link, so an app keeps its own rule too: no
+     * preview of an AI-written link the member did not write.
+     *
+     * @example
+     * const { data, refused } = await r.linkPreview.get(url, { messageId: message.id });
      */
-    get(url: string): Promise<LinkPreviewResponse>;
+    get(url: string, source?: LinkPreviewSource | null): Promise<LinkPreviewResponse>;
 }

package/dist/resources/link-preview.js

@@ -1,3 +1,4 @@
+import { ValidationError } from '../errors.js';
 export class LinkPreviewResource {
     client;
     constructor(client) {
@@ -9,8 +10,41 @@ export class LinkPreviewResource {
      * preview (`data: null`). No auth required — the endpoint is intentionally
      * public so unauthenticated UIs can render link previews. A URL that is not
      * http(s), or points at a private or internal address, still rejects (422).
+     *
+     * For a link in a chat message, pass `source`: the server then previews the
+     * link only when it is in the named message and a person wrote that message,
+     * or when the caller wrote the same address in that conversation (in a
+     * message, or as the card link of a Minds post they shared there). Otherwise
+     * it answers `{ data: null, refused: 'ai_link' }` without fetching it. A
+     * request with `source` is the caller's own: make it on a signed-in client
+     * whose key has `chat:read` (a keyless one gets 401). A message or
+     * conversation the caller cannot read rejects with 404. A `source` with no
+     * id in it (an AI reply whose id is not known yet, say) rejects with a
+     * ValidationError and sends nothing. Do not pass `source` in an encrypted
+     * conversation (see LinkPreviewSource). Servers before this change ignore
+     * `source` and preview the link, so an app keeps its own rule too: no
+     * preview of an AI-written link the member did not write.
+     *
+     * @example
+     * const { data, refused } = await r.linkPreview.get(url, { messageId: message.id });
      */
-    get(url) {
-        return this.client.get('/link-preview', { url });
+    async get(url, source) {
+        const params = { url };
+        if (source != null) {
+            // A source with no id must not turn into a bare request: the server would
+            // then fetch the link with no check at all.
+            if (!source.messageId && !source.conversationId) {
+                throw new ValidationError({
+                    type: 'validation_error',
+                    code: 'link_preview_source_missing',
+                    message: 'linkPreview.get: source needs a messageId or a conversationId. Wait for the id, or show the plain link.',
+                });
+            }
+            if (source.messageId)
+                params.message_id = source.messageId;
+            if (source.conversationId)
+                params.conversation_id = source.conversationId;
+        }
+        return this.client.get('/link-preview', params);
     }
 }

package/dist/resources/network.d.ts

@@ -1,5 +1,6 @@
 import type { HttpClient } from '../client.js';
 import type { SingleResponse } from '../types.js';
+import type { AssistantSettings } from '../assistant-surfaces.js';
 interface NetworkConfig {
     name: string;
     slug: string | null;
@@ -25,6 +26,11 @@ interface NetworkConfig {
     auth_methods: string;
     default_template_name: string | null;
     locale: string;
+    /**
+     * The assistant surface switches for the app this key is bound to (absent on servers from before George plan G7a).
+     * Read them with `assistantSurfaceOn(config, id)`, which is off for anything but an explicit true.
+     */
+    assistant?: AssistantSettings;
 }
 export declare class NetworkResource {
     private client;

package/dist/resources/project-brain.d.ts

@@ -1,5 +1,6 @@
 import type { HttpClient } from '../client.js';
 import type { SingleResponse } from '../types.js';
+import type { AssistantSettings, AssistantSettingsUpdate } from '../assistant-surfaces.js';
 export interface BrainTask {
     id: string;
     title: string;
@@ -153,6 +154,8 @@ export interface ProjectBrainSettings {
     maxStepsPerRun?: number;
     heartbeatTimeoutMinutes?: number;
     dailySpendingLimitUsd?: number;
+    /** The assistant surface switches: every surface id, off unless stored as true (absent on older servers). */
+    assistant?: AssistantSettings;
     [key: string]: unknown;
 }
 export interface UpdateProjectSettingsInput {
@@ -161,6 +164,11 @@ export interface UpdateProjectSettingsInput {
     max_steps_per_run?: number;
     heartbeat_timeout_minutes?: number;
     daily_spending_limit_usd?: number;
+    /**
+     * Turn assistant surfaces on or off for this app (George plan G7a): the ids given are set, the rest kept. The
+     * project's owner or an admin only (403 `project_admin_required` otherwise); an unknown id is a 400.
+     */
+    assistant?: AssistantSettingsUpdate;
 }
 export interface BrowserUseRunTaskInput {
     task: string;

package/dist/resources/users.d.ts

@@ -1,10 +1,19 @@
 import type { HttpClient } from '../client.js';
 import type { PaginatedResponse, SingleResponse, User, FollowUser, PaginationParams } from '../types.js';
+import type { AssistantSettings } from '../assistant-surfaces.js';
+/** The signed-in user as `users.me()` returns it. */
+export interface CurrentUser extends User {
+    /**
+     * The assistant surface switches for the app this key is bound to (absent on servers from before George plan G7a).
+     * Read them with `assistantSurfaceOn(me, id)`, which is off for anything but an explicit true.
+     */
+    assistant?: AssistantSettings;
+}
 export declare class UsersResource {
     private client;
     constructor(client: HttpClient);
-    /** Get the authenticated user's profile */
-    me(): Promise<SingleResponse<User>>;
+    /** Get the authenticated user's profile, with the app's assistant surface switches */
+    me(): Promise<SingleResponse<CurrentUser>>;
     /** Get a user by ID */
     get(id: string): Promise<SingleResponse<User>>;
     /** List a user's followers */

package/dist/resources/users.js

@@ -3,7 +3,7 @@ export class UsersResource {
     constructor(client) {
         this.client = client;
     }
-    /** Get the authenticated user's profile */
+    /** Get the authenticated user's profile, with the app's assistant surface switches */
     me() {
         return this.client.get('/users/me');
     }

package/dist/types.d.ts

@@ -1316,7 +1316,35 @@ export interface AgentChatInput {
     message: string;
     conversation_id?: string;
     new_conversation?: boolean;
+    /** Per-turn options. `{ safe: true }` makes this a safe turn (see {@link AgentChatTurn}). */
+    turn?: AgentChatTurn;
 }
+/**
+ * Per-turn options for an agent chat message.
+ *
+ * `safe: true` (George plan G6a) asks about something on the network, typically someone else's post, on the caller's
+ * own personal agent, in their one Asks thread with it (found or made by the server; leave out `new_conversation`, and
+ * send `conversation_id` only for that thread). The turn has no tools whatever the agent's tool mode, reads and saves
+ * no memory, sends OpenRouter `data_collection: 'deny'` whatever the member chose, writes no audit copy of the prompt
+ * or reply (`ai_usage_detail`), sends pictures as alt text and stored descriptions only, and counts against a small
+ * daily allowance. Every later turn in the Asks thread is a safe turn too, however it is sent. The reply
+ * carries `metadata.safe_turn: true`. Refusals answer with a fixed {@link SafeTurnRefusalCode}; none names a plan or
+ * a price, and the server never creates an agent for an ask.
+ */
+export interface AgentChatTurn {
+    safe?: boolean;
+}
+/**
+ * Why the server refused a safe turn (the `code` of the error):
+ * - `safe_turn_limit` (429): today's asks are used up (an app shows its own "limit" words). Marked
+ *   `X-RateLimit-Scope: action`, so the SDK throws it at once as a `RateLimitError` with `scope: 'action'` and
+ *   `resetAt` (the next midnight UTC), and does not resend it.
+ * - `safe_turn_needs_personal_agent` (409): the agent is not the caller's own personal agent.
+ * - `safe_turn_needs_app` (403): the key is bound to no app (a personal key, say); an ask goes with the app's own key.
+ * - `safe_turn_ai_off` / `safe_turn_standard_off` (403): the member's AI choices refuse it.
+ * - `safe_turn_conversation` (400): `new_conversation` was sent, or `conversation_id` is not the Asks thread.
+ */
+export type SafeTurnRefusalCode = 'safe_turn_limit' | 'safe_turn_needs_personal_agent' | 'safe_turn_needs_app' | 'safe_turn_ai_off' | 'safe_turn_standard_off' | 'safe_turn_conversation';
 /** Answer an existing message of yours again, without sending it a second time. */
 export interface AgentChatRetryInput {
     conversation_id: string;
@@ -1597,6 +1625,12 @@ export interface ContentPreferences {
     autoplay_video: boolean;
     ai_enabled: boolean;
     default_feed: 'foryou' | 'following';
+    /**
+     * True when the member picked `default_feed` themselves (any `updateContent({ default_feed })` sets it).
+     * When false, `default_feed` is only the default and the app may choose for them. Absent from APIs older than
+     * this field: treat absent as unknown, not as false.
+     */
+    default_feed_chosen?: boolean;
 }
 export interface UpdateNotificationChannelsInput {
     /** Master switch: sets in-app on every kind. */

package/llm.md

@@ -214,6 +214,27 @@ Methods: `tasks`, `stats`, `decisions`, `milestones`, `agents`, `teamActivity`,
 
 ---
 
+## Assistant subjects — `@recursiv/sdk/assistant` (unreleased)
+
+Pure, no network: the same input on a server, a phone or the web. Build the bundle from data you already hold, then render it; never paste post text into a prompt by hand.
+
+```typescript
+import { buildSubjectBundle, renderBundleForModel } from '@recursiv/sdk/assistant'
+const { bundle, refused, excluded } = buildSubjectBundle({ mode: 'standard', asker: { id, blocked_ids, muted_ids }, post, parent, quoted, replies }) // server: also blocked_by_ids
+if (bundle) {
+  const { system, user, references } = renderBundleForModel(bundle, 'summarise', { boundary }) // boundary: fresh random, 16+ chars, per call
+}
+```
+
+- `bundle` is null when the post itself may not be read: author asks off (`ai_ask_allowed` `'off'`, or `'sealed_only'` in Standard), the asker blocked or muted the author or the author blocked the asker, known-minor author (unless asker is author), child-safety hold, moderator suppression, `assist_readable: 'none'`. Make no model call.
+- `refused` and `excluded` (`{ role, reason, count }[]`, never ids) are safe to show the asker: blocks, minors, holds and suppression all read `'unavailable'`. `audit` has the detail: server log only, never to a client.
+- `known_minor`, `child_safety_hold`, `assistant_suppressed`, media `held`, `blocked_by_ids`: server-side inputs, never sent to another member's client; a client passes the server's per-viewer `assist_readable` instead. Flags fail closed (anything but false/null/absent is set); an unreadable id list throws.
+- Replies, parent and quote are left out by the same rules. Media go as alt text and stored caption only; picture and media addresses never reach `references`. Hidden text is stripped; top 20 replies; per-field and total caps (lower them with `limits`, never raise).
+- Intents: `explain`, `fact_context` (post, parent, quote), `summarise` (plus replies), `translate` (needs `language`, a BCP 47 tag), `describe` (text only). Output filters allow only `references` ids, handles and URLs, as plain links (never render an image the model wrote). Render only bundles you built from your own reads.
+- Fixed cards, before any model call: `matchFixedCard(memberWords, { country, locale })` → `{ kind: 'crisis' | 'election', card } | null`. Crisis (self-harm, suicide risk, immediate danger) always shows the card first, then the turn may answer; election logistics only (never candidates, results, fraud claims, votes on a post or poll), and `fixedCardAnswer('election', Date.now())` is `'card_only'` until 2026-11-04T12:00Z. English and Spanish; every number and URL is sourced data (`CRISIS_LINES`, `ELECTION_SITES`), never generated. Pass the member's words, not the post they ask about.
+
+---
+
 ## Evidence — Measure agents (evals, accuracy, cost)
 
 ### r.evidence — Author evals, run simulations, read graded results
@@ -564,6 +585,14 @@ const { data: reset } = await r.e2ee.resetAccount({ email_code, device_name, rea
 // → { reset, resetAt, retiredRoot, revokedDeviceIds, device (the new main device), signedOut: { sessions, keys, connectedApps } }; a retry after a lost answer gets the same result
 ```
 
+A contact's reset (D2 R2, 0.7.83; where `accountReset` is on). Each member of an encrypted conversation the account shares (a direct chat, or a group both accepted) gets `e2ee:peer` `{ userId, reason: 'root_changed', conversationId }`, once per shared conversation, and each direct-chat contact one push (at most one a day per person who reset; it does not name them): "A contact reset encrypted chat. Open Minds to keep chatting." `peerChanges({ since })` lists the accounts whose main device a reset replaced since then (default and floor 7 days, oldest first, at most 200; a relay without it answers 404: treat it as none). An engine that can accept a contact's new main device sends `trust_change: true` with its messages; in a direct chat with someone who reset, such a message gets 409 `peer_not_joined` (`details.userId`) until a device of this account added their new device, and 409 `stale_epoch` under a key generation before the chat's last key update. Messages without it are accepted as before.
+
+```ts
+r.realtime.onE2eePeer(({ userId, conversationId }) => {});              // look at userId's devices again
+const { data: changes } = await r.e2ee.peerChanges({ since });          // [{ userId, at }] after time in the background
+await r.e2ee.appendEvent(conversationId, { device_id, envelope, trust_change: true }); // ConflictError 'peer_not_joined' | 'stale_epoch'
+```
+
 ### r.realtime — WebSocket Chat Client
 
 Provides persistent real-time streaming and chat presence, useful for building frontends (e.g. React Native, Web).
@@ -597,7 +626,7 @@ unsub()
 const off = r.realtime.on('notification', (n) => refreshBadge(n))
 ```
 
-Events: `onMessage`, `onMessageEdit`, `onMessageDelete`, `onTyping`, `onAgentThinking`, `onE2eeEvent`, `onE2eeLink`, `onE2eeDevices`, `on(event, fn)`
+Events: `onMessage`, `onMessageEdit`, `onMessageDelete`, `onTyping`, `onAgentThinking`, `onE2eeEvent`, `onE2eeLink`, `onE2eeDevices`, `onE2eePeer`, `on(event, fn)`
 
 Reconnects on its own (transport drops, token expiry, refused handshakes) with jittered backoff and a fresh single-use token per attempt; listeners and joined rooms carry over, so no app-side reconnect shim is needed. It stops only on `disconnect()` or a 401/403 from the token source. `connect()` is safe to call repeatedly.
 
@@ -794,7 +823,7 @@ Methods: `list`, `get`, `create`, `delete`
 
 ## Platform Resources
 
-- `r.settings` — User preferences, sessions, password changes, account deletion. `revokeOtherSessions({ keep_session_token? })` signs out every other device and keeps this key (and the proven session); `revokeAllSessions()` also revokes this key. Accounts with no password confirm `requestEmailChange({ new_email, email_code })` with a code from `requestConfirmationCode('email_change')`. With a project-bound key, `getPreferences()` includes app-scoped `content`; persist changes with `updateContent({ show_nsfw?, autoplay_video?, ai_enabled?, default_feed? })`. Notifications (0.7.72): `getPreferences()` returns `notifications.channels`, each kind (`post_mention`, `post_reply`, `post_repost`, `post_reaction`, `follow`, `message`, and the operator kinds) with `{ inApp, push, email }`; `updateNotifications({ channels: { post_reaction: { push: false } } })` changes that kind only, while `in_app`/`push`/`email` stay master switches over every kind. `disableAccount({ password })` (0.7.71) deactivates the account (hidden, nothing deleted; signing back in restores it), asked once; an API that does not serve deactivation answers 404 `NotFoundError`, so keep the control hidden until yours does.
+- `r.settings` — User preferences, sessions, password changes, account deletion. `revokeOtherSessions({ keep_session_token? })` signs out every other device and keeps this key (and the proven session); `revokeAllSessions()` also revokes this key. Accounts with no password confirm `requestEmailChange({ new_email, email_code })` with a code from `requestConfirmationCode('email_change')`. With a project-bound key, `getPreferences()` includes app-scoped `content`; persist changes with `updateContent({ show_nsfw?, autoplay_video?, ai_enabled?, default_feed? })`; `content.default_feed_chosen` is true once the member set `default_feed` themselves (absent on older APIs). Notifications (0.7.72): `getPreferences()` returns `notifications.channels`, each kind (`post_mention`, `post_reply`, `post_repost`, `post_reaction`, `follow`, `message`, and the operator kinds) with `{ inApp, push, email }`; `updateNotifications({ channels: { post_reaction: { push: false } } })` changes that kind only, while `in_app`/`push`/`email` stay master switches over every kind. `disableAccount({ password })` (0.7.71) deactivates the account (hidden, nothing deleted; signing back in restores it), asked once; an API that does not serve deactivation answers 404 `NotFoundError`, so keep the control hidden until yours does.
 - `r.signals` (0.7.71) — The member's engagement signals for their own ranking (For You), under their app-bound key (`agents:write`): `batch(events, { keepalive?, retry? })` sends up to `SIGNAL_BATCH_MAX` (100) `{ event_type, post_id?, dwell_ms?, metadata? }` to POST /signals/batch; `record(event)` sends one to POST /signals/post (for an API before the batch route, which answers that one 404). `event_type`: `view`, `click`, `dwell`, `react_up`, `react_down`, `save`, `hide`, `share`, `mute_source`, `open_chat`, `ask_agent`, `more_like`, `unhide`. Best-effort: a signal the server cannot store answers 200 with `recorded` 0 (or false) and a `reason` (`no_project_scope`, `project_db_unavailable`). `keepalive: true` is for a flush as the page is hidden or unloads: the request is on the wire before the call returns and is asked once.
 
 ```typescript
@@ -855,6 +884,7 @@ await r.appSubscriptions.changeTier({ tier: 'pro', proration_date: quote.prorati
 - `r.dispatcher` — Task queue: `tasks()`, `create()`, `claimNext()`, `complete()`, `release()`, `stats()`, `signals()`, `outcomes()`, `staleItems()`, `stuckItems()`, `discoveries()`
 - `r.dispatcher` (webhooks): `createWebhook()`, `listWebhooks()`, `updateWebhook()`, `deleteWebhook()`, `testWebhook()`, `webhookDeliveries()`, `cleanupWebhookLogs()`
 - `r.goals` — Org goals that dispatcher tasks roll up into: `list()`, `get()`, `create()`, `update()`, `archive()`. Tasks link via `goal_id` on `r.dispatcher.create()/update()`; `tasks({ goal_id })` filters (use `'none'` for goal-less tasks).
+- `r.linkPreview` — Open Graph card for a public link: `get(url)` answers `{ data: LinkPreview | null }` (null: no preview, show the plain link); keyless clients may call it. For a link in a chat message pass where it came from, `get(url, { messageId })` (or `{ conversationId }` before the message has an id), on a signed-in key with `chat:read`: the link is fetched only when it is in the named message and a person wrote that message, or when the caller wrote the same address in that conversation (a message, or the card link of a Minds post they shared there), else `{ data: null, refused: 'ai_link' }` with nothing fetched; 401 without a key, 404 for a message or conversation the caller cannot read. A `source` with no id rejects with `ValidationError` and sends nothing. Never pass `source` in an encrypted conversation: the server cannot read it, so every link would be refused; the app's own rule decides there.
 
 ```typescript
 // Create a goal and group tasks under it (personal keys: pass organization_id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursiv/sdk",
-  "version": "0.7.82",
+  "version": "0.7.83",
   "description": "TypeScript SDK for the Recursiv API",
   "license": "FSL-1.1-ALv2",
   "type": "module",
@@ -13,6 +13,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./assistant": {
+      "types": "./dist/assistant/index.d.ts",
+      "import": "./dist/assistant/index.js",
+      "default": "./dist/assistant/index.js"
+    },
     "./react": {
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",