@parall/sdk 1.36.1 → 1.38.0

package/src/client.ts

@@ -1,5 +1,11 @@
 import { ENDPOINTS, WIKI_BASE } from './constants.js';
 import type {
+  ClaimDispatchRequest,
+  ClaimDispatchResponse,
+  SteerDispatchRequest,
+  SteerDispatchResponse,
+  CompleteDispatchRequest,
+  CompleteDispatchResult,
   AuthTokens,
   AvatarUploadResponse,
   RegisterRequest,
@@ -41,6 +47,7 @@ import type {
   MachineRuntimeAuthState,
   AgentWorkspaceState,
   AgentWorkspaceReportStatus,
+  DetectedRuntime,
   BrowseMachineFilesystemResponse,
   FilesystemEntry,
   DaemonAgentConfig,
@@ -74,6 +81,14 @@ import type {
   CreateExternalConnectionInput,
   UpdateExternalConnectionInput,
   ExternalConnectionFilters,
+  ChannelConnection,
+  ChannelConversation,
+  ChannelMessage,
+  ChannelCredentialsInput,
+  ChannelProvisioningSession,
+  CreateChannelConnectionInput,
+  InitiateChannelProvisioningInput,
+  UpdateChannelConnectionInput,
   ExternalIngressEvent,
   ExternalIngressEventFilters,
   ExternalTrigger,
@@ -97,6 +112,8 @@ import type {
   PlatformConfigResponse,
   Wiki,
   WikiBlob,
+  CopyWikiFileRequest,
+  CopyWikiFileResponse,
   WikiChangeset,
   WikiFileUploadResponse,
   WikiFilePreviewUrlResponse,
@@ -163,6 +180,8 @@ import type {
   UpdateAutoReloadRequest,
   ComputePricing,
   ComputePricingResponse,
+  RuntimeCapability,
+  PlatformModelsResponse,
   Clip,
   AgentClip,
   CreateClipRequest,
@@ -178,6 +197,7 @@ import type {
   MachineBrowserProfile,
   BrowserProfileListItem,
   BrowserProfileStatus,
+  BrowserRuntimeStatus,
   BrowserProfileConsent,
   CreateBrowserProfileRequest,
   UpdateBrowserProfileRequest,
@@ -360,7 +380,13 @@ export class ParallClient {
     body?: unknown,
     query?: Record<string, string | number | boolean | undefined>,
     retried = false,
-    opts?: { timeoutMs?: number; signal?: AbortSignal; keepalive?: boolean },
+    opts?: {
+      timeoutMs?: number;
+      signal?: AbortSignal;
+      keepalive?: boolean;
+      /** Observes the final HTTP status of a successful request (e.g. 200-idempotent-replay vs 201-created). */
+      onStatus?: (status: number) => void;
+    },
   ): Promise<T> {
     // Proactive refresh: block until token is fresh (no-op if still valid)
     if (!retried) {
@@ -427,6 +453,7 @@ export class ParallClient {
       throw buildApiError(res, rawErrorBody);
     }
 
+    opts?.onStatus?.(res.status);
     if (res.status === 204) return undefined as T;
     // 202 Accepted may have an empty body (e.g., async restart) or a JSON body.
     if (res.status === 202) {
@@ -631,6 +658,17 @@ export class ParallClient {
     return res.data;
   }
 
+  /** User IDs of soft-removed (former) org members — for marking their avatar /
+   *  name as "left" where dormant relations still surface them (DMs, task
+   *  assignees, message history). */
+  async getFormerMemberIds(orgId: string): Promise<string[]> {
+    const res = await this.request<{ user_ids: string[] }>(
+      'GET',
+      ENDPOINTS.ORG_MEMBERS_FORMER(orgId),
+    );
+    return res.user_ids ?? [];
+  }
+
   async getTeams(orgId: string): Promise<Team[]> {
     const res = await this.request<{ data: Team[] }>('GET', ENDPOINTS.TEAMS(orgId));
     return res.data;
@@ -944,6 +982,33 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.CHAT_MESSAGES(orgId, chatId), req);
   }
 
+  /**
+   * sendMessage variant that also reports whether the server answered with an
+   * idempotent replay (HTTP 200 — the message already existed for this
+   * idempotency/effect key) instead of a fresh create (201). Used by the CLI
+   * to surface "already sent by a previous run (deduplicated)".
+   */
+  async sendMessageDetailed(
+    orgId: string,
+    chatId: string,
+    req: SendMessageRequest,
+  ): Promise<{ message: Message; deduplicated: boolean }> {
+    let status = 0;
+    const message = await this.request<Message>(
+      'POST',
+      ENDPOINTS.CHAT_MESSAGES(orgId, chatId),
+      req,
+      undefined,
+      false,
+      {
+        onStatus: (s) => {
+          status = s;
+        },
+      },
+    );
+    return { message, deduplicated: status === 200 };
+  }
+
   async getMessages(
     orgId: string,
     chatId: string,
@@ -1515,29 +1580,40 @@ export class ParallClient {
     profileId: string,
     status: BrowserProfileStatus,
     errorMsg?: string,
+    // The lifecycle generation this report was issued under (captured at op start,
+    // PR #1650). Omitted by pre-generation callers; the server then falls back to
+    // safe-state compatibility. The server no-ops a report older than the row's.
+    generation?: number,
   ): Promise<void> {
     await this.request('POST', ENDPOINTS.MACHINES_ME_BROWSER_PROFILE_STATUS(profileId), {
       status,
       ...(errorMsg ? { error_msg: errorMsg } : {}),
+      ...(generation !== undefined ? { generation } : {}),
     });
   }
 
   /**
    * `POST /machines/me/health` — bump the Machine's `updated_at` to now and
-   * report daemon state. The daemon should call this on a fixed cadence (e.g.
-   * every 30s) so an external observer can detect a wedged supervisor. Both
+   * report daemon state. The daemon calls this on startup and again whenever
+   * periodic runtime re-detection produces a CHANGED result (there is no
+   * fixed-cadence keepalive loop today — steady state posts nothing). All
    * fields are optional and only persisted when changed:
    *  - `daemonVersion` — the running bundle/launcher version.
    *  - `selfUpdateCapable` — whether the daemon can act on a machine.update
    *    signal (true under a service manager, false for bare `npx` foreground).
+   *  - `detectedRuntimes` — runtime CLIs found on the host. Omitted = no
+   *    report this beat (server keeps the stored value); [] = detection ran
+   *    and found nothing (server clears to empty).
    */
   async postMachineHeartbeat(opts?: {
     daemonVersion?: string;
     selfUpdateCapable?: boolean;
+    detectedRuntimes?: DetectedRuntime[];
   }): Promise<void> {
     const body: Record<string, unknown> = {};
     if (opts?.daemonVersion) body.daemon_version = opts.daemonVersion;
     if (opts?.selfUpdateCapable !== undefined) body.self_update_capable = opts.selfUpdateCapable;
+    if (opts?.detectedRuntimes !== undefined) body.detected_runtimes = opts.detectedRuntimes;
     return this.request(
       'POST',
       ENDPOINTS.MACHINES_ME_HEALTH,
@@ -1785,6 +1861,41 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.DISPATCH_EXPIRE(orgId), undefined, params);
   }
 
+  /**
+   * Claim a dispatch lane (explicit consume endpoint). Occupies the
+   * (agent, target, thread) lane and folds claimable WorkItems into it;
+   * `claimed: false` means a healthy incumbent holds the lane.
+   */
+  async claimDispatch(orgId: string, req: ClaimDispatchRequest): Promise<ClaimDispatchResponse> {
+    return this.request('POST', ENDPOINTS.DISPATCH_CLAIM(orgId), req);
+  }
+
+  /** Fold a pending same-target WorkItem into a live lane (409 STALE_LANE when dethroned). */
+  async steerDispatch(orgId: string, req: SteerDispatchRequest): Promise<SteerDispatchResponse> {
+    return this.request('POST', ENDPOINTS.DISPATCH_STEER(orgId), req);
+  }
+
+  /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
+  async completeDispatch(
+    orgId: string,
+    req: CompleteDispatchRequest,
+  ): Promise<CompleteDispatchResult> {
+    return this.request('POST', ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
+  }
+
+  /** Release a lane on graceful shutdown — members return to pending immediately. */
+  async releaseDispatchLane(orgId: string, lane: string): Promise<void> {
+    return this.request('POST', ENDPOINTS.DISPATCH_RELEASE(orgId), { lane });
+  }
+
+  /** Renew a live lane's lease (long-turn keepalive). 409 STALE_LANE when dethroned. */
+  async heartbeatDispatchLane(
+    orgId: string,
+    req: { lane: string; target_uri: string; thread_root_id?: string },
+  ): Promise<{ lease_until?: string }> {
+    return this.request('POST', ENDPOINTS.DISPATCH_HEARTBEAT(orgId), req);
+  }
+
   async getDispatchByMessages(
     orgId: string,
     chatId: string,
@@ -2165,6 +2276,124 @@ export class ParallClient {
     return this.request('DELETE', ENDPOINTS.EXTERNAL_CONNECTION(orgId, connectionId));
   }
 
+  // ---- External IM channel (org-scoped) ----
+
+  async createChannelConnection(
+    orgId: string,
+    input: CreateChannelConnectionInput,
+  ): Promise<ChannelConnection> {
+    return this.request('POST', ENDPOINTS.CHANNEL_CONNECTIONS(orgId), input);
+  }
+
+  async listChannelConnections(orgId: string): Promise<{ connections: ChannelConnection[] }> {
+    return this.request('GET', ENDPOINTS.CHANNEL_CONNECTIONS(orgId));
+  }
+
+  async getChannelConnection(orgId: string, connectionId: string): Promise<ChannelConnection> {
+    return this.request('GET', ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId));
+  }
+
+  async updateChannelConnection(
+    orgId: string,
+    connectionId: string,
+    patch: UpdateChannelConnectionInput,
+  ): Promise<ChannelConnection> {
+    return this.request('PATCH', ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId), patch);
+  }
+
+  async archiveChannelConnection(orgId: string, connectionId: string): Promise<ChannelConnection> {
+    return this.request('DELETE', ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId));
+  }
+
+  async deliverChannelCredentials(
+    orgId: string,
+    connectionId: string,
+    credentials: ChannelCredentialsInput,
+  ): Promise<ChannelConnection> {
+    return this.request(
+      'POST',
+      ENDPOINTS.CHANNEL_CONNECTION_CREDENTIALS(orgId, connectionId),
+      credentials,
+    );
+  }
+
+  async regenerateChannelIngressToken(
+    orgId: string,
+    connectionId: string,
+  ): Promise<ChannelConnection> {
+    return this.request(
+      'POST',
+      ENDPOINTS.CHANNEL_CONNECTION_INGRESS_TOKEN_REGENERATE(orgId, connectionId),
+    );
+  }
+
+  /** Start a Feishu one-click provisioning session (device flow QR). */
+  async initiateChannelProvisioning(
+    orgId: string,
+    input: InitiateChannelProvisioningInput,
+  ): Promise<ChannelProvisioningSession> {
+    return this.request('POST', ENDPOINTS.CHANNEL_PROVISIONING(orgId), input);
+  }
+
+  /**
+   * Lazy status poll — server-side this may forward one provider poll, so
+   * call it at the session's `poll_interval_seconds` cadence, not faster.
+   */
+  async getChannelProvisioningSession(
+    orgId: string,
+    sessionId: string,
+  ): Promise<ChannelProvisioningSession> {
+    return this.request('GET', ENDPOINTS.CHANNEL_PROVISIONING_SESSION(orgId, sessionId));
+  }
+
+  async cancelChannelProvisioning(
+    orgId: string,
+    sessionId: string,
+  ): Promise<ChannelProvisioningSession> {
+    return this.request('POST', ENDPOINTS.CHANNEL_PROVISIONING_CANCEL(orgId, sessionId));
+  }
+
+  async listChannelConversations(
+    orgId: string,
+    connectionId: string,
+  ): Promise<{ conversations: ChannelConversation[] }> {
+    return this.request('GET', ENDPOINTS.CHANNEL_CONNECTION_CONVERSATIONS(orgId, connectionId));
+  }
+
+  async getChannelConversation(
+    orgId: string,
+    conversationId: string,
+  ): Promise<ChannelConversation> {
+    return this.request('GET', ENDPOINTS.CHANNEL_CONVERSATION(orgId, conversationId));
+  }
+
+  async listChannelConversationMessages(
+    orgId: string,
+    conversationId: string,
+    limit?: number,
+  ): Promise<{ messages: ChannelMessage[] }> {
+    return this.request(
+      'GET',
+      ENDPOINTS.CHANNEL_CONVERSATION_MESSAGES(orgId, conversationId),
+      undefined,
+      { limit },
+    );
+  }
+
+  async setChannelConversationSession(
+    orgId: string,
+    conversationId: string,
+    agentSessionId: string,
+  ): Promise<ChannelConversation> {
+    return this.request('PATCH', ENDPOINTS.CHANNEL_CONVERSATION_SESSION(orgId, conversationId), {
+      agent_session_id: agentSessionId,
+    });
+  }
+
+  async getChannelMessage(orgId: string, messageId: string): Promise<ChannelMessage> {
+    return this.request('GET', ENDPOINTS.CHANNEL_MESSAGE(orgId, messageId));
+  }
+
   async getExternalTriggerSchema(
     orgId: string,
     connectionId: string,
@@ -2254,6 +2483,26 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.WIKI(orgId, wikiId));
   }
 
+  /** Soft-delete an entire wiki (org owner only; the default wiki is
+   *  protected → 403 WIKI_PROTECTED). Returns the deleted wiki. Recoverable
+   *  via restoreWiki within the retention window. */
+  async deleteWiki(orgId: string, wikiId: string): Promise<Wiki> {
+    return this.request('DELETE', ENDPOINTS.WIKI(orgId, wikiId));
+  }
+
+  /** Restore a soft-deleted wiki (org owner only). 409 WIKI_PURGE_STARTED once
+   *  purge has been claimed (no longer restorable), or 404 once the row is gone.
+   *  Returns the restored wiki. */
+  async restoreWiki(orgId: string, wikiId: string): Promise<Wiki> {
+    return this.request('POST', ENDPOINTS.WIKI_RESTORE(orgId, wikiId));
+  }
+
+  /** Recycle bin — list soft-deleted wikis for the org (owner only). */
+  async getDeletedWikis(orgId: string): Promise<Wiki[]> {
+    const res = await this.request<{ data: Wiki[] }>('GET', ENDPOINTS.WIKIS_DELETED(orgId));
+    return res.data;
+  }
+
   async getWikiTree(
     orgId: string,
     wikiId: string,
@@ -2301,6 +2550,20 @@ export class ParallClient {
     return blob;
   }
 
+  /**
+   * Copy one wiki file to another path as an independent snapshot (no sync).
+   * Used to "share a private file out": copy a file from the caller's personal
+   * namespace (`users/{userId}/…`) into the public wiki, leaving the original
+   * untouched. 409 `FILE_EXISTS` if `dest_path` already exists.
+   */
+  async copyWikiFile(
+    orgId: string,
+    wikiId: string,
+    req: CopyWikiFileRequest,
+  ): Promise<CopyWikiFileResponse> {
+    return this.request('POST', ENDPOINTS.WIKI_COPY(orgId, wikiId), req);
+  }
+
   async getWikiNodeSections(
     orgId: string,
     wikiId: string,
@@ -2828,6 +3091,21 @@ export class ParallClient {
     return resp.data;
   }
 
+  /** Runtime capability table (public) — SSOT for the create/settings interlock. */
+  async getRuntimes(): Promise<RuntimeCapability[]> {
+    const resp = await this.request<{ data: RuntimeCapability[] }>('GET', ENDPOINTS.RUNTIMES());
+    return resp.data;
+  }
+
+  /**
+   * Platform model catalog (public) — DB-backed, replaces the compile-time
+   * PLATFORM_MODELS constant. Pass includeModel to keep an agent's pinned
+   * hidden legacy model representable (settings picker).
+   */
+  async getModels(includeModel?: string): Promise<PlatformModelsResponse> {
+    return this.request<PlatformModelsResponse>('GET', ENDPOINTS.MODELS(includeModel));
+  }
+
   // ---- Clips ----
 
   async listClips(orgId: string): Promise<Clip[]> {
@@ -2895,6 +3173,12 @@ export class ParallClient {
     return resp.data;
   }
 
+  /** Deployment-wide hosted browser runtime availability — drives whether the
+   *  create UI offers the platform-hosted placement. Fail-closed server-side. */
+  async getBrowserRuntimeStatus(orgId: string): Promise<BrowserRuntimeStatus> {
+    return this.request('GET', ENDPOINTS.BROWSER_RUNTIME_STATUS(orgId));
+  }
+
   /** Org-wide browser-profile discovery list. Returns the sanitized
    *  {@link BrowserProfileListItem} shape (not the full domain model), each row
    *  carrying a per-viewer `can_open` control hint. */

package/src/constants.ts

@@ -7,11 +7,17 @@ export const WIKI_BASE = '/wiki/v1';
 // Clip-service base path (served by clip-service, routed via LB path rules)
 export const CLIP_BASE = '/clip/v1';
 
-// LLM model catalog — mirrors server/pkg/llmproxy/models.go DefaultModels.
-// SSOT is the Go side; keep this list in sync when models change. `provider`
-// is used by clients to filter runtime-specific pickers. `runtime_names` is
-// included for catalog completeness and agent runtime delivery; product UI
-// should continue to display canonical model IDs/names.
+// LLM model catalog — frozen compile-time mirror of the catalog at the time
+// the DB-backed source shipped (docs/engineering-design/model-catalog-design.md).
+// Kept ONLY as the offline/degraded fallback for pickers; it is NOT updated
+// when models are added through the admin catalog.
+/**
+ * @deprecated The catalog is DB-backed — fetch it via `client.getModels()`
+ * (GET /api/v1/models). This constant is a frozen degraded-mode fallback and
+ * will be removed after one release cycle. Still structurally consumed by
+ * FALLBACK_CATALOG (`@parall/app` agent-interlock) — do not delete before
+ * that fallback strategy changes (PR-3).
+ */
 export const PLATFORM_MODELS = [
   // Fable 5 rejects an explicit thinking "disabled" param (400) — bridges must
   // omit the thinking config entirely instead of disabling it.
@@ -211,6 +217,12 @@ export const PLATFORM_MODELS = [
 
 // Hidden from new-agent pickers, but available to editors so persisted Beta
 // agent defaults remain representable.
+/**
+ * @deprecated Fetch via `client.getModels(currentModelId)` — the include_model
+ * parameter serves the legacy-pin case. Frozen degraded-mode fallback only.
+ * Still structurally consumed by FALLBACK_CATALOG (`@parall/app`
+ * agent-interlock) — do not delete before that fallback changes (PR-3).
+ */
 export const PLATFORM_LEGACY_MODELS = [
   {
     id: 'openai/gpt-5.4-mini',
@@ -284,9 +296,13 @@ export const PLATFORM_LEGACY_MODELS = [
   },
 ] as const;
 
-// Mirrors server/pkg/llmproxy/models.go DefaultModelIDForRuntime. Go remains
-// the SSOT; keep this client-side fallback in sync until the catalog is codegen
-// or fetched before render.
+// Frozen mirror of the per-runtime defaults at ship time of the DB-backed
+// catalog (llm_runtime_defaults). Live values arrive as recommended_model on
+// GET /runtimes.
+/**
+ * @deprecated Read `recommended_model` from `client.getRuntimes()` instead.
+ * Frozen degraded-mode fallback only.
+ */
 export const PLATFORM_DEFAULT_MODEL_BY_RUNTIME = {
   openclaw: 'anthropic/claude-sonnet-4.6',
   'claude-code': 'anthropic/claude-sonnet-4.6',
@@ -312,6 +328,11 @@ export function platformDefaultModelForRuntime(runtime: string | null | undefine
     case '':
     case 'openclaw':
     case 'claude-code':
+    // hermes / parel route through the Parall proxy and accept any model; the
+    // server (DefaultModelIDForRuntime) recommends the platform default, so
+    // mirror it.
+    case 'hermes':
+    case 'parel':
       return PLATFORM_DEFAULT_MODEL_BY_RUNTIME.openclaw;
     case 'codex':
       return PLATFORM_DEFAULT_MODEL_BY_RUNTIME.codex;
@@ -347,6 +368,7 @@ export const ENDPOINTS = {
   // Org-scoped
   ORG: (orgId: string) => `${API_BASE}/orgs/${orgId}`,
   ORG_MEMBERS: (orgId: string) => `${API_BASE}/orgs/${orgId}/members`,
+  ORG_MEMBERS_FORMER: (orgId: string) => `${API_BASE}/orgs/${orgId}/members/former`,
   TEAMS: (orgId: string) => `${API_BASE}/orgs/${orgId}/teams`,
   ORG_MEMBERS_ONLINE: (orgId: string) => `${API_BASE}/orgs/${orgId}/members/online`,
   ORG_MEMBER: (orgId: string, userId: string) => `${API_BASE}/orgs/${orgId}/members/${userId}`,
@@ -584,6 +606,30 @@ export const ENDPOINTS = {
   EXTERNAL_TRIGGER_RUN: (orgId: string, runId: string) =>
     `${API_BASE}/orgs/${orgId}/external-trigger-runs/${runId}`,
 
+  // External IM channel (org-scoped, platform-mediated Feishu/Slack)
+  CHANNEL_CONNECTIONS: (orgId: string) => `${API_BASE}/orgs/${orgId}/channel-connections`,
+  CHANNEL_CONNECTION: (orgId: string, connectionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}`,
+  CHANNEL_CONNECTION_CREDENTIALS: (orgId: string, connectionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/credentials`,
+  CHANNEL_CONNECTION_INGRESS_TOKEN_REGENERATE: (orgId: string, connectionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/ingress-token/regenerate`,
+  CHANNEL_CONNECTION_CONVERSATIONS: (orgId: string, connectionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/conversations`,
+  CHANNEL_CONVERSATION: (orgId: string, conversationId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}`,
+  CHANNEL_CONVERSATION_MESSAGES: (orgId: string, conversationId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}/messages`,
+  CHANNEL_CONVERSATION_SESSION: (orgId: string, conversationId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}/session`,
+  CHANNEL_MESSAGE: (orgId: string, messageId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-messages/${messageId}`,
+  CHANNEL_PROVISIONING: (orgId: string) => `${API_BASE}/orgs/${orgId}/channel-provisioning`,
+  CHANNEL_PROVISIONING_SESSION: (orgId: string, sessionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}`,
+  CHANNEL_PROVISIONING_CANCEL: (orgId: string, sessionId: string) =>
+    `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}/cancel`,
+
   // Invitations (org-scoped, admin)
   ORG_INVITATIONS: (orgId: string) => `${API_BASE}/orgs/${orgId}/invitations`,
   ORG_INVITATION: (orgId: string, invId: string) =>
@@ -608,9 +654,17 @@ export const ENDPOINTS = {
 
   // Wikis (org-scoped, served by wiki-service)
   WIKIS: (orgId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis`,
+  // Recycle bin — soft-deleted wikis (owner only). Must precede WIKI in the
+  // backend router so `deleted` isn't captured as a {wikiId}; the SDK builder
+  // is just a string.
+  WIKIS_DELETED: (orgId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis/deleted`,
+  // Detail URL — also reused for DELETE (soft-delete) and `${WIKI}/restore`.
   WIKI: (orgId: string, wikiId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}`,
+  WIKI_RESTORE: (orgId: string, wikiId: string) =>
+    `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restore`,
   WIKI_TREE: (orgId: string, wikiId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/tree`,
   WIKI_BLOB: (orgId: string, wikiId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/blob`,
+  WIKI_COPY: (orgId: string, wikiId: string) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/copy`,
   WIKI_NODE_SECTIONS: (orgId: string, wikiId: string) =>
     `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/node-sections`,
   WIKI_SEARCH: (orgId: string, wikiId: string) =>
@@ -695,6 +749,11 @@ export const ENDPOINTS = {
   DISPATCH_ACK_BY_ID: (orgId: string, id: string) => `${API_BASE}/orgs/${orgId}/dispatch/${id}/ack`,
   DISPATCH_EXPIRE: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/expire`,
   DISPATCH_BY_MESSAGES: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/by-messages`,
+  DISPATCH_CLAIM: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/claim`,
+  DISPATCH_STEER: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/steer`,
+  DISPATCH_COMPLETE: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/complete`,
+  DISPATCH_RELEASE: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/release`,
+  DISPATCH_HEARTBEAT: (orgId: string) => `${API_BASE}/orgs/${orgId}/dispatch/heartbeat`,
 
   // Unread
   UNREAD: `${API_BASE}/me/unread`,
@@ -734,6 +793,19 @@ export const ENDPOINTS = {
   BILLING_SETUP_INTENT: (orgId: string) => `${API_BASE}/orgs/${orgId}/billing/setup-intent`,
   COMPUTE_PRICING: () => `${API_BASE}/billing/compute-pricing`,
 
+  // Runtime capability table (public, no auth) — SSOT for the create/settings
+  // interlock: per-runtime compute modes, native model family, cross-family
+  // availability, and recommended model.
+  RUNTIMES: () => `${API_BASE}/runtimes`,
+
+  // Model catalog (public, no auth) — served from the server's DB-backed
+  // snapshot. Optional include_model keeps an agent's pinned hidden legacy
+  // model representable in settings pickers.
+  MODELS: (includeModel?: string) =>
+    includeModel
+      ? `${API_BASE}/models?include_model=${encodeURIComponent(includeModel)}`
+      : `${API_BASE}/models`,
+
   // ADMIN_GRANTS intentionally NOT exported here — it sits under the
   // unauthenticated `/internal/admin/*` surface and must not bleed into the
   // public SDK. Admin dashboard hits the URL directly from its own client.
@@ -750,6 +822,7 @@ export const ENDPOINTS = {
     `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips/${clipId}`,
   CLIP_INVOKE: (orgId: string) => `${CLIP_BASE}/orgs/${orgId}/invoke`,
   CLIP_ONLINE: (orgId: string) => `${CLIP_BASE}/orgs/${orgId}/online`,
+  BROWSER_RUNTIME_STATUS: (orgId: string) => `${CLIP_BASE}/orgs/${orgId}/browser-runtime/status`,
   BROWSER_PROFILES: (orgId: string) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles`,
   BROWSER_PROFILE: (orgId: string, profileId: string) =>
     `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}`,
@@ -772,6 +845,42 @@ export const ENDPOINTS = {
   CLIP_REGISTRY: () => `${CLIP_BASE}/registry/clips`,
 } as const;
 
+/**
+ * Wiki personal-namespace prefix — the path subtree a member owns for
+ * self-service private spaces: `users/{userId}/`. SSOT mirror of the
+ * wiki-service `personalNamespacePrefix` (server/internal/wiki/handler/acl.go):
+ * a member may create/manage path restrictions anywhere under this prefix
+ * without org/path admin. The trailing slash is load-bearing — it keeps a user
+ * ID that is a string prefix of another from matching across namespaces.
+ */
+export function wikiPersonalNamespacePrefix(userId: string): string {
+  return `users/${userId}/`;
+}
+
+/**
+ * Whether `path` falls inside `userId`'s personal namespace (the namespace root
+ * itself or any descendant). Mirrors the server's `ownsPersonalNamespacePath`;
+ * use it for UI affordance gating only — the wiki-service stays the security
+ * SSOT and re-checks on every mutation.
+ */
+export function isInWikiPersonalNamespace(userId: string, path: string): boolean {
+  if (!userId) return false;
+  const prefix = wikiPersonalNamespacePrefix(userId);
+  return path === prefix || path.startsWith(prefix);
+}
+
+/**
+ * Whether `path` falls inside ANY user's personal namespace (`users/{id}/…`),
+ * regardless of whose. UI affordance helper — e.g. badging member personal-space
+ * restriction rows in the admin Access tab, or keeping "copy to shared wiki"
+ * destinations out of personal namespaces. Matches by shape (`users/<segment>/`
+ * or the bare `users/<segment>`), deliberately broader than
+ * `isInWikiPersonalNamespace`.
+ */
+export function isWikiPersonalNamespacePath(path: string): boolean {
+  return /^users\/[^/]+(\/|$)/.test(path);
+}
+
 // WebSocket event types
 export const WS_EVENTS = {
   // Client -> Server
@@ -813,10 +922,13 @@ export const WS_EVENTS = {
   INVITATION_REVOKED: 'invitation.revoked',
   ORG_JOIN_REQUEST_NEW: 'org.join_request.new',
   ORG_INVITE_LINK_JOINED: 'org.invite_link.joined',
+  ORG_MEMBER_REMOVED: 'org.member.removed',
   AGENT_CONFIG_UPDATE: 'agent_config.update',
   PRESENCE_UPDATE: 'presence.update',
   WIKI_CHANGESET_CREATED: 'wiki.changeset.created',
   WIKI_CHANGESET_UPDATED: 'wiki.changeset.updated',
+  WIKI_DELETED: 'wiki.deleted',
+  WIKI_RESTORED: 'wiki.restored',
   COMMENT_CREATED: 'comment.created',
   COMMENT_UPDATED: 'comment.updated',
   COMMENT_DELETED: 'comment.deleted',
@@ -827,6 +939,7 @@ export const WS_EVENTS = {
   READ_POSITION_UPDATED: 'read_position.updated',
   DISPATCH_NEW: 'dispatch.new',
   DISPATCH_RECEIVED: 'dispatch.received',
+  DISPATCH_RESOLVED: 'dispatch.resolved',
   SCHEDULE_CREATED: 'schedule.created',
   SCHEDULE_UPDATED: 'schedule.updated',
   SCHEDULE_DELETED: 'schedule.deleted',
@@ -844,6 +957,7 @@ export const WS_EVENTS = {
   MACHINE_FILESYSTEM_BROWSE: 'machine.filesystem.browse',
   MACHINE_UPDATE: 'machine.update',
   MACHINE_CONFIG_UPDATED: 'machine.config.updated',
+  MACHINE_AGENT_CONFIG_UPDATED: 'machine.agent_config.updated',
   MACHINE_CLIP_SYNC: 'machine.clip.sync',
   MACHINE_BROWSER_PROFILE_LIFECYCLE: 'machine.browser_profile.lifecycle',
   MACHINE_BROWSER_PROFILE_VIEWER: 'machine.browser_profile.viewer',