@controlflow-ai/daemon 0.1.1 → 0.1.3

package/src/client.ts

@@ -1,6 +1,73 @@
 import { defaultServerToken, defaultServerUrl } from './config.js';
+import { HttpError } from './http.js';
 import { serverAuthHeaders } from './server-auth.js';
-import type { AgentRoomSubscriptionMode, AgentRun, AgentSession, ApiResponse, Chat, Computer, ComputerAgentAssignment, ComputerConnection, DaemonInstance, Message, MessageDelivery, ProvisionedComputer, RoomChannel, RoomParticipant, RunAction } from './types.js';
+import type { AgentActivityEvent, AgentActivityKind, AgentDeletionResult, AgentPermissionProfile, AgentRoomSubscription, AgentRoomSubscriptionMode, AgentRun, AgentSession, AgentWorkbench, ApiResponse, Chat, Computer, ComputerAgentAssignment, ComputerConnection, ComputerDeletionImpact, ComputerDeletionResult, DaemonInstance, DeliveryContext, EnabledSkill, HeldDraftStatus, HeldMessageDraft, Message, MessageDelivery, MessageFreshnessInput, ProvisionedComputer, RemoteFileList, RoomChannel, RoomParticipant, RoomReminder, RoomReminderStatus, RoomSavedMessage, RoomTask, RoomTaskStatus, RunAction } from './types.js';
+export type { DeliveryBacklogSummary, DeliveryConnectionStats as DeliveryConnectionStatus, DeliveryWebSocketSummary, LarkMessagingStatus, MessagingDiagnostic, MessagingHealth, MessagingHealthDomain, MessagingStatus, MessagingStatusSummary } from './messaging-status.js';
+import type { DeliveryBacklogSummary, DeliveryConnectionStats as DeliveryConnectionStatus, MessagingHealth, MessagingStatus } from './messaging-status.js';
+
+export interface LarkRestartResult {
+  bots: string[];
+  restarted: string[];
+  missing: string[];
+  skipped_recent?: string[];
+  skipped_ineffective?: string[];
+}
+
+export interface LarkProbeEventResult {
+  app_id: string;
+  envelope: string;
+  raw_event_id: string;
+  inserted: boolean;
+  duplicate: boolean;
+  parse_ok: 0 | 1;
+  handled: boolean;
+}
+
+export interface LarkRecentEventSummary {
+  id: string;
+  received_at: string;
+  app_id: string;
+  event_type: string;
+  event_id: string;
+  parse_ok: 0 | 1;
+  bytes: number;
+  is_probe: boolean;
+}
+
+export interface LarkRepairParseResult {
+  dry_run: boolean;
+  scanned: number;
+  repaired: number;
+  unchanged: number;
+  conflicts: number;
+  errors: number;
+  rows: Array<{
+    id: string;
+    app_id: string;
+    old_event_id: string;
+    old_event_type: string;
+    new_event_id: string;
+    new_event_type: string;
+    status: 'repaired' | 'would_repair' | 'unchanged' | 'conflict' | 'error';
+    error?: string;
+  }>;
+}
+
+export interface DeliveryProbeResult {
+  message: Message;
+  deliveries: MessageDelivery[];
+  notify: {
+    deliveries: number;
+    target_connections: number;
+    open_sockets: number;
+    websocket_frames: number;
+  };
+  probe: {
+    token: string;
+    agent: string;
+    room: string;
+  };
+}
 
 export interface SendRequest {
   chat?: string;
@@ -15,6 +82,102 @@ export interface SendRequest {
   type?: 'message' | 'system';
   idempotency_key?: string | null;
   mentions?: string[];
+  mention_lint?: 'strict' | 'literal' | 'infer';
+  attachments?: SendMessageAttachmentRequest[];
+  messages?: SendBatchMessageRequest[];
+  freshness?: MessageFreshnessInput;
+}
+
+export interface SendBatchMessageRequest {
+  parent_id?: number;
+  channel_id?: string | null;
+  recipient?: string | null;
+  content: string;
+  type?: 'message' | 'system';
+  idempotency_key?: string | null;
+  mentions?: string[];
+  attachments?: SendMessageAttachmentRequest[];
+}
+
+export interface SendMessageAttachmentRequest {
+  kind: 'image' | 'file';
+  mime_type: string;
+  filename?: string | null;
+  content_base64: string;
+}
+
+export interface SendBatchRequest extends Omit<SendRequest, 'content' | 'recipient' | 'mentions' | 'idempotency_key' | 'type' | 'parent_id' | 'channel_id'> {
+  messages: SendBatchMessageRequest[];
+}
+
+export interface SendMessageResult {
+  message?: Message;
+  messages?: Message[];
+  deliveries?: MessageDelivery[];
+  notify?: unknown;
+  draft?: HeldMessageDraft;
+  drafts?: HeldMessageDraft[];
+  intervening_messages?: Message[];
+  invalid_mentions?: string[];
+  available_mentions?: string[];
+  mention_lint?: {
+    missing_mentions: string[];
+    available_mentions: string[];
+    message: string;
+  };
+}
+
+export interface HeldDraftResolutionResult {
+  draft: HeldMessageDraft;
+  message?: Message;
+  deliveries?: MessageDelivery[];
+  notify?: unknown;
+}
+
+export interface ListHeldDraftsRequest {
+  agent?: string;
+  room_id?: string | null;
+  status?: HeldDraftStatus | 'all';
+  limit?: number;
+}
+
+export interface CreateRoomTasksRequest {
+  title?: string;
+  tasks?: Array<{ title: string }>;
+  created_by?: string | null;
+  source_message_id?: number | null;
+}
+
+export interface CreateRoomReminderRequest {
+  msg_id: number;
+  title: string;
+  created_by?: string | null;
+  fire_at?: string | null;
+  delay_seconds?: number | null;
+  repeat?: string | null;
+}
+
+export interface ListRoomRemindersRequest {
+  status?: RoomReminderStatus | 'all';
+  created_by?: string | null;
+  room_id?: string | null;
+  limit?: number;
+}
+
+export interface CreateRoomSavedMessageRequest {
+  msg_id: number;
+  saved_by: string;
+  note?: string | null;
+}
+
+export interface ListRoomSavedMessagesRequest {
+  saved_by?: string | null;
+  room_id?: string | null;
+  limit?: number;
+}
+
+export interface ClaimRoomTaskRequest {
+  assignee: string;
 }
 
 export interface DaemonAuth {
@@ -65,6 +228,15 @@ export interface ProvisionComputerRequest {
   package_name?: string;
 }
 
+export interface UpdateComputerRequest {
+  name: string;
+}
+
+export interface RegenerateComputerCommandRequest {
+  server_url?: string;
+  package_name?: string;
+}
+
 export interface CreateDeliveryRequest {
   message_id: number;
   agent: string;
@@ -75,6 +247,7 @@ export interface ClaimDeliveryRequest {
   connection_id?: string | null;
   computer_id?: string | null;
   lease_ms?: number;
+  steer_run_id?: string | null;
 }
 
 export interface GetOrCreateSessionRequest {
@@ -106,6 +279,23 @@ export interface FinishRunRequest {
   output?: string;
 }
 
+export interface RecordAgentActivityRequest {
+  kind: AgentActivityKind;
+  title: string;
+  detail?: string | null;
+  metadata?: Record<string, unknown> | null;
+}
+
+export interface CreateHandoffRoomRequest {
+  source_room_id: string;
+  source_message_id?: number;
+  actor: string;
+  purpose: string;
+  name: string;
+  team?: Array<{ agent: string; mode?: AgentRoomSubscriptionMode }>;
+  handoff_content?: string;
+}
+
 export interface CreateArtifactRequest {
   content_base64: string;
   mime_type: string;
@@ -132,13 +322,17 @@ export class LockClient {
     return data.chats;
   }
 
-  async listRooms(): Promise<Chat[]> {
-    const data = await this.get<{ rooms: Chat[] }>('/api/rooms');
+  async listRooms(agentScope?: string): Promise<Chat[]> {
+    const params = new URLSearchParams();
+    if (agentScope) params.set('agent_scope', agentScope);
+    const data = await this.get<{ rooms: Chat[] }>(`/api/rooms${params.size ? `?${params}` : ''}`);
     return data.rooms;
   }
 
-  async listRoomMembers(room: string): Promise<{ room: Chat; participants: RoomParticipant[]; completeness: string }> {
-    const data = await this.get<{ room: Chat; participants: RoomParticipant[]; completeness: string }>(`/api/rooms/${encodeURIComponent(room)}/members`);
+  async listRoomMembers(room: string, agent?: string): Promise<{ room: Chat; participants: RoomParticipant[]; agent_subscriptions?: AgentRoomSubscription[]; enabled_skills?: EnabledSkill[]; completeness: string }> {
+    const params = new URLSearchParams();
+    if (agent) params.set('agent', agent);
+    const data = await this.get<{ room: Chat; participants: RoomParticipant[]; agent_subscriptions?: AgentRoomSubscription[]; enabled_skills?: EnabledSkill[]; completeness: string }>(`/api/rooms/${encodeURIComponent(room)}/members${params.size ? `?${params}` : ''}`);
     return data;
   }
 
@@ -146,32 +340,183 @@ export class LockClient {
     return this.post<{ participant: RoomParticipant; subscription: unknown }>(`/api/rooms/${encodeURIComponent(room)}/agents`, input);
   }
 
+  async createHandoffRoom(input: CreateHandoffRoomRequest): Promise<{ room: Chat; message: Message | null; deliveries: MessageDelivery[]; notify: unknown }> {
+    return this.post<{ room: Chat; message: Message | null; deliveries: MessageDelivery[]; notify: unknown }>('/api/rooms/handoff', input);
+  }
+
+  async leaveAgentRoom(room: string, agent: string): Promise<{ room: Chat; agent: string; participant_removed: boolean; subscriptions_removed: number; active_deliveries_canceled: number }> {
+    return this.delete<{ room: Chat; agent: string; participant_removed: boolean; subscriptions_removed: number; active_deliveries_canceled: number }>(`/api/rooms/${encodeURIComponent(room)}/agents/${encodeURIComponent(agent)}`);
+  }
+
+  async deleteAgent(agent: string, input: { confirm_delete: boolean; leave_rooms: boolean; unbind_lark: boolean } = { confirm_delete: true, leave_rooms: true, unbind_lark: true }): Promise<{ deletion: AgentDeletionResult; lark: { unbound: boolean; app_id: string | null; error: string | null } }> {
+    return this.delete<{ deletion: AgentDeletionResult; lark: { unbound: boolean; app_id: string | null; error: string | null } }>(`/api/agents/${encodeURIComponent(agent)}`, undefined, input);
+  }
+
   async createTopic(room: string, input: { name: string; created_by?: string | null }): Promise<RoomChannel> {
     const data = await this.post<{ channel: RoomChannel }>(`/api/rooms/${encodeURIComponent(room)}/topics`, input);
     return data.channel;
   }
 
+  async listRoomTasks(room: string, status: RoomTaskStatus | 'all' = 'all', limit = 50): Promise<RoomTask[]> {
+    const params = new URLSearchParams({ status, limit: String(limit) });
+    const data = await this.get<{ tasks: RoomTask[] }>(`/api/rooms/${encodeURIComponent(room)}/tasks?${params}`);
+    return data.tasks;
+  }
+
+  async createRoomTasks(room: string, input: CreateRoomTasksRequest): Promise<RoomTask[]> {
+    const data = await this.post<{ tasks: RoomTask[] }>(`/api/rooms/${encodeURIComponent(room)}/tasks`, input);
+    return data.tasks;
+  }
+
+  async claimRoomTask(room: string, taskNumber: number, input: ClaimRoomTaskRequest): Promise<RoomTask> {
+    const data = await this.post<{ task: RoomTask }>(`/api/rooms/${encodeURIComponent(room)}/tasks/${taskNumber}/claim`, input);
+    return data.task;
+  }
+
+  async unclaimRoomTask(room: string, taskNumber: number): Promise<RoomTask> {
+    const data = await this.post<{ task: RoomTask }>(`/api/rooms/${encodeURIComponent(room)}/tasks/${taskNumber}/unclaim`, {});
+    return data.task;
+  }
+
+  async updateRoomTaskStatus(room: string, taskNumber: number, status: RoomTaskStatus): Promise<RoomTask> {
+    const data = await this.patch<{ task: RoomTask }>(`/api/rooms/${encodeURIComponent(room)}/tasks/${taskNumber}`, { status });
+    return data.task;
+  }
+
+  async restartRoomAgent(room: string, agent: string): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>(`/api/rooms/${encodeURIComponent(room)}/agents/${encodeURIComponent(agent)}/restart`, {});
+    return data.run;
+  }
+
+  async scheduleReminder(input: CreateRoomReminderRequest): Promise<RoomReminder> {
+    const data = await this.post<{ reminder: RoomReminder }>('/api/reminders', input);
+    return data.reminder;
+  }
+
+  async listReminders(input: ListRoomRemindersRequest = {}): Promise<RoomReminder[]> {
+    const params = new URLSearchParams();
+    params.set('status', input.status ?? 'scheduled');
+    if (input.created_by) params.set('created_by', input.created_by);
+    if (input.room_id) params.set('room_id', input.room_id);
+    params.set('limit', String(input.limit ?? 50));
+    const data = await this.get<{ reminders: RoomReminder[] }>(`/api/reminders?${params}`);
+    return data.reminders;
+  }
+
+  async cancelReminder(id: string): Promise<RoomReminder> {
+    const data = await this.post<{ reminder: RoomReminder }>(`/api/reminders/${encodeURIComponent(id)}/cancel`, {});
+    return data.reminder;
+  }
+
+  async saveMessage(input: CreateRoomSavedMessageRequest): Promise<RoomSavedMessage> {
+    const data = await this.post<{ saved_message: RoomSavedMessage }>('/api/saved-messages', input);
+    return data.saved_message;
+  }
+
+  async listSavedMessages(input: ListRoomSavedMessagesRequest = {}): Promise<RoomSavedMessage[]> {
+    const params = new URLSearchParams();
+    if (input.saved_by) params.set('saved_by', input.saved_by);
+    if (input.room_id) params.set('room_id', input.room_id);
+    params.set('limit', String(input.limit ?? 50));
+    const data = await this.get<{ saved_messages: RoomSavedMessage[] }>(`/api/saved-messages?${params}`);
+    return data.saved_messages;
+  }
+
+  async removeSavedMessage(id: string): Promise<RoomSavedMessage> {
+    const data = await this.post<{ saved_message: RoomSavedMessage }>(`/api/saved-messages/${encodeURIComponent(id)}/delete`, {});
+    return data.saved_message;
+  }
+
   async getMessages(params: URLSearchParams): Promise<Message[]> {
     const data = await this.get<{ messages: Message[] }>(`/api/messages?${params}`);
     return data.messages;
   }
 
+  async getDeliveryContext(input: { agent: string; chatId: string; messageId: number; limit?: number }): Promise<DeliveryContext> {
+    const params = new URLSearchParams({
+      agent: input.agent,
+      chat_id: input.chatId,
+      message_id: String(input.messageId),
+      limit: String(input.limit ?? 50),
+    });
+    const data = await this.get<{ context: DeliveryContext }>(`/api/messages/context?${params}`);
+    return data.context;
+  }
+
   async getInbox(agent: string, after = 0, limit = 50): Promise<Message[]> {
     const params = new URLSearchParams({ agent, after: String(after), limit: String(limit) });
     const data = await this.get<{ messages: Message[] }>(`/api/inbox?${params}`);
     return data.messages;
   }
 
-  async getMessage(id: number): Promise<Message> {
-    const data = await this.get<{ message: Message }>(`/api/messages/${id}`);
+  async getMessage(id: number, agentScope?: string): Promise<Message> {
+    const suffix = agentScope ? `?agent_scope=${encodeURIComponent(agentScope)}` : '';
+    const data = await this.get<{ message: Message }>(`/api/messages/${id}${suffix}`);
     return data.message;
   }
 
+  async getMessageAttachmentContent(id: string, agentScope?: string): Promise<{ content: Uint8Array; mimeType: string; filename: string }> {
+    const suffix = agentScope ? `?agent_scope=${encodeURIComponent(agentScope)}` : '';
+    const response = await fetch(`${this.baseUrl}/api/message-attachments/${encodeURIComponent(id)}/content${suffix}`);
+    if (!response.ok) {
+      let message = `request failed: ${response.status}`;
+      let code = 'REQUEST_FAILED';
+      try {
+        const payload = await response.json() as ApiResponse<unknown>;
+        if ('code' in payload && typeof payload.code === 'string') code = payload.code;
+        message = payload.message ?? message;
+      } catch {
+        // Binary endpoint errors should be JSON, but keep a fallback.
+      }
+      throw new HttpError(response.status, code, message);
+    }
+    const filename = response.headers.get('content-disposition')?.match(/filename="([^"]+)"/)?.[1] ?? id;
+    return {
+      content: new Uint8Array(await response.arrayBuffer()),
+      mimeType: response.headers.get('content-type') ?? 'application/octet-stream',
+      filename,
+    };
+  }
+
   async sendMessage(input: SendRequest): Promise<Message> {
-    const data = await this.post<{ message: Message }>('/api/messages', input);
+    const data = await this.sendMessageResult(input);
+    if (!data.message) throw new HttpError(202, 'MESSAGE_HELD', 'message was held as a draft');
     return data.message;
   }
 
+  async sendMessageResult(input: SendRequest): Promise<SendMessageResult> {
+    return this.post<SendMessageResult>('/api/messages', input);
+  }
+
+  async getAgentWorkbench(agent: string): Promise<AgentWorkbench> {
+    const data = await this.get<{ workbench: AgentWorkbench }>(`/api/agents/${encodeURIComponent(agent)}/workbench`);
+    return data.workbench;
+  }
+
+  async listHeldDrafts(input: ListHeldDraftsRequest = {}): Promise<HeldMessageDraft[]> {
+    const agent = input.agent?.trim();
+    if (!agent) throw new Error('agent is required');
+    const workbench = await this.getAgentWorkbench(agent);
+    const status = input.status ?? 'held';
+    const limit = input.limit ?? 50;
+    return workbench.held_drafts
+      .filter((draft) => status === 'all' || draft.status === status)
+      .filter((draft) => !input.room_id || draft.chat_id === input.room_id)
+      .slice(0, limit);
+  }
+
+  async abandonHeldDraft(id: string): Promise<HeldDraftResolutionResult> {
+    return this.post<HeldDraftResolutionResult>(`/api/held-drafts/${encodeURIComponent(id)}/abandon`, {});
+  }
+
+  async sendHeldDraftAnyway(id: string): Promise<HeldDraftResolutionResult> {
+    return this.post<HeldDraftResolutionResult>(`/api/held-drafts/${encodeURIComponent(id)}/send-anyway`, {});
+  }
+
+  async reviseHeldDraft(id: string, content: string): Promise<HeldDraftResolutionResult> {
+    return this.post<HeldDraftResolutionResult>(`/api/held-drafts/${encodeURIComponent(id)}/revise`, { content });
+  }
+
   async provisionComputer(input: ProvisionComputerRequest = {}): Promise<ProvisionedComputer> {
     const data = await this.post<ProvisionedComputer>('/api/computers/provision', input);
     return data;
@@ -182,8 +527,39 @@ export class LockClient {
     return data.computers;
   }
 
-  async connectComputer(input: ConnectComputerRequest): Promise<{ computer: Computer; connection: ComputerConnection; token: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }> {
-    const data = await this.post<{ computer: Computer; connection: ComputerConnection; token: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }>('/api/computers/connect', input);
+  async updateComputer(computerId: string, input: UpdateComputerRequest): Promise<Computer> {
+    const data = await this.patch<{ computer: Computer }>(`/api/computers/${encodeURIComponent(computerId)}`, input);
+    return data.computer;
+  }
+
+  async regenerateComputerCommand(computerId: string, input: RegenerateComputerCommandRequest = {}): Promise<ProvisionedComputer> {
+    return this.post<ProvisionedComputer>(`/api/computers/${encodeURIComponent(computerId)}/reconnect-command`, input);
+  }
+
+  async getComputerDeleteImpact(computerId: string): Promise<ComputerDeletionImpact> {
+    const data = await this.get<{ impact: ComputerDeletionImpact }>(`/api/computers/${encodeURIComponent(computerId)}/delete-impact`);
+    return data.impact;
+  }
+
+  async deleteComputer(computerId: string, input: { remove_projects?: boolean; remove_agents?: boolean } = {}): Promise<ComputerDeletionResult & { deleted: boolean }> {
+    return this.delete<ComputerDeletionResult & { deleted: boolean }>(`/api/computers/${encodeURIComponent(computerId)}`, undefined, input);
+  }
+
+  async fetchPermissionProfile(agent: string): Promise<AgentPermissionProfile> {
+    const data = await this.get<{ profile: AgentPermissionProfile }>(`/api/agents/${encodeURIComponent(agent)}/permissions`);
+    return data.profile;
+  }
+
+  async connectComputer(input: ConnectComputerRequest): Promise<{ computer: Computer; connection: ComputerConnection; token: string; local_control_token?: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }> {
+    const data = await this.post<{ computer: Computer; connection: ComputerConnection; token: string; local_control_token?: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }>('/api/computers/connect', input);
+    return data;
+  }
+
+  async listComputerFiles(computerId: string, input: { path?: string; show_hidden?: boolean } = {}): Promise<RemoteFileList> {
+    const params = new URLSearchParams();
+    if (input.path) params.set('path', input.path);
+    if (input.show_hidden) params.set('show_hidden', 'true');
+    const data = await this.get<RemoteFileList>(`/api/computers/${encodeURIComponent(computerId)}/files${params.size ? `?${params}` : ''}`);
     return data;
   }
 
@@ -197,12 +573,80 @@ export class LockClient {
     return data.daemon;
   }
 
-  async listDeliveries(agent: string, status = 'pending', limit = 50): Promise<MessageDelivery[]> {
+  async listDeliveries(agent: string, status = 'pending', limit = 50, options: { distinctChat?: boolean; excludeRunningComputerId?: string | null; connectionId?: string | null } = {}): Promise<MessageDelivery[]> {
     const params = new URLSearchParams({ agent, status, limit: String(limit) });
+    if (options.distinctChat) params.set('distinct_chat', 'true');
+    if (options.excludeRunningComputerId) params.set('exclude_running_computer_id', options.excludeRunningComputerId);
+    if (options.connectionId) params.set('connection_id', options.connectionId);
     const data = await this.get<{ deliveries: MessageDelivery[] }>(`/api/deliveries?${params}`);
     return data.deliveries;
   }
 
+  async getDelivery(id: string): Promise<MessageDelivery> {
+    const data = await this.get<{ delivery: MessageDelivery }>(`/api/deliveries/${encodeURIComponent(id)}`);
+    return data.delivery;
+  }
+
+  async listPendingDeliveryAgents(): Promise<Array<{ agent: string; pending: number }>> {
+    const data = await this.get<{ agents: Array<{ agent: string; pending: number }> }>('/api/deliveries/pending-agents');
+    return data.agents;
+  }
+
+  async listDeliveryBacklog(): Promise<DeliveryBacklogSummary[]> {
+    const data = await this.get<{ backlog: DeliveryBacklogSummary[] }>('/api/deliveries/backlog');
+    return data.backlog;
+  }
+
+  async getDeliveryWebSocketStatus(): Promise<DeliveryConnectionStatus> {
+    const data = await this.get<{ websocket: DeliveryConnectionStatus }>('/api/daemon/ws/status');
+    return data.websocket;
+  }
+
+  async getMessagingStatus(): Promise<MessagingStatus> {
+    return this.get<MessagingStatus>('/api/messaging/status');
+  }
+
+  async getMessagingHealth(): Promise<MessagingHealth> {
+    return this.get<MessagingHealth>('/api/messaging/health');
+  }
+
+  async probeDelivery(input: { agent?: string; room?: string; sender?: string; content?: string; idempotencyKey?: string | null } = {}, token = defaultServerToken()): Promise<DeliveryProbeResult> {
+    return this.post<DeliveryProbeResult>('/api/messaging/probe-delivery', {
+      agent: input.agent,
+      room: input.room,
+      sender: input.sender,
+      content: input.content,
+      idempotency_key: input.idempotencyKey,
+    }, serverAuthHeaders(token));
+  }
+
+  async restartLarkWebSocket(options: { appId?: string; appIds?: string[] } = {}): Promise<LarkRestartResult> {
+    const body = options.appId ? { app_id: options.appId } : options.appIds ? { app_ids: options.appIds } : {};
+    return this.post<LarkRestartResult>('/api/lark/restart', body);
+  }
+
+  async probeLarkEvent(input: { appId: string; envelope?: string; data: unknown }, token = defaultServerToken()): Promise<LarkProbeEventResult> {
+    return this.post<LarkProbeEventResult>('/api/lark/probe-event', {
+      app_id: input.appId,
+      envelope: input.envelope,
+      data: input.data,
+    }, serverAuthHeaders(token));
+  }
+
+  async listRecentLarkEvents(limit = 20): Promise<LarkRecentEventSummary[]> {
+    const params = new URLSearchParams({ limit: String(limit) });
+    const data = await this.get<{ events: LarkRecentEventSummary[] }>(`/api/lark/events/recent?${params}`);
+    return data.events;
+  }
+
+  async repairLarkEventParseFailures(input: { appId?: string; limit?: number; dryRun?: boolean } = {}, token = defaultServerToken()): Promise<LarkRepairParseResult> {
+    return this.post<LarkRepairParseResult>('/api/lark/events/repair-parse', {
+      app_id: input.appId,
+      limit: input.limit,
+      dry_run: input.dryRun,
+    }, serverAuthHeaders(token));
+  }
+
   async createDelivery(input: CreateDeliveryRequest): Promise<MessageDelivery> {
     const data = await this.post<{ delivery: MessageDelivery }>('/api/deliveries', input);
     return data.delivery;
@@ -218,6 +662,11 @@ export class LockClient {
     return data.delivery;
   }
 
+  async markDeliveryProcessingCompleted(id: string, input: FinishDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>(`/api/deliveries/${id}/processing-completed`, input);
+    return data.delivery;
+  }
+
   async getOrCreateSession(input: GetOrCreateSessionRequest): Promise<AgentSession> {
     const data = await this.post<{ session: AgentSession }>('/api/sessions', input);
     return data.session;
@@ -263,6 +712,11 @@ export class LockClient {
     return data.run;
   }
 
+  async recordRunActivity(runId: string, input: RecordAgentActivityRequest): Promise<AgentActivityEvent> {
+    const data = await this.post<{ event: AgentActivityEvent }>(`/api/runs/${runId}/activity`, input);
+    return data.event;
+  }
+
   async finishRun(runId: string, input: FinishRunRequest): Promise<AgentRun> {
     const data = await this.post<{ run: AgentRun }>(`/api/runs/${runId}/finish`, input);
     return data.run;
@@ -290,6 +744,22 @@ export class LockClient {
     });
   }
 
+  private async patch<T>(path: string, body: unknown, headers?: HeadersInit): Promise<T> {
+    return this.request<T>(path, {
+      method: 'PATCH',
+      headers: { 'content-type': 'application/json', ...this.daemonAuthHeaders(), ...headers },
+      body: JSON.stringify(body),
+    });
+  }
+
+  private async delete<T>(path: string, headers?: HeadersInit, body?: unknown): Promise<T> {
+    return this.request<T>(path, {
+      method: 'DELETE',
+      headers: { ...(body === undefined ? {} : { 'content-type': 'application/json' }), ...this.daemonAuthHeaders(), ...headers },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+  }
+
   private daemonAuthHeaders(): HeadersInit {
     if (!this.daemonAuth) return {};
     return {
@@ -303,7 +773,7 @@ export class LockClient {
     const response = await fetch(`${this.baseUrl}${path}`, init);
     const payload = await response.json() as ApiResponse<T>;
     if (!response.ok || !payload.ok) {
-      throw new Error(payload.message ?? `request failed: ${response.status}`);
+      throw new HttpError(response.status, 'code' in payload && typeof payload.code === 'string' ? payload.code : 'REQUEST_FAILED', payload.message ?? `request failed: ${response.status}`);
     }
     return payload.data as T;
   }

package/src/coco.ts

@@ -1,52 +1,21 @@
 import { buildPalPrompt, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+import { buildCocoPermissionArgs, buildRuntimeLaunchContext, effectivePermissionProfile } from './agent-permissions.js';
 export { runAgentRuntime } from './agent-runtime.js';
 
-function extractSessionId(stdout: string): string | null {
-  for (const line of stdout.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('{')) continue;
-    try {
-      const event = JSON.parse(trimmed) as { session_id?: unknown };
-      if (typeof event.session_id === 'string' && event.session_id.trim()) {
-        return event.session_id;
-      }
-    } catch {
-      // Non-JSON stdout is kept in output; it just is not a JSONL event.
-    }
-  }
-  return null;
-}
-
-export function makeCocoRuntime(_agentUuid: string): AgentRuntime {
+export function makeCocoRuntime(_agentUuid: string, model?: string | null): AgentRuntime {
+  // Coco ACP exits before initialize when passed --model. Per-invocation model
+  // selection works through config overrides.
+  const modelArgs = model?.trim() ? ['-c', `model.name=${model.trim()}`] : [];
   return {
     name: 'coco',
-    capabilities: { protocol: 'acp', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: true },
-    command: 'coco',
-    buildPrompt: buildPalPrompt,
-    buildCwd: runtimeCwd,
-    buildArgs(input: AgentRuntimeRunInput): string[] {
-      return ['acp', 'serve', '-y', ...input.extraArgs];
-    },
-  };
-}
-
-export function makeCocoStreamJsonRuntime(_agentUuid: string): AgentRuntime {
-  return {
-    name: 'coco-stream-json',
-    capabilities: { protocol: 'json-stream', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: false },
+    capabilities: { protocol: 'acp', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: true, supportsSteer: false },
     command: 'coco',
     buildPrompt: buildPalPrompt,
     buildCwd: runtimeCwd,
     buildArgs(input: AgentRuntimeRunInput): string[] {
-      const prompt = buildPalPrompt(input);
-      const resumeArgs = input.runtimeSessionId ? ['--resume', input.runtimeSessionId] : [];
-      return ['-y', '-p', '--output-format', 'stream-json', ...resumeArgs, ...input.extraArgs, prompt];
-    },
-    parseOutput({ stdout, stderr, input }) {
-      return {
-        output: [stdout.trim(), stderr.trim()].filter(Boolean).join('\n'),
-        runtimeSessionId: extractSessionId(stdout) ?? input.runtimeSessionId ?? null,
-      };
+      const context = input.launchContext ?? buildRuntimeLaunchContext(input);
+      const permissionArgs = buildCocoPermissionArgs(effectivePermissionProfile(input), context);
+      return ['acp', 'serve', ...permissionArgs, ...modelArgs, ...input.extraArgs];
     },
   };
 }