@parall/sdk 1.30.0 → 1.32.0

package/src/client.ts

@@ -52,6 +52,7 @@ import type {
   TaskRelation,
   TaskRelationTargetType,
   TaskWatcher,
+  RefSearchResponse,
   ThreadWatcher,
   CreateTaskRelationRequest,
   TaskComment,
@@ -75,6 +76,9 @@ import type {
   NewSessionResponse,
   OrgInvitation,
   InvitationPublicInfo,
+  OrgInviteLink,
+  JoinByLinkResponse,
+  OrgJoinRequest,
   PlatformConfigResponse,
   Wiki,
   WikiBlob,
@@ -126,6 +130,7 @@ import type {
   TransferChatOwnershipRequest,
   UpdateChatMemberRequest,
   UnreadEntry,
+  ThreadUnreadEntry,
   BillingSummary,
   CreditTransaction,
   CreditTransactionAgentGroup,
@@ -137,6 +142,16 @@ import type {
   UpdateAutoReloadRequest,
   ComputePricing,
   ComputePricingResponse,
+  Clip,
+  AgentClip,
+  CreateClipRequest,
+  UpdateClipRequest,
+  BindAgentClipRequest,
+  InvokeClipRequest,
+  InvokeClipResponse,
+  OnlineClipInfo,
+  RegistryClipInfo,
+  MachineClipInstall,
 } from './types.js';
 
 export interface ParallClientOptions {
@@ -159,16 +174,26 @@ export class ParallClient {
 
   /** Auth endpoints excluded from automatic 401 refresh to prevent recursion. */
   private static readonly AUTH_PATHS = new Set([
-    '/auth/login', '/auth/register', '/auth/refresh', '/auth/logout',
-    '/auth/verify-email', '/auth/resend-code', '/auth/check-email',
-    '/auth/forgot-password', '/auth/reset-password',
+    '/auth/login',
+    '/auth/register',
+    '/auth/refresh',
+    '/auth/logout',
+    '/auth/verify-email',
+    '/auth/resend-code',
+    '/auth/check-email',
+    '/auth/forgot-password',
+    '/auth/reset-password',
   ]);
 
   /** Proactive refresh when token expires within this window (seconds). */
   private static readonly REFRESH_THRESHOLD_S = 5 * 60;
 
   private static normalizeFetchError(err: unknown): ApiError {
-    if (typeof DOMException !== 'undefined' && err instanceof DOMException && (err.name === 'TimeoutError' || err.name === 'AbortError')) {
+    if (
+      typeof DOMException !== 'undefined' &&
+      err instanceof DOMException &&
+      (err.name === 'TimeoutError' || err.name === 'AbortError')
+    ) {
       // The SDK only creates internal timeout signals today. If caller-owned
       // cancellation is added later, AbortError should get its own code.
       return new ApiError(0, 'Request timed out', 'REQUEST_TIMEOUT');
@@ -328,10 +353,18 @@ export class ParallClient {
 
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === 'object' ? rawErrorBody as Record<string, unknown> : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === 'object' ? errorBody.error as { message?: string; code?: string } : undefined;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
+      const errorBody =
+        rawErrorBody !== null && typeof rawErrorBody === 'object'
+          ? (rawErrorBody as Record<string, unknown>)
+          : {};
+      const errorObj =
+        errorBody?.error && typeof errorBody.error === 'object'
+          ? (errorBody.error as { message?: string; code?: string })
+          : undefined;
+      const errMsg =
+        errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
+      const errCode =
+        errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
       const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
       const { error: _e, code: _c, message: _m, ...extras } = errorBody;
       if (Object.keys(extras).length > 0) apiError.extras = extras;
@@ -397,10 +430,18 @@ export class ParallClient {
 
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === 'object' ? rawErrorBody as Record<string, unknown> : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === 'object' ? errorBody.error as { message?: string; code?: string } : undefined;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
+      const errorBody =
+        rawErrorBody !== null && typeof rawErrorBody === 'object'
+          ? (rawErrorBody as Record<string, unknown>)
+          : {};
+      const errorObj =
+        errorBody?.error && typeof errorBody.error === 'object'
+          ? (errorBody.error as { message?: string; code?: string })
+          : undefined;
+      const errMsg =
+        errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
+      const errCode =
+        errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
       const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
       const { error: _e, code: _c, message: _m, ...extras } = errorBody;
       if (Object.keys(extras).length > 0) apiError.extras = extras;
@@ -450,7 +491,10 @@ export class ParallClient {
   }
 
   async resetPassword(token: string, newPassword: string): Promise<AuthTokens> {
-    return this.request('POST', ENDPOINTS.AUTH_RESET_PASSWORD, { token, new_password: newPassword });
+    return this.request('POST', ENDPOINTS.AUTH_RESET_PASSWORD, {
+      token,
+      new_password: newPassword,
+    });
   }
 
   // ---- WebSocket ----
@@ -483,7 +527,11 @@ export class ParallClient {
     return this.request('DELETE', ENDPOINTS.USER_AVATAR);
   }
 
-  async uploadAgentAvatar(orgId: string, agentId: string, file: File | Blob): Promise<AvatarUploadResponse> {
+  async uploadAgentAvatar(
+    orgId: string,
+    agentId: string,
+    file: File | Blob,
+  ): Promise<AvatarUploadResponse> {
     const fd = new FormData();
     fd.append('file', file);
     return this.multipartRequest('POST', ENDPOINTS.AGENT_AVATAR(orgId, agentId), fd);
@@ -497,10 +545,13 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.USER(id));
   }
 
-
   // ---- Organizations ----
 
-  async createOrg(data: { name: string; invite_code: string; avatar_url?: string }): Promise<Organization> {
+  async createOrg(data: {
+    name: string;
+    invite_code: string;
+    avatar_url?: string;
+  }): Promise<Organization> {
     return this.request('POST', ENDPOINTS.ORGS, data);
   }
 
@@ -520,7 +571,12 @@ export class ParallClient {
    */
   async updateOrg(
     orgId: string,
-    data: Partial<Pick<Organization, 'name' | 'avatar_url' | 'smart_routing_strategy' | 'smart_routing_agent_id'>>,
+    data: Partial<
+      Pick<
+        Organization,
+        'name' | 'avatar_url' | 'smart_routing_strategy' | 'smart_routing_agent_id'
+      >
+    >,
   ): Promise<Organization> {
     return this.request('PATCH', ENDPOINTS.ORG(orgId), data);
   }
@@ -535,10 +591,20 @@ export class ParallClient {
   }
 
   async getOnlineMembers(orgId: string): Promise<string[]> {
-    const res = await this.request<{ user_ids: string[] }>('GET', ENDPOINTS.ORG_MEMBERS_ONLINE(orgId));
+    const res = await this.request<{ user_ids: string[] }>(
+      'GET',
+      ENDPOINTS.ORG_MEMBERS_ONLINE(orgId),
+    );
     return res.user_ids ?? [];
   }
 
+  async searchRefs(
+    orgId: string,
+    params?: { q?: string; limit_per_type?: number },
+  ): Promise<RefSearchResponse> {
+    return this.request('GET', ENDPOINTS.REF_SEARCH(orgId), undefined, params);
+  }
+
   async removeOrgMember(orgId: string, userId: string): Promise<void> {
     return this.request('DELETE', ENDPOINTS.ORG_MEMBER(orgId, userId));
   }
@@ -585,12 +651,19 @@ export class ParallClient {
 
   // ---- Invitations ----
 
-  async createInvitation(orgId: string, email: string, role?: OrgMemberRole): Promise<OrgInvitation> {
+  async createInvitation(
+    orgId: string,
+    email: string,
+    role?: OrgMemberRole,
+  ): Promise<OrgInvitation> {
     return this.request('POST', ENDPOINTS.ORG_INVITATIONS(orgId), { email, role });
   }
 
   async getOrgInvitations(orgId: string): Promise<OrgInvitation[]> {
-    const res = await this.request<{ data: OrgInvitation[] }>('GET', ENDPOINTS.ORG_INVITATIONS(orgId));
+    const res = await this.request<{ data: OrgInvitation[] }>(
+      'GET',
+      ENDPOINTS.ORG_INVITATIONS(orgId),
+    );
     return res.data;
   }
 
@@ -619,9 +692,59 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.INVITATION_BY_TOKEN(token));
   }
 
+  // ---- Org-level shareable invite link ----
+
+  /** Fetch the org's current invite link. Auto-creates on first call
+   *  so the settings UI never sees an empty state. */
+  async getOrgInviteLink(orgId: string): Promise<OrgInviteLink> {
+    return this.request('GET', ENDPOINTS.ORG_INVITE_LINK(orgId));
+  }
+
+  /** Rotate the token in place. The old token stops resolving immediately. */
+  async regenerateOrgInviteLink(orgId: string): Promise<OrgInviteLink> {
+    return this.request('POST', ENDPOINTS.ORG_INVITE_LINK_REGENERATE(orgId));
+  }
+
+  /** Toggle the require-approval flag on the org's invite link. */
+  async updateOrgInviteLink(
+    orgId: string,
+    data: { require_approval: boolean },
+  ): Promise<OrgInviteLink> {
+    return this.request('PATCH', ENDPOINTS.ORG_INVITE_LINK(orgId), data);
+  }
+
+  /** Redeem an invite-link token. Caller must be authenticated; the
+   *  token is the lookup key so this endpoint is NOT org-scoped. */
+  async joinByInviteLink(token: string): Promise<JoinByLinkResponse> {
+    return this.request('POST', ENDPOINTS.INVITE_LINK_JOIN, { token });
+  }
+
+  /** Admin: list pending invite-link join requests for an org. */
+  async listOrgJoinRequests(orgId: string): Promise<OrgJoinRequest[]> {
+    const res = await this.request<{ data: OrgJoinRequest[] }>(
+      'GET',
+      ENDPOINTS.ORG_INVITE_LINK_JOIN_REQUESTS(orgId),
+    );
+    return res.data;
+  }
+
+  /** Admin: approve or reject a pending invite-link join request. */
+  async decideOrgJoinRequest(
+    orgId: string,
+    jrId: string,
+    decision: 'approve' | 'reject',
+  ): Promise<OrgJoinRequest> {
+    return this.request('POST', ENDPOINTS.ORG_INVITE_LINK_JOIN_REQUEST_DECIDE(orgId, jrId), {
+      decision,
+    });
+  }
+
   // ---- Direct Messages (org-scoped) ----
 
-  async sendDirectMessage(orgId: string, req: SendDirectMessageRequest): Promise<DirectMessageResponse> {
+  async sendDirectMessage(
+    orgId: string,
+    req: SendDirectMessageRequest,
+  ): Promise<DirectMessageResponse> {
     return this.request('POST', ENDPOINTS.DM(orgId), req);
   }
 
@@ -655,7 +778,22 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.CHAT(orgId, chatId));
   }
 
-  async updateChat(orgId: string, chatId: string, data: Partial<Pick<Chat, 'name' | 'avatar_url' | 'description' | 'visibility' | 'agent_routing_mode' | 'smart_routing_strategy' | 'smart_routing_agent_id'>>): Promise<Chat> {
+  async updateChat(
+    orgId: string,
+    chatId: string,
+    data: Partial<
+      Pick<
+        Chat,
+        | 'name'
+        | 'avatar_url'
+        | 'description'
+        | 'visibility'
+        | 'agent_routing_mode'
+        | 'smart_routing_strategy'
+        | 'smart_routing_agent_id'
+      >
+    >,
+  ): Promise<Chat> {
     return this.request('PATCH', ENDPOINTS.CHAT(orgId, chatId), data);
   }
 
@@ -677,7 +815,12 @@ export class ParallClient {
   }
 
   async deleteChat(orgId: string, chatId: string, opts?: { force?: boolean }): Promise<void> {
-    return this.request('DELETE', ENDPOINTS.CHAT(orgId, chatId), undefined, opts?.force ? { force: 'true' } : undefined);
+    return this.request(
+      'DELETE',
+      ENDPOINTS.CHAT(orgId, chatId),
+      undefined,
+      opts?.force ? { force: 'true' } : undefined,
+    );
   }
 
   async archiveChat(orgId: string, chatId: string): Promise<void> {
@@ -691,7 +834,10 @@ export class ParallClient {
   // ---- Chat Members ----
 
   async getChatMembers(orgId: string, chatId: string): Promise<ChatMember[]> {
-    const res = await this.request<{ data: ChatMember[] }>('GET', ENDPOINTS.CHAT_MEMBERS(orgId, chatId));
+    const res = await this.request<{ data: ChatMember[] }>(
+      'GET',
+      ENDPOINTS.CHAT_MEMBERS(orgId, chatId),
+    );
     return res.data;
   }
 
@@ -703,15 +849,29 @@ export class ParallClient {
     return this.request('DELETE', ENDPOINTS.CHAT_MEMBER(orgId, chatId, userId));
   }
 
-  async updateChatMemberRole(orgId: string, chatId: string, userId: string, role: ChatMemberRole): Promise<void> {
+  async updateChatMemberRole(
+    orgId: string,
+    chatId: string,
+    userId: string,
+    role: ChatMemberRole,
+  ): Promise<void> {
     return this.request('PATCH', ENDPOINTS.CHAT_MEMBER(orgId, chatId, userId), { role });
   }
 
-  async updateChatMember(orgId: string, chatId: string, userId: string, req: UpdateChatMemberRequest): Promise<ChatMember> {
+  async updateChatMember(
+    orgId: string,
+    chatId: string,
+    userId: string,
+    req: UpdateChatMemberRequest,
+  ): Promise<ChatMember> {
     return this.request('PATCH', ENDPOINTS.CHAT_MEMBER(orgId, chatId, userId), req);
   }
 
-  async transferChatOwnership(orgId: string, chatId: string, req: TransferChatOwnershipRequest): Promise<void> {
+  async transferChatOwnership(
+    orgId: string,
+    chatId: string,
+    req: TransferChatOwnershipRequest,
+  ): Promise<void> {
     return this.request('POST', ENDPOINTS.CHAT_TRANSFER_OWNERSHIP(orgId, chatId), req);
   }
 
@@ -732,7 +892,12 @@ export class ParallClient {
       top_level?: boolean;
     },
   ): Promise<PaginatedResponse<Message>> {
-    return this.request('GET', ENDPOINTS.CHAT_MESSAGES(orgId, chatId), undefined, params as Record<string, string | number | boolean | undefined>);
+    return this.request(
+      'GET',
+      ENDPOINTS.CHAT_MESSAGES(orgId, chatId),
+      undefined,
+      params as Record<string, string | number | boolean | undefined>,
+    );
   }
 
   async getMessage(id: string): Promise<Message> {
@@ -765,7 +930,12 @@ export class ParallClient {
   }
 
   async getFileUrl(id: string, opts?: { download?: boolean }): Promise<FileUrlResponse> {
-    return this.request('GET', ENDPOINTS.FILE(id), undefined, opts?.download ? { download: true } : undefined);
+    return this.request(
+      'GET',
+      ENDPOINTS.FILE(id),
+      undefined,
+      opts?.download ? { download: true } : undefined,
+    );
   }
 
   // ---- Approvals ----
@@ -798,7 +968,11 @@ export class ParallClient {
 
   // ---- Agents (org-scoped) ----
 
-  async createAgent(orgId: string, req: CreateAgentRequest, opts?: { timeoutMs?: number }): Promise<CreateAgentResponse> {
+  async createAgent(
+    orgId: string,
+    req: CreateAgentRequest,
+    opts?: { timeoutMs?: number },
+  ): Promise<CreateAgentResponse> {
     return this.request('POST', ENDPOINTS.AGENTS(orgId), req, undefined, false, opts);
   }
 
@@ -817,10 +991,7 @@ export class ParallClient {
    * topology metadata (base URL → provider / tenant) to non-admins,
    * so this dedicated endpoint is the only read path.
    */
-  async getAgentProviderConfig(
-    orgId: string,
-    agentId: string,
-  ): Promise<AgentProviderConfigRead> {
+  async getAgentProviderConfig(orgId: string, agentId: string): Promise<AgentProviderConfigRead> {
     return this.request('GET', ENDPOINTS.AGENT_PROVIDER_CONFIG(orgId, agentId));
   }
 
@@ -849,13 +1020,25 @@ export class ParallClient {
     return this.request('DELETE', ENDPOINTS.AGENT_API_KEY(orgId, agentId, key));
   }
 
-  async getAgentActivity(orgId: string, agentId: string, params?: { limit?: number }): Promise<Message[]> {
-    const res = await this.request<{ data: Message[] }>('GET', ENDPOINTS.AGENT_ACTIVITY(orgId, agentId), undefined, params);
+  async getAgentActivity(
+    orgId: string,
+    agentId: string,
+    params?: { limit?: number },
+  ): Promise<Message[]> {
+    const res = await this.request<{ data: Message[] }>(
+      'GET',
+      ENDPOINTS.AGENT_ACTIVITY(orgId, agentId),
+      undefined,
+      params,
+    );
     return res.data;
   }
 
   async getAgentMonitor(orgId: string, agentId: string): Promise<unknown> {
-    const res = await this.request<{ data: unknown }>('GET', ENDPOINTS.AGENT_MONITOR(orgId, agentId));
+    const res = await this.request<{ data: unknown }>(
+      'GET',
+      ENDPOINTS.AGENT_MONITOR(orgId, agentId),
+    );
     return res.data;
   }
 
@@ -871,7 +1054,11 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.AGENT_NEW_SESSION(orgId, agentId));
   }
 
-  async createAgentSession(orgId: string, agentId: string, req: CreateAgentSessionRequest): Promise<AgentSessionDB> {
+  async createAgentSession(
+    orgId: string,
+    agentId: string,
+    req: CreateAgentSessionRequest,
+  ): Promise<AgentSessionDB> {
     return this.request('POST', ENDPOINTS.AGENT_SESSIONS(orgId, agentId), req);
   }
 
@@ -879,27 +1066,60 @@ export class ParallClient {
    * List agent sessions.
    * @param params.status - Comma-separated status filter (e.g., `'open'`).
    */
-  async getAgentSessions(orgId: string, agentId: string, params?: { limit?: number; status?: string; cursor?: string }): Promise<PaginatedResponse<AgentSessionDB>> {
+  async getAgentSessions(
+    orgId: string,
+    agentId: string,
+    params?: { limit?: number; status?: string; cursor?: string },
+  ): Promise<PaginatedResponse<AgentSessionDB>> {
     return this.request('GET', ENDPOINTS.AGENT_SESSIONS(orgId, agentId), undefined, params);
   }
 
-  async getAgentSession(orgId: string, agentId: string, sessionId: string): Promise<AgentSessionDB> {
+  async getAgentSession(
+    orgId: string,
+    agentId: string,
+    sessionId: string,
+  ): Promise<AgentSessionDB> {
     return this.request('GET', ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId));
   }
 
-  async updateAgentSession(orgId: string, agentId: string, sessionId: string, req: UpdateAgentSessionRequest): Promise<AgentSessionDB> {
+  async updateAgentSession(
+    orgId: string,
+    agentId: string,
+    sessionId: string,
+    req: UpdateAgentSessionRequest,
+  ): Promise<AgentSessionDB> {
     return this.request('PATCH', ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId), req);
   }
 
-  async createAgentStep(orgId: string, agentId: string, sessionId: string, req: CreateAgentStepRequest): Promise<AgentStep> {
+  async createAgentStep(
+    orgId: string,
+    agentId: string,
+    sessionId: string,
+    req: CreateAgentStepRequest,
+  ): Promise<AgentStep> {
     return this.request('POST', ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), req);
   }
 
-  async getAgentSessionSteps(orgId: string, agentId: string, sessionId: string, params?: { limit?: number; cursor?: string }): Promise<PaginatedResponse<AgentStep>> {
-    return this.request('GET', ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), undefined, params);
+  async getAgentSessionSteps(
+    orgId: string,
+    agentId: string,
+    sessionId: string,
+    params?: { limit?: number; cursor?: string },
+  ): Promise<PaginatedResponse<AgentStep>> {
+    return this.request(
+      'GET',
+      ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId),
+      undefined,
+      params,
+    );
   }
 
-  async getAgentSessionStep(orgId: string, agentId: string, sessionId: string, stepId: string): Promise<AgentStep> {
+  async getAgentSessionStep(
+    orgId: string,
+    agentId: string,
+    sessionId: string,
+    stepId: string,
+  ): Promise<AgentStep> {
     return this.request('GET', ENDPOINTS.AGENT_SESSION_STEP(orgId, agentId, sessionId, stepId));
   }
 
@@ -918,11 +1138,7 @@ export class ParallClient {
     agentId: string,
     req: StartRuntimeAuthSessionRequest = {},
   ): Promise<RuntimeAuthSession> {
-    return this.request(
-      'POST',
-      ENDPOINTS.AGENT_RUNTIME_AUTH_SESSIONS(orgId, agentId),
-      req,
-    );
+    return this.request('POST', ENDPOINTS.AGENT_RUNTIME_AUTH_SESSIONS(orgId, agentId), req);
   }
 
   async completeAgentRuntimeAuthSession(
@@ -982,7 +1198,12 @@ export class ParallClient {
     do {
       const params: Record<string, string> = { limit: '100' };
       if (cursor) params.cursor = cursor;
-      const res = await this.request<PaginatedResponse<Task>>('GET', ENDPOINTS.AGENT_TASKS(orgId, agentId), undefined, params);
+      const res = await this.request<PaginatedResponse<Task>>(
+        'GET',
+        ENDPOINTS.AGENT_TASKS(orgId, agentId),
+        undefined,
+        params,
+      );
       all.push(...res.data);
       cursor = res.has_more ? res.next_cursor : undefined;
     } while (cursor);
@@ -1020,21 +1241,30 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.MACHINE_LOGS(orgId, machineId), undefined, { lines });
   }
 
-  async restartMachine(orgId: string, machineId: string): Promise<{ machine_id: string; command_id: string }> {
+  async restartMachine(
+    orgId: string,
+    machineId: string,
+  ): Promise<{ machine_id: string; command_id: string }> {
     return this.request('POST', ENDPOINTS.MACHINE_RESTART(orgId, machineId));
   }
 
-  async restartAllMachines(orgId: string): Promise<{ data: Array<{ machine_id: string; command_id?: string; status: string; error?: string }>; total: number }> {
+  async restartAllMachines(orgId: string): Promise<{
+    data: Array<{ machine_id: string; command_id?: string; status: string; error?: string }>;
+    total: number;
+  }> {
     return this.request('POST', ENDPOINTS.MACHINE_RESTART_ALL(orgId));
   }
 
   // ---- Daemon-mode Machine management (org-scoped, user auth) ----
 
   /**
-   * Create a new daemon-mode Machine. Returns the Machine row + one-shot
-   * mck_ token. The UI uses this when the user clicks "Create Workspace".
+   * Create a new self-hosted daemon-mode Machine. Returns the Machine row +
+   * one-shot mck_ token.
    */
-  async createMachine(orgId: string, opts: { label?: string; tier?: string; llm_source?: string; compute_mode?: 'hosted' | 'local' }): Promise<{
+  async createMachine(
+    orgId: string,
+    opts: { label?: string; compute_mode: 'local'; llm_source?: 'parall' | 'runtime_auth' },
+  ): Promise<{
     machine: Machine;
     machine_key: string;
     key_id: string;
@@ -1043,16 +1273,24 @@ export class ParallClient {
   }
 
   /**
-   * Returns only daemon_mode=true machines (non-terminated). Backs the
-   * "Workspaces" UI list. Legacy 1:1 machines are excluded.
+   * Returns local daemon_mode=true machines (non-terminated). Backs the
+   * "Workspaces" UI list. Legacy 1:1 and retired hosted daemon machines are
+   * excluded.
    */
   async getDaemonMachines(orgId: string): Promise<Machine[]> {
     const all = await this.getMachines(orgId);
-    return all.filter((m) => m.daemon_mode && m.status !== 'terminated');
+    return all.filter(
+      (m) => m.daemon_mode && m.compute_mode === 'local' && m.status !== 'terminated',
+    );
   }
 
   /** Attach an agent to a daemon-mode Machine. */
-  async attachAgent(orgId: string, machineId: string, agentId: string, opts?: AttachAgentRequest): Promise<{ status: string; machine_id: string; agent_id: string }> {
+  async attachAgent(
+    orgId: string,
+    machineId: string,
+    agentId: string,
+    opts?: AttachAgentRequest,
+  ): Promise<{ status: string; machine_id: string; agent_id: string }> {
     return this.request('POST', ENDPOINTS.MACHINE_ATTACH_AGENT(orgId, machineId, agentId), opts);
   }
 
@@ -1062,20 +1300,36 @@ export class ParallClient {
   }
 
   async listAgentWorkspaceStates(orgId: string, machineId: string): Promise<AgentWorkspaceState[]> {
-    const res = await this.request<{ data: AgentWorkspaceState[] }>('GET', ENDPOINTS.MACHINE_WORKSPACE_STATES(orgId, machineId));
+    const res = await this.request<{ data: AgentWorkspaceState[] }>(
+      'GET',
+      ENDPOINTS.MACHINE_WORKSPACE_STATES(orgId, machineId),
+    );
     return res.data;
   }
 
-  async patchAgentDaemonConfig(orgId: string, machineId: string, agentId: string, daemonConfig: DaemonAgentConfig): Promise<void> {
-    return this.request('PATCH', ENDPOINTS.MACHINE_AGENT_DAEMON_CONFIG(orgId, machineId, agentId), { daemon_config: daemonConfig });
+  async patchAgentDaemonConfig(
+    orgId: string,
+    machineId: string,
+    agentId: string,
+    daemonConfig: DaemonAgentConfig,
+  ): Promise<void> {
+    return this.request('PATCH', ENDPOINTS.MACHINE_AGENT_DAEMON_CONFIG(orgId, machineId, agentId), {
+      daemon_config: daemonConfig,
+    });
   }
 
   async retryAgentWorkspaceSetup(orgId: string, machineId: string, agentId: string): Promise<void> {
     return this.request('POST', ENDPOINTS.MACHINE_AGENT_WORKSPACE_SETUP(orgId, machineId, agentId));
   }
 
-  async patchMachineLLMSource(orgId: string, machineId: string, llmSource: string): Promise<Machine> {
-    return this.request('PATCH', ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource });
+  async patchMachineLLMSource(
+    orgId: string,
+    machineId: string,
+    llmSource: string,
+  ): Promise<Machine> {
+    return this.request('PATCH', ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), {
+      llm_source: llmSource,
+    });
   }
 
   /** Get machine-level runtime auth state. */
@@ -1097,7 +1351,11 @@ export class ParallClient {
     sessionId: string,
     req: CompleteRuntimeAuthSessionRequest,
   ): Promise<RuntimeAuthSession> {
-    return this.request('POST', ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSION_COMPLETE(orgId, machineId, sessionId), req);
+    return this.request(
+      'POST',
+      ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSION_COMPLETE(orgId, machineId, sessionId),
+      req,
+    );
   }
 
   async disconnectMachineRuntimeAuth(orgId: string, machineId: string): Promise<void> {
@@ -1127,23 +1385,50 @@ export class ParallClient {
     return res.data;
   }
 
+  /** `GET /machines/me/clip-installs` — registry clips this machine should
+   * install but hasn't yet (durable reconcile, mck_-authed). */
+  async listClipInstalls(): Promise<MachineClipInstall[]> {
+    const res = await this.request<{ data: MachineClipInstall[] }>(
+      'GET',
+      ENDPOINTS.MACHINES_ME_CLIP_INSTALLS,
+    );
+    return res.data;
+  }
+
+  /** `POST /machines/me/clip-installs/{clipId}/installed` — report a finished install. */
+  async reportClipInstall(clipId: string, version?: string): Promise<void> {
+    return this.request(
+      'POST',
+      ENDPOINTS.MACHINES_ME_CLIP_INSTALL_DONE(clipId),
+      version ? { version } : undefined,
+    );
+  }
+
   /**
    * `POST /machines/me/health` — bump the Machine's `updated_at` to now.
    * Body is intentionally empty; the server ignores any payload. The
    * daemon should call this on a fixed cadence (e.g. every 30s) so an
    * external observer can detect a wedged supervisor.
    */
-  async postMachineHeartbeat(): Promise<void> {
-    return this.request('POST', ENDPOINTS.MACHINES_ME_HEALTH);
+  async postMachineHeartbeat(daemonVersion?: string): Promise<void> {
+    const body = daemonVersion ? { daemon_version: daemonVersion } : undefined;
+    return this.request('POST', ENDPOINTS.MACHINES_ME_HEALTH, body);
   }
 
-  async reportAgentWorkspaceState(agentId: string, state: {
-    config_hash: string;
-    status: AgentWorkspaceReportStatus;
-    last_error?: string | null;
-    output_tail?: string | null;
-  }): Promise<void> {
-    const res = await this.request<{ status?: string }>('PUT', ENDPOINTS.MACHINES_ME_AGENT_WORKSPACE_STATE(agentId), state);
+  async reportAgentWorkspaceState(
+    agentId: string,
+    state: {
+      config_hash: string;
+      status: AgentWorkspaceReportStatus;
+      last_error?: string | null;
+      output_tail?: string | null;
+    },
+  ): Promise<void> {
+    const res = await this.request<{ status?: string }>(
+      'PUT',
+      ENDPOINTS.MACHINES_ME_AGENT_WORKSPACE_STATE(agentId),
+      state,
+    );
     if (res?.status === 'ignored_stale') {
       throw new ApiError(409, 'Workspace state report ignored as stale', 'STALE_WORKSPACE_STATE');
     }
@@ -1165,21 +1450,52 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.MACHINES_ME_WS_TICKET);
   }
 
-  async postBrowseResponse(requestId: string, response: { request_id: string; path: string; entries: FilesystemEntry[]; error?: string }): Promise<void> {
+  async postBrowseResponse(
+    requestId: string,
+    response: { request_id: string; path: string; entries: FilesystemEntry[]; error?: string },
+  ): Promise<void> {
     return this.request('POST', ENDPOINTS.MACHINES_ME_BROWSE_RESPONSE(requestId), response);
   }
 
-  async resizeMachine(orgId: string, machineId: string, spec: ResizeMachineRequest): Promise<Machine> {
+  async resizeMachine(
+    orgId: string,
+    machineId: string,
+    spec: ResizeMachineRequest,
+  ): Promise<Machine> {
     return this.request('PATCH', ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
 
-  async browseMachineFilesystem(orgId: string, machineId: string, path: string): Promise<BrowseMachineFilesystemResponse> {
-    return this.request('POST', ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path }, undefined, false, { timeoutMs: 15_000 });
+  /** Signal a local daemon-mode Machine to check for and apply an update. */
+  async requestMachineUpdate(orgId: string, machineId: string, mandatory = false): Promise<void> {
+    await this.request('POST', ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
+  }
+
+  async browseMachineFilesystem(
+    orgId: string,
+    machineId: string,
+    path: string,
+  ): Promise<BrowseMachineFilesystemResponse> {
+    return this.request(
+      'POST',
+      ENDPOINTS.MACHINE_BROWSE(orgId, machineId),
+      { path },
+      undefined,
+      false,
+      { timeoutMs: 15_000 },
+    );
   }
 
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
-  async createMachineKey(orgId: string, machineId: string, name?: string): Promise<{ machine_key: string; key_id: string; key: MachineKey }> {
-    return this.request('POST', ENDPOINTS.MACHINE_KEYS(orgId, machineId), name ? { name } : undefined);
+  async createMachineKey(
+    orgId: string,
+    machineId: string,
+    name?: string,
+  ): Promise<{ machine_key: string; key_id: string; key: MachineKey }> {
+    return this.request(
+      'POST',
+      ENDPOINTS.MACHINE_KEYS(orgId, machineId),
+      name ? { name } : undefined,
+    );
   }
 
   /** Revoke (soft-delete) a machine key by ID. */
@@ -1201,12 +1517,25 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.CHAT_READ(orgId, chatId), { message_id: messageId });
   }
 
+  async getThreadUnread(
+    orgId: string,
+    chatId: string,
+    threadRootId: string,
+  ): Promise<ThreadUnreadEntry> {
+    return this.request('GET', ENDPOINTS.THREAD_UNREAD(orgId, chatId, threadRootId));
+  }
+
   // ---- Inbox ----
 
-  async getInbox(orgId: string, params?: {
-    type?: string; read?: string;
-    limit?: number; cursor?: string;
-  }): Promise<PaginatedResponse<InboxItem>> {
+  async getInbox(
+    orgId: string,
+    params?: {
+      type?: string;
+      read?: string;
+      limit?: number;
+      cursor?: string;
+    },
+  ): Promise<PaginatedResponse<InboxItem>> {
     return this.request('GET', ENDPOINTS.INBOX(orgId), undefined, params as Record<string, string>);
   }
 
@@ -1247,17 +1576,36 @@ export class ParallClient {
 
   // ---- Dispatch (agent event delivery) ----
 
-  async getDispatch(orgId: string, params?: {
-    limit?: number; cursor?: string;
-  }): Promise<PaginatedResponse<DispatchEvent>> {
-    return this.request('GET', ENDPOINTS.DISPATCH(orgId), undefined, params as Record<string, string>);
+  async getDispatch(
+    orgId: string,
+    params?: {
+      limit?: number;
+      cursor?: string;
+    },
+  ): Promise<PaginatedResponse<DispatchEvent>> {
+    return this.request(
+      'GET',
+      ENDPOINTS.DISPATCH(orgId),
+      undefined,
+      params as Record<string, string>,
+    );
   }
 
   async getDispatchPendingCount(orgId: string): Promise<{ count: number }> {
     return this.request('GET', ENDPOINTS.DISPATCH_PENDING_COUNT(orgId));
   }
 
-  async ackDispatch(orgId: string, source: { source_type: string; source_id: string }): Promise<void> {
+  async markDispatchReceived(
+    orgId: string,
+    source: { source_type: string; source_id: string },
+  ): Promise<void> {
+    return this.request('POST', ENDPOINTS.DISPATCH_RECEIVED(orgId), source);
+  }
+
+  async ackDispatch(
+    orgId: string,
+    source: { source_type: string; source_id: string },
+  ): Promise<void> {
     return this.request('POST', ENDPOINTS.DISPATCH_ACK(orgId), source);
   }
 
@@ -1265,6 +1613,20 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.DISPATCH_ACK_BY_ID(orgId, id));
   }
 
+  async getDispatchByMessages(
+    orgId: string,
+    chatId: string,
+    messageIds: string[],
+  ): Promise<{ data: DispatchEvent[] }> {
+    const params = { chat_id: chatId, message_ids: messageIds.join(',') };
+    return this.request(
+      'GET',
+      ENDPOINTS.DISPATCH_BY_MESSAGES(orgId),
+      undefined,
+      params as unknown as Record<string, string>,
+    );
+  }
+
   // ---- Platform Config ----
 
   /**
@@ -1295,10 +1657,18 @@ export class ParallClient {
 
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === 'object' ? rawErrorBody as Record<string, unknown> : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === 'object' ? errorBody.error as { message?: string; code?: string } : undefined;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
+      const errorBody =
+        rawErrorBody !== null && typeof rawErrorBody === 'object'
+          ? (rawErrorBody as Record<string, unknown>)
+          : {};
+      const errorObj =
+        errorBody?.error && typeof errorBody.error === 'object'
+          ? (errorBody.error as { message?: string; code?: string })
+          : undefined;
+      const errMsg =
+        errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
+      const errCode =
+        errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
       const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
       const { error: _e, code: _c, message: _m, ...extras } = errorBody;
       if (Object.keys(extras).length > 0) apiError.extras = extras;
@@ -1314,18 +1684,22 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.TASKS(orgId), data);
   }
 
-  async getTasks(orgId: string, params?: {
-    status?: string;
-    priority?: string;
-    assignee_id?: string;
-    parent_id?: string;
-    project_id?: string;
-    limit?: number;
-    cursor?: string;
-    sort?: string;
-    order?: string;
-    scope?: 'active' | 'archived' | 'all';
-  }): Promise<PaginatedResponse<Task>> {
+  async getTasks(
+    orgId: string,
+    params?: {
+      q?: string;
+      status?: string;
+      priority?: string;
+      assignee_id?: string;
+      parent_id?: string;
+      project_id?: string;
+      limit?: number;
+      cursor?: string;
+      sort?: string;
+      order?: string;
+      scope?: 'active' | 'archived' | 'all';
+    },
+  ): Promise<PaginatedResponse<Task>> {
     return this.request('GET', ENDPOINTS.TASKS(orgId), undefined, params);
   }
 
@@ -1338,7 +1712,12 @@ export class ParallClient {
   }
 
   async deleteTask(orgId: string, taskId: string, opts?: { force?: boolean }): Promise<void> {
-    return this.request('DELETE', ENDPOINTS.TASK(orgId, taskId), undefined, opts?.force ? { force: 'true' } : undefined);
+    return this.request(
+      'DELETE',
+      ENDPOINTS.TASK(orgId, taskId),
+      undefined,
+      opts?.force ? { force: 'true' } : undefined,
+    );
   }
 
   async archiveTask(orgId: string, taskId: string): Promise<void> {
@@ -1358,10 +1737,21 @@ export class ParallClient {
   }
 
   async getTaskWatchers(orgId: string, taskId: string): Promise<TaskWatcher[]> {
-    const res = await this.request<{ data: TaskWatcher[] }>('GET', ENDPOINTS.TASK_WATCHERS(orgId, taskId));
+    const res = await this.request<{ data: TaskWatcher[] }>(
+      'GET',
+      ENDPOINTS.TASK_WATCHERS(orgId, taskId),
+    );
     return res.data;
   }
 
+  async subscribeTaskMember(orgId: string, taskId: string, userId: string): Promise<void> {
+    return this.request('PUT', ENDPOINTS.TASK_SUBSCRIBER(orgId, taskId, userId));
+  }
+
+  async unsubscribeTaskMember(orgId: string, taskId: string, userId: string): Promise<void> {
+    return this.request('DELETE', ENDPOINTS.TASK_SUBSCRIBER(orgId, taskId, userId));
+  }
+
   async watchThread(threadRootId: string): Promise<void> {
     return this.request('POST', ENDPOINTS.MESSAGE_WATCH(threadRootId));
   }
@@ -1371,26 +1761,42 @@ export class ParallClient {
   }
 
   async getThreadWatchers(threadRootId: string): Promise<ThreadWatcher[]> {
-    const res = await this.request<{ data: ThreadWatcher[] }>('GET', ENDPOINTS.MESSAGE_WATCHERS(threadRootId));
+    const res = await this.request<{ data: ThreadWatcher[] }>(
+      'GET',
+      ENDPOINTS.MESSAGE_WATCHERS(threadRootId),
+    );
     return res.data;
   }
 
   async isWatchingThread(threadRootId: string): Promise<boolean> {
-    const res = await this.request<{ watching: boolean }>('GET', ENDPOINTS.MESSAGE_WATCHING(threadRootId));
+    const res = await this.request<{ watching: boolean }>(
+      'GET',
+      ENDPOINTS.MESSAGE_WATCHING(threadRootId),
+    );
     return res.watching;
   }
 
   async getSubtasks(orgId: string, taskId: string): Promise<Task[]> {
-    const res = await this.request<PaginatedResponse<Task>>('GET', ENDPOINTS.TASK_SUBTASKS(orgId, taskId));
+    const res = await this.request<PaginatedResponse<Task>>(
+      'GET',
+      ENDPOINTS.TASK_SUBTASKS(orgId, taskId),
+    );
     return res.data;
   }
 
-  async createTaskRelation(orgId: string, taskId: string, data: CreateTaskRelationRequest): Promise<TaskRelation> {
+  async createTaskRelation(
+    orgId: string,
+    taskId: string,
+    data: CreateTaskRelationRequest,
+  ): Promise<TaskRelation> {
     return this.request('POST', ENDPOINTS.TASK_RELATIONS(orgId, taskId), data);
   }
 
   async getTaskRelations(orgId: string, taskId: string): Promise<TaskRelation[]> {
-    const res = await this.request<{ data: TaskRelation[] }>('GET', ENDPOINTS.TASK_RELATIONS(orgId, taskId));
+    const res = await this.request<{ data: TaskRelation[] }>(
+      'GET',
+      ENDPOINTS.TASK_RELATIONS(orgId, taskId),
+    );
     return res.data;
   }
 
@@ -1415,9 +1821,15 @@ export class ParallClient {
 
   // ---- Task Comments ----
 
-  async getTaskComments(orgId: string, taskId: string, params?: {
-    limit?: number; cursor?: string; order?: string;
-  }): Promise<PaginatedResponse<TaskComment>> {
+  async getTaskComments(
+    orgId: string,
+    taskId: string,
+    params?: {
+      limit?: number;
+      cursor?: string;
+      order?: string;
+    },
+  ): Promise<PaginatedResponse<TaskComment>> {
     return this.request('GET', ENDPOINTS.TASK_COMMENTS(orgId, taskId), undefined, params);
   }
 
@@ -1425,11 +1837,20 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.TASK_COMMENT(orgId, taskId, commentId));
   }
 
-  async createTaskComment(orgId: string, taskId: string, data: CreateTaskCommentRequest): Promise<TaskComment> {
+  async createTaskComment(
+    orgId: string,
+    taskId: string,
+    data: CreateTaskCommentRequest,
+  ): Promise<TaskComment> {
     return this.request('POST', ENDPOINTS.TASK_COMMENTS(orgId, taskId), data);
   }
 
-  async updateTaskComment(orgId: string, taskId: string, commentId: string, data: UpdateTaskCommentRequest): Promise<TaskComment> {
+  async updateTaskComment(
+    orgId: string,
+    taskId: string,
+    commentId: string,
+    data: UpdateTaskCommentRequest,
+  ): Promise<TaskComment> {
     return this.request('PATCH', ENDPOINTS.TASK_COMMENT(orgId, taskId, commentId), data);
   }
 
@@ -1439,9 +1860,14 @@ export class ParallClient {
 
   // ---- Task Activities ----
 
-  async getTaskActivities(orgId: string, taskId: string, params?: {
-    limit?: number; cursor?: string;
-  }): Promise<PaginatedResponse<TaskActivity>> {
+  async getTaskActivities(
+    orgId: string,
+    taskId: string,
+    params?: {
+      limit?: number;
+      cursor?: string;
+    },
+  ): Promise<PaginatedResponse<TaskActivity>> {
     return this.request('GET', ENDPOINTS.TASK_ACTIVITIES(orgId, taskId), undefined, params);
   }
 
@@ -1460,7 +1886,11 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.PROJECT(orgId, projectId));
   }
 
-  async updateProject(orgId: string, projectId: string, data: UpdateProjectRequest): Promise<Project> {
+  async updateProject(
+    orgId: string,
+    projectId: string,
+    data: UpdateProjectRequest,
+  ): Promise<Project> {
     return this.request('PATCH', ENDPOINTS.PROJECT(orgId, projectId), data);
   }
 
@@ -1474,15 +1904,27 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.SCHEDULES(orgId), input);
   }
 
-  async listSchedules(orgId: string, filters?: ScheduleFilters): Promise<PaginatedResponse<Schedule>> {
-    return this.request('GET', ENDPOINTS.SCHEDULES(orgId), undefined, filters as Record<string, string | number | undefined>);
+  async listSchedules(
+    orgId: string,
+    filters?: ScheduleFilters,
+  ): Promise<PaginatedResponse<Schedule>> {
+    return this.request(
+      'GET',
+      ENDPOINTS.SCHEDULES(orgId),
+      undefined,
+      filters as Record<string, string | number | undefined>,
+    );
   }
 
   async getSchedule(orgId: string, scheduleId: string): Promise<Schedule> {
     return this.request('GET', ENDPOINTS.SCHEDULE(orgId, scheduleId));
   }
 
-  async updateSchedule(orgId: string, scheduleId: string, patch: UpdateScheduleInput): Promise<Schedule> {
+  async updateSchedule(
+    orgId: string,
+    scheduleId: string,
+    patch: UpdateScheduleInput,
+  ): Promise<Schedule> {
     return this.request('PATCH', ENDPOINTS.SCHEDULE(orgId, scheduleId), patch);
   }
 
@@ -1534,31 +1976,59 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.WIKI(orgId, wikiId));
   }
 
-  async getWikiTree(orgId: string, wikiId: string, params?: { ref?: string; path?: string }): Promise<WikiTreeResponse> {
+  async getWikiTree(
+    orgId: string,
+    wikiId: string,
+    params?: { ref?: string; path?: string },
+  ): Promise<WikiTreeResponse> {
     return this.request('GET', ENDPOINTS.WIKI_TREE(orgId, wikiId), undefined, params);
   }
 
-  async getWikiBlob(orgId: string, wikiId: string, params: { path: string; ref?: string }): Promise<WikiBlob> {
+  async getWikiBlob(
+    orgId: string,
+    wikiId: string,
+    params: { path: string; ref?: string },
+  ): Promise<WikiBlob> {
     return this.request('GET', ENDPOINTS.WIKI_BLOB(orgId, wikiId), undefined, params);
   }
 
-  async getWikiNodeSections(orgId: string, wikiId: string, params?: { ref?: string }): Promise<WikiNodeSectionArtifact> {
+  async getWikiNodeSections(
+    orgId: string,
+    wikiId: string,
+    params?: { ref?: string },
+  ): Promise<WikiNodeSectionArtifact> {
     return this.request('GET', ENDPOINTS.WIKI_NODE_SECTIONS(orgId, wikiId), undefined, params);
   }
 
-  async searchWiki(orgId: string, wikiId: string, params: { q: string; limit?: number; path_prefix?: string; ref?: string }): Promise<WikiSearchResponse> {
+  async searchWiki(
+    orgId: string,
+    wikiId: string,
+    params: { q: string; limit?: number; path_prefix?: string; ref?: string },
+  ): Promise<WikiSearchResponse> {
     return this.request('GET', ENDPOINTS.WIKI_SEARCH(orgId, wikiId), undefined, params);
   }
 
-  async getWikiPageIndex(orgId: string, wikiId: string, params?: { ref?: string }): Promise<WikiPageIndex> {
+  async getWikiPageIndex(
+    orgId: string,
+    wikiId: string,
+    params?: { ref?: string },
+  ): Promise<WikiPageIndex> {
     return this.request('GET', ENDPOINTS.WIKI_PAGE_INDEX(orgId, wikiId), undefined, params);
   }
 
-  async getWikiRefs(orgId: string, wikiId: string, params?: { ref?: string }): Promise<WikiRefsResponse> {
+  async getWikiRefs(
+    orgId: string,
+    wikiId: string,
+    params?: { ref?: string },
+  ): Promise<WikiRefsResponse> {
     return this.request('GET', ENDPOINTS.WIKI_REFS(orgId, wikiId), undefined, params);
   }
 
-  async checkWikiRefs(orgId: string, wikiId: string, params?: { ref?: string }): Promise<WikiRefsCheckResponse> {
+  async checkWikiRefs(
+    orgId: string,
+    wikiId: string,
+    params?: { ref?: string },
+  ): Promise<WikiRefsCheckResponse> {
     return this.request('GET', ENDPOINTS.WIKI_REFS_CHECK(orgId, wikiId), undefined, params);
   }
 
@@ -1572,17 +2042,32 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.WIKI_ANCHOR_STATUS(orgId, wikiId), body);
   }
 
-  async createWikiChangeset(orgId: string, wikiId: string, data: CreateWikiChangesetRequest): Promise<WikiChangeset> {
-    return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId), data));
+  async createWikiChangeset(
+    orgId: string,
+    wikiId: string,
+    data: CreateWikiChangesetRequest,
+  ): Promise<WikiChangeset> {
+    return normalizeWikiChangeset(
+      await this.request('POST', ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId), data),
+    );
   }
 
   async getWikiChangesets(orgId: string, wikiId: string): Promise<WikiChangeset[]> {
-    const res = await this.request<{ data: WikiChangeset[] }>('GET', ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId));
+    const res = await this.request<{ data: WikiChangeset[] }>(
+      'GET',
+      ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId),
+    );
     return res.data.map(normalizeWikiChangeset);
   }
 
-  async getWikiChangeset(orgId: string, wikiId: string, changesetId: string): Promise<WikiChangeset> {
-    return normalizeWikiChangeset(await this.request('GET', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId)));
+  async getWikiChangeset(
+    orgId: string,
+    wikiId: string,
+    changesetId: string,
+  ): Promise<WikiChangeset> {
+    return normalizeWikiChangeset(
+      await this.request('GET', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId)),
+    );
   }
 
   async updateWikiChangeset(
@@ -1591,19 +2076,37 @@ export class ParallClient {
     changesetId: string,
     data: UpdateWikiChangesetRequest,
   ): Promise<WikiChangeset> {
-    return normalizeWikiChangeset(await this.request('PATCH', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId), data));
+    return normalizeWikiChangeset(
+      await this.request('PATCH', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId), data),
+    );
   }
 
-  async getWikiChangesetDiff(orgId: string, wikiId: string, changesetId: string): Promise<WikiDiff> {
+  async getWikiChangesetDiff(
+    orgId: string,
+    wikiId: string,
+    changesetId: string,
+  ): Promise<WikiDiff> {
     return this.request('GET', ENDPOINTS.WIKI_CHANGESET_DIFF(orgId, wikiId, changesetId));
   }
 
-  async mergeWikiChangeset(orgId: string, wikiId: string, changesetId: string): Promise<WikiChangeset> {
-    return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESET_MERGE(orgId, wikiId, changesetId)));
+  async mergeWikiChangeset(
+    orgId: string,
+    wikiId: string,
+    changesetId: string,
+  ): Promise<WikiChangeset> {
+    return normalizeWikiChangeset(
+      await this.request('POST', ENDPOINTS.WIKI_CHANGESET_MERGE(orgId, wikiId, changesetId)),
+    );
   }
 
-  async closeWikiChangeset(orgId: string, wikiId: string, changesetId: string): Promise<WikiChangeset> {
-    return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESET_CLOSE(orgId, wikiId, changesetId)));
+  async closeWikiChangeset(
+    orgId: string,
+    wikiId: string,
+    changesetId: string,
+  ): Promise<WikiChangeset> {
+    return normalizeWikiChangeset(
+      await this.request('POST', ENDPOINTS.WIKI_CHANGESET_CLOSE(orgId, wikiId, changesetId)),
+    );
   }
 
   // ---- Wiki Binary Upload / Delete (Phase 2 of wiki-file-storage-design) ----
@@ -1660,12 +2163,10 @@ export class ParallClient {
     wikiId: string,
     params: { path: string; message?: string },
   ): Promise<void> {
-    await this.request(
-      'DELETE',
-      ENDPOINTS.WIKI_FILES(orgId, wikiId),
-      undefined,
-      { path: params.path, message: params.message },
-    );
+    await this.request('DELETE', ENDPOINTS.WIKI_FILES(orgId, wikiId), undefined, {
+      path: params.path,
+      message: params.message,
+    });
   }
 
   /**
@@ -1678,21 +2179,24 @@ export class ParallClient {
     wikiId: string,
     params: { path: string; ref?: string },
   ): Promise<WikiFilePreviewUrlResponse> {
-    return this.request(
-      'POST',
-      ENDPOINTS.WIKI_FILE_PREVIEW_URL(orgId, wikiId),
-      params,
-    );
+    return this.request('POST', ENDPOINTS.WIKI_FILE_PREVIEW_URL(orgId, wikiId), params);
   }
 
   // ---- Wiki Path Scopes (AFCS ACL) ----
 
   async getWikiPathScopes(orgId: string, wikiId: string): Promise<WikiPathScope[]> {
-    const res = await this.request<{ data: WikiPathScope[] }>('GET', ENDPOINTS.WIKI_PATH_SCOPES(orgId, wikiId));
+    const res = await this.request<{ data: WikiPathScope[] }>(
+      'GET',
+      ENDPOINTS.WIKI_PATH_SCOPES(orgId, wikiId),
+    );
     return res.data;
   }
 
-  async createWikiPathScope(orgId: string, wikiId: string, data: CreateWikiPathScopeRequest): Promise<WikiPathScope> {
+  async createWikiPathScope(
+    orgId: string,
+    wikiId: string,
+    data: CreateWikiPathScopeRequest,
+  ): Promise<WikiPathScope> {
     return this.request('POST', ENDPOINTS.WIKI_PATH_SCOPES(orgId, wikiId), data);
   }
 
@@ -1700,11 +2204,24 @@ export class ParallClient {
     await this.request('DELETE', ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
 
-  async getWikiAccessStatus(orgId: string, wikiId: string, path?: string): Promise<WikiAccessStatus> {
-    return this.request('GET', ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), undefined, path ? { path } : undefined);
+  async getWikiAccessStatus(
+    orgId: string,
+    wikiId: string,
+    path?: string,
+  ): Promise<WikiAccessStatus> {
+    return this.request(
+      'GET',
+      ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId),
+      undefined,
+      path ? { path } : undefined,
+    );
   }
 
-  async createWikiAccessRequest(orgId: string, wikiId: string, data: CreateWikiAccessRequest): Promise<void> {
+  async createWikiAccessRequest(
+    orgId: string,
+    wikiId: string,
+    data: CreateWikiAccessRequest,
+  ): Promise<void> {
     await this.request('POST', ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
   }
 
@@ -1724,7 +2241,10 @@ export class ParallClient {
     path: string,
     params?: { page?: number; limit?: number },
   ): Promise<{ data: WikiCommit[]; page: number; limit: number }> {
-    return this.request('GET', ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), undefined, { path, ...params });
+    return this.request('GET', ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), undefined, {
+      path,
+      ...params,
+    });
   }
 
   async getWikiBlame(
@@ -1759,8 +2279,20 @@ export class ParallClient {
   async getComments(
     orgId: string,
     params:
-      | { target_uri: string; target_prefix?: never; limit?: number; cursor?: string; order?: string }
-      | { target_prefix: string; target_uri?: never; limit?: number; cursor?: string; order?: string },
+      | {
+          target_uri: string;
+          target_prefix?: never;
+          limit?: number;
+          cursor?: string;
+          order?: string;
+        }
+      | {
+          target_prefix: string;
+          target_uri?: never;
+          limit?: number;
+          cursor?: string;
+          order?: string;
+        },
   ): Promise<PaginatedResponse<Comment>> {
     return this.request('GET', ENDPOINTS.COMMENTS(orgId), undefined, params);
   }
@@ -1773,7 +2305,11 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.COMMENTS(orgId), data);
   }
 
-  async updateComment(orgId: string, commentId: string, data: UpdateCommentRequest): Promise<Comment> {
+  async updateComment(
+    orgId: string,
+    commentId: string,
+    data: UpdateCommentRequest,
+  ): Promise<Comment> {
     return this.request('PATCH', ENDPOINTS.COMMENT(orgId, commentId), data);
   }
 
@@ -1783,7 +2319,11 @@ export class ParallClient {
 
   // ---- References ----
 
-  async resolveRefs(orgId: string, refs: string[], options?: { sourceMessageId?: string }): Promise<ResolveRefsResponse> {
+  async resolveRefs(
+    orgId: string,
+    refs: string[],
+    options?: { sourceMessageId?: string },
+  ): Promise<ResolveRefsResponse> {
     const body: Record<string, unknown> = { refs };
     if (options?.sourceMessageId) {
       body.source_message_id = options.sourceMessageId;
@@ -1822,7 +2362,9 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.NOTIFICATION_PREFERENCES);
   }
 
-  async updateNotificationPreferences(prefs: Partial<NotifPrefs>): Promise<NotificationPreferences> {
+  async updateNotificationPreferences(
+    prefs: Partial<NotifPrefs>,
+  ): Promise<NotificationPreferences> {
     return this.request('PATCH', ENDPOINTS.NOTIFICATION_PREFERENCES, { prefs });
   }
 
@@ -1838,7 +2380,20 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.BILLING(orgId));
   }
 
-  async listBillingTransactions(orgId: string, opts?: { cursor?: string; limit?: number; types?: string[]; user_id?: string; unresolved_actor?: boolean; machine_id?: string; unresolved_machine?: boolean; from?: string; to?: string }): Promise<{ items: CreditTransaction[]; next_cursor: string | null }> {
+  async listBillingTransactions(
+    orgId: string,
+    opts?: {
+      cursor?: string;
+      limit?: number;
+      types?: string[];
+      user_id?: string;
+      unresolved_actor?: boolean;
+      machine_id?: string;
+      unresolved_machine?: boolean;
+      from?: string;
+      to?: string;
+    },
+  ): Promise<{ items: CreditTransaction[]; next_cursor: string | null }> {
     const params = new URLSearchParams();
     if (opts?.cursor) params.set('cursor', opts.cursor);
     if (opts?.limit) params.set('limit', String(opts.limit));
@@ -1853,14 +2408,20 @@ export class ParallClient {
     return this.request('GET', `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}${qs ? `?${qs}` : ''}`);
   }
 
-  async listBillingTransactionAgentGroups(orgId: string, opts?: { from?: string; to?: string }): Promise<{ groups: CreditTransactionAgentGroup[] }> {
+  async listBillingTransactionAgentGroups(
+    orgId: string,
+    opts?: { from?: string; to?: string },
+  ): Promise<{ groups: CreditTransactionAgentGroup[] }> {
     const params = new URLSearchParams({ group_by: 'agent' });
     if (opts?.from) params.set('from', opts.from);
     if (opts?.to) params.set('to', opts.to);
     return this.request('GET', `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}?${params}`);
   }
 
-  async listBillingTransactionMachineGroups(orgId: string, opts?: { from?: string; to?: string }): Promise<{ groups: CreditTransactionMachineGroup[] }> {
+  async listBillingTransactionMachineGroups(
+    orgId: string,
+    opts?: { from?: string; to?: string },
+  ): Promise<{ groups: CreditTransactionMachineGroup[] }> {
     const params = new URLSearchParams({ group_by: 'machine' });
     if (opts?.from) params.set('from', opts.from);
     if (opts?.to) params.set('to', opts.to);
@@ -1886,7 +2447,10 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.BILLING_AUTO_RELOAD(orgId));
   }
 
-  async updateAutoReloadSettings(orgId: string, req: UpdateAutoReloadRequest): Promise<AutoReloadSettings> {
+  async updateAutoReloadSettings(
+    orgId: string,
+    req: UpdateAutoReloadRequest,
+  ): Promise<AutoReloadSettings> {
     return this.request('PUT', ENDPOINTS.BILLING_AUTO_RELOAD(orgId), req);
   }
 
@@ -1897,7 +2461,78 @@ export class ParallClient {
   // own thin client (`ts/admin/lib/api.ts`) that hits these directly.
 
   async getComputePricing(): Promise<ComputePricingResponse> {
-    const resp = await this.request<{ data: ComputePricingResponse }>('GET', ENDPOINTS.COMPUTE_PRICING());
+    const resp = await this.request<{ data: ComputePricingResponse }>(
+      'GET',
+      ENDPOINTS.COMPUTE_PRICING(),
+    );
+    return resp.data;
+  }
+
+  // ---- Clips ----
+
+  async listClips(orgId: string): Promise<Clip[]> {
+    const resp = await this.request<{ data: Clip[] }>('GET', ENDPOINTS.CLIPS(orgId));
+    return resp.data;
+  }
+
+  async createClip(orgId: string, req: CreateClipRequest): Promise<Clip> {
+    return this.request('POST', ENDPOINTS.CLIPS(orgId), req);
+  }
+
+  async getClip(orgId: string, clipId: string): Promise<Clip> {
+    return this.request('GET', ENDPOINTS.CLIP(orgId, clipId));
+  }
+
+  async updateClip(orgId: string, clipId: string, req: UpdateClipRequest): Promise<Clip> {
+    return this.request('PATCH', ENDPOINTS.CLIP(orgId, clipId), req);
+  }
+
+  async deleteClip(orgId: string, clipId: string): Promise<void> {
+    await this.request('DELETE', ENDPOINTS.CLIP(orgId, clipId));
+  }
+
+  async listClipAgents(orgId: string, clipId: string): Promise<AgentClip[]> {
+    const resp = await this.request<{ data: AgentClip[] }>(
+      'GET',
+      ENDPOINTS.CLIP_AGENTS(orgId, clipId),
+    );
+    return resp.data;
+  }
+
+  async listAgentClips(orgId: string, agentId: string): Promise<Clip[]> {
+    const resp = await this.request<{ data: Clip[] }>('GET', ENDPOINTS.AGENT_CLIPS(orgId, agentId));
+    return resp.data;
+  }
+
+  async bindAgentClip(
+    orgId: string,
+    agentId: string,
+    req: BindAgentClipRequest,
+  ): Promise<AgentClip> {
+    return this.request('POST', ENDPOINTS.AGENT_CLIPS(orgId, agentId), req);
+  }
+
+  async unbindAgentClip(orgId: string, agentId: string, clipId: string): Promise<void> {
+    await this.request('DELETE', ENDPOINTS.AGENT_CLIP(orgId, agentId, clipId));
+  }
+
+  async invokeClip(orgId: string, req: InvokeClipRequest): Promise<InvokeClipResponse> {
+    const serverTimeout = Math.max(req.timeout_ms ?? 30000, 1000);
+    const timeoutMs = serverTimeout + 5000;
+    return this.request('POST', ENDPOINTS.CLIP_INVOKE(orgId), req, undefined, false, { timeoutMs });
+  }
+
+  async listOnlineClips(orgId: string): Promise<OnlineClipInfo[]> {
+    const resp = await this.request<{ data: OnlineClipInfo[] }>(
+      'GET',
+      ENDPOINTS.CLIP_ONLINE(orgId),
+    );
+    return resp.data;
+  }
+
+  async listRegistryClips(q?: string): Promise<RegistryClipInfo[]> {
+    const url = ENDPOINTS.CLIP_REGISTRY() + (q ? `?q=${encodeURIComponent(q)}` : '');
+    const resp = await this.request<{ data: RegistryClipInfo[] }>('GET', url);
     return resp.data;
   }
 }