clawdex-mobile 2.0.0 → 3.0.0

package/apps/mobile/src/api/__tests__/ws.test.ts

@@ -260,6 +260,33 @@ describe('HostBridgeWsClient', () => {
     await expect(waitPromise).resolves.toBeUndefined();
   });
 
+  it('waitForTurnCompletion prefers the direct child thread id over parent_thread_id', async () => {
+    const client = new HostBridgeWsClient('http://localhost:8787');
+    client.connect();
+
+    const waitPromise = client.waitForTurnCompletion('thr_child', 'turn_child', 100);
+    latestMockSocket().simulateMessage(
+      JSON.stringify({
+        method: 'codex/event/task_complete',
+        params: {
+          msg: {
+            type: 'task_complete',
+            thread_id: 'thr_child',
+            source: {
+              subagent: {
+                thread_spawn: {
+                  parent_thread_id: 'thr_parent',
+                },
+              },
+            },
+          },
+        },
+      })
+    );
+
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
   it('deduplicates notifications by eventId', () => {
     const client = new HostBridgeWsClient('http://localhost:8787');
     const listener = jest.fn();

package/apps/mobile/src/api/account.ts

@@ -0,0 +1,47 @@
+import { readString, toRecord } from './chatMapping';
+import type { AccountSnapshot, PlanType } from './types';
+
+const PLAN_TYPES = new Set<PlanType>([
+  'free',
+  'go',
+  'plus',
+  'pro',
+  'team',
+  'business',
+  'enterprise',
+  'edu',
+  'unknown',
+]);
+
+export function readAccountSnapshot(value: unknown): AccountSnapshot {
+  const record = toRecord(value);
+  const accountRecord = toRecord(record?.account);
+  const accountType = readAccountType(accountRecord?.type);
+
+  return {
+    type: accountType,
+    email: accountType === 'chatgpt' ? readString(accountRecord?.email) : null,
+    planType:
+      accountType === 'chatgpt'
+        ? readPlanType(accountRecord?.planType ?? accountRecord?.plan_type)
+        : null,
+    requiresOpenaiAuth:
+      record?.requiresOpenaiAuth === true || record?.requires_openai_auth === true,
+  };
+}
+
+function readAccountType(value: unknown): AccountSnapshot['type'] {
+  if (value === 'apiKey' || value === 'chatgpt') {
+    return value;
+  }
+
+  return null;
+}
+
+function readPlanType(value: unknown): PlanType | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  return PLAN_TYPES.has(value as PlanType) ? (value as PlanType) : null;
+}

package/apps/mobile/src/api/chatMapping.ts

@@ -1,8 +1,11 @@
 import type {
   Chat,
   ChatMessage,
+  ChatMessageSubAgentMeta,
+  ChatPlanSnapshot,
   ChatStatus,
   ChatSummary,
+  TurnPlanStep,
 } from './types';
 
 export type RawThreadStatus =
@@ -43,6 +46,8 @@ export interface RawThread {
   title?: string;
   preview?: string;
   modelProvider?: string;
+  agentNickname?: string;
+  agentRole?: string;
   createdAt?: number;
   updatedAt?: number;
   status?: RawThreadStatus;
@@ -51,6 +56,12 @@ export interface RawThread {
   turns?: RawTurn[];
 }
 
+interface ThreadSourceMetadata {
+  kind?: string;
+  parentThreadId?: string;
+  subAgentDepth?: number;
+}
+
 export function toRecord(value: unknown): Record<string, unknown> | null {
   return typeof value === 'object' && value !== null
     ? (value as Record<string, unknown>)
@@ -61,6 +72,16 @@ export function readString(value: unknown): string | null {
   return typeof value === 'string' ? value : null;
 }
 
+function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((entry) => readString(entry)?.trim() ?? '')
+    .filter((entry): entry is string => entry.length > 0);
+}
+
 function readNumber(value: unknown): number | null {
   return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
@@ -197,6 +218,14 @@ export function toRawThread(value: unknown): RawThread {
     title: threadName,
     preview: readString(record.preview) ?? undefined,
     modelProvider: readString(record.modelProvider) ?? undefined,
+    agentNickname:
+      readString(record.agentNickname) ??
+      readString(record.agent_nickname) ??
+      undefined,
+    agentRole:
+      readString(record.agentRole) ??
+      readString(record.agent_role) ??
+      undefined,
     createdAt: readNumber(record.createdAt) ?? undefined,
     updatedAt: readNumber(record.updatedAt) ?? undefined,
     status: (record.status as RawThreadStatus) ?? undefined,
@@ -236,6 +265,7 @@ export function mapChatSummary(raw: RawThread): ChatSummary | null {
   const createdAt = unixSecondsToIso(raw.createdAt);
   const updatedAt = unixSecondsToIso(raw.updatedAt);
   const turns = Array.isArray(raw.turns) ? raw.turns : [];
+  const sourceMetadata = readThreadSourceMetadata(raw.source);
 
   const lastError = extractLastError(turns);
   const displayTitle = raw.name ?? raw.preview;
@@ -250,59 +280,125 @@ export function mapChatSummary(raw: RawThread): ChatSummary | null {
     lastMessagePreview: toPreview(raw.preview || ''),
     cwd: readString(raw.cwd) ?? undefined,
     modelProvider: readString(raw.modelProvider) ?? undefined,
-    sourceKind: mapSourceKind(raw.source),
+    agentNickname: readString(raw.agentNickname) ?? undefined,
+    agentRole: readString(raw.agentRole) ?? undefined,
+    sourceKind: sourceMetadata.kind,
+    parentThreadId: sourceMetadata.parentThreadId,
+    subAgentDepth: sourceMetadata.subAgentDepth,
     lastError: lastError ?? undefined,
   };
 }
 
-function mapSourceKind(source: unknown): string | undefined {
+function readThreadSourceMetadata(source: unknown): ThreadSourceMetadata {
   if (typeof source === 'string') {
-    return source;
+    return {
+      kind: source,
+    };
   }
 
   const sourceRecord = toRecord(source);
   if (!sourceRecord) {
-    return undefined;
+    return {};
   }
 
   // Legacy shape used by older adapters.
   const legacyKind = readString(sourceRecord.kind);
   if (legacyKind) {
-    return legacyKind;
+    return {
+      kind: legacyKind,
+      parentThreadId:
+        readString(sourceRecord.parentThreadId) ??
+        readString(sourceRecord.parent_thread_id) ??
+        undefined,
+      subAgentDepth:
+        readNumber(sourceRecord.depth) ??
+        readNumber(sourceRecord.agentDepth) ??
+        readNumber(sourceRecord.agent_depth) ??
+        undefined,
+    };
   }
 
   // Current app-server shape: { subAgent: ... } tagged union.
-  if ('subAgent' in sourceRecord) {
-    const subAgent = sourceRecord.subAgent;
+  const subAgentValue =
+    sourceRecord.subAgent ??
+    sourceRecord.subagent;
+
+  if (subAgentValue !== undefined) {
+    const subAgent = subAgentValue;
     if (typeof subAgent === 'string') {
-      if (subAgent === 'review') return 'subAgentReview';
-      if (subAgent === 'compact') return 'subAgentCompact';
-      if (subAgent === 'memory_consolidation') return 'subAgentOther';
-      return 'subAgent';
+      const kind =
+        subAgent === 'review'
+          ? 'subAgentReview'
+          : subAgent === 'compact'
+            ? 'subAgentCompact'
+            : subAgent === 'memory_consolidation'
+              ? 'subAgentOther'
+              : 'subAgent';
+      return {
+        kind,
+      };
     }
 
     const subAgentRecord = toRecord(subAgent);
     if (!subAgentRecord) {
-      return 'subAgent';
+      return {
+        kind: 'subAgent',
+      };
     }
 
-    if (toRecord(subAgentRecord.thread_spawn)) {
-      return 'subAgentThreadSpawn';
+    const threadSpawn = toRecord(subAgentRecord.thread_spawn);
+    if (threadSpawn) {
+      return {
+        kind: 'subAgentThreadSpawn',
+        parentThreadId:
+          readString(threadSpawn.parentThreadId) ??
+          readString(threadSpawn.parent_thread_id) ??
+          undefined,
+        subAgentDepth:
+          readNumber(threadSpawn.depth) ??
+          readNumber(threadSpawn.agentDepth) ??
+          readNumber(threadSpawn.agent_depth) ??
+          undefined,
+      };
     }
 
     if (readString(subAgentRecord.other)) {
-      return 'subAgentOther';
+      return {
+        kind: 'subAgentOther',
+      };
     }
 
-    return 'subAgent';
+    return {
+      kind: 'subAgent',
+      parentThreadId:
+        readString(subAgentRecord.parentThreadId) ??
+        readString(subAgentRecord.parent_thread_id) ??
+        undefined,
+      subAgentDepth:
+        readNumber(subAgentRecord.depth) ??
+        readNumber(subAgentRecord.agentDepth) ??
+        readNumber(subAgentRecord.agent_depth) ??
+        undefined,
+    };
   }
 
   const typeKind = readString(sourceRecord.type);
   if (typeKind && typeKind.startsWith('subAgent')) {
-    return typeKind;
+    return {
+      kind: typeKind,
+      parentThreadId:
+        readString(sourceRecord.parentThreadId) ??
+        readString(sourceRecord.parent_thread_id) ??
+        undefined,
+      subAgentDepth:
+        readNumber(sourceRecord.depth) ??
+        readNumber(sourceRecord.agentDepth) ??
+        readNumber(sourceRecord.agent_depth) ??
+        undefined,
+    };
   }
 
-  return undefined;
+  return {};
 }
 
 export function mapChat(raw: RawThread): Chat {
@@ -312,6 +408,7 @@ export function mapChat(raw: RawThread): Chat {
   }
 
   const messages = mapMessages(raw, summary.createdAt);
+  const plans = extractChatPlans(raw);
 
   const lastPreview =
     messages.length > 0
@@ -322,6 +419,67 @@ export function mapChat(raw: RawThread): Chat {
     ...summary,
     lastMessagePreview: lastPreview,
     messages,
+    latestPlan: plans.latestPlan,
+    latestTurnPlan: plans.latestTurnPlan,
+    latestTurnStatus: plans.latestTurnStatus,
+  };
+}
+
+function extractChatPlans(raw: RawThread): {
+  latestPlan: ChatPlanSnapshot | null;
+  latestTurnPlan: ChatPlanSnapshot | null;
+  latestTurnStatus: string | null;
+} {
+  const threadId = raw.id?.trim();
+  const turns = Array.isArray(raw.turns) ? raw.turns : [];
+  const latestTurn = turns.length > 0 ? turns[turns.length - 1] : null;
+  const latestTurnStatus = readString(latestTurn?.status);
+
+  if (!threadId || turns.length === 0) {
+    return {
+      latestPlan: null,
+      latestTurnPlan: null,
+      latestTurnStatus,
+    };
+  }
+
+  let latestPlan: ChatPlanSnapshot | null = null;
+  let latestTurnPlan: ChatPlanSnapshot | null = null;
+
+  for (const turn of turns) {
+    const turnId = readString(turn.id);
+    const items = Array.isArray(turn.items) ? turn.items : [];
+    let latestPlanInTurn: ChatPlanSnapshot | null = null;
+
+    for (const item of items) {
+      const itemRecord = toRecord(item);
+      if (!itemRecord) {
+        continue;
+      }
+
+      const itemType = normalizeType(readString(itemRecord.type) ?? '');
+      if (itemType !== 'plan') {
+        continue;
+      }
+
+      const plan = toPlanSnapshot(itemRecord, threadId, turnId);
+      if (!plan) {
+        continue;
+      }
+
+      latestPlan = plan;
+      latestPlanInTurn = plan;
+    }
+
+    if (turn === latestTurn) {
+      latestTurnPlan = latestPlanInTurn;
+    }
+  }
+
+  return {
+    latestPlan,
+    latestTurnPlan,
+    latestTurnStatus,
   };
 }
 
@@ -406,10 +564,13 @@ function mapMessages(raw: RawThread, fallbackCreatedAt: string): ChatMessage[] {
 
       const toolLikeMessage = toToolLikeMessage(itemRecord);
       if (toolLikeMessage) {
+        const systemKind = itemType === 'collabToolCall' ? 'subAgent' : 'tool';
         messages.push({
           id: readString(itemRecord.id) ?? generateLocalId(),
           role: 'system',
           content: toolLikeMessage,
+          systemKind,
+          subAgentMeta: systemKind === 'subAgent' ? toSubAgentMeta(itemRecord) : undefined,
           createdAt: new Date(baseTs + messages.length * 1000).toISOString(),
         });
       }
@@ -423,6 +584,147 @@ function generateLocalId(): string {
   return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 }
 
+function toPlanSnapshot(
+  item: Record<string, unknown>,
+  threadId: string,
+  fallbackTurnId?: string | null
+): ChatPlanSnapshot | null {
+  const turnId =
+    readString(item.turnId) ??
+    readString(item.turn_id) ??
+    fallbackTurnId ??
+    readString(item.id);
+  if (!turnId) {
+    return null;
+  }
+
+  const rawSteps = Array.isArray(item.plan)
+    ? item.plan
+    : Array.isArray(item.steps)
+      ? item.steps
+      : [];
+  const steps: TurnPlanStep[] = rawSteps
+    .map((entry) => {
+      const entryRecord = toRecord(entry);
+      if (!entryRecord) {
+        return null;
+      }
+
+      const step = readString(entryRecord.step);
+      const status = normalizePlanStepStatus(readString(entryRecord.status));
+      if (!step || !status) {
+        return null;
+      }
+
+      return {
+        step,
+        status,
+      } satisfies TurnPlanStep;
+    })
+    .filter((entry): entry is TurnPlanStep => entry !== null);
+  const explanation = readString(item.explanation);
+
+  if (steps.length === 0 && !explanation?.trim()) {
+    return parsePlanTextSnapshot(readString(item.text), threadId, turnId);
+  }
+
+  return {
+    threadId,
+    turnId,
+    explanation,
+    steps,
+  };
+}
+
+function parsePlanTextSnapshot(
+  text: string | null | undefined,
+  threadId: string,
+  turnId: string
+): ChatPlanSnapshot | null {
+  const trimmed = text?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const lines = trimmed
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    return null;
+  }
+
+  const hasSummaryHeader = lines.some((line) => /^summary$/i.test(line));
+  const steps: TurnPlanStep[] = [];
+  for (const line of lines) {
+    const match = line.match(/^\d+[.)]\s+(.+)$/);
+    if (!match?.[1]) {
+      continue;
+    }
+
+    steps.push({
+      step: match[1].trim(),
+      status: 'pending',
+    });
+  }
+
+  if (!hasSummaryHeader && steps.length === 0) {
+    return null;
+  }
+
+  let startIndex = 0;
+  if (lines.length > 1 && /plan$/i.test(lines[0])) {
+    startIndex = 1;
+  }
+  if (lines[startIndex] && /^summary$/i.test(lines[startIndex])) {
+    startIndex += 1;
+  }
+
+  const explanationLines: string[] = [];
+  for (let index = startIndex; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^\d+[.)]\s+/.test(line)) {
+      break;
+    }
+    if (/^(summary|implementation plan|proposed plan)$/i.test(line)) {
+      continue;
+    }
+    explanationLines.push(line);
+  }
+
+  const explanation =
+    explanationLines.length > 0 ? explanationLines.join(' ').trim() : null;
+
+  if (steps.length === 0 && !explanation) {
+    return null;
+  }
+
+  return {
+    threadId,
+    turnId,
+    explanation,
+    steps,
+  };
+}
+
+function normalizePlanStepStatus(value: string | null | undefined): TurnPlanStep['status'] | null {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase().replace(/[^a-z]/g, '');
+  if (normalized === 'pending') {
+    return 'pending';
+  }
+  if (normalized === 'inprogress') {
+    return 'inProgress';
+  }
+  if (normalized === 'completed' || normalized === 'complete') {
+    return 'completed';
+  }
+  return null;
+}
+
 function toToolLikeMessage(item: Record<string, unknown>): string | null {
   const rawType = readString(item.type);
   if (!rawType) {
@@ -473,6 +775,72 @@ function toToolLikeMessage(item: Record<string, unknown>): string | null {
     return withNestedDetail(title, detail);
   }
 
+  if (type === 'collabtoolcall') {
+    const tool = normalizeType(readString(item.tool) ?? '');
+    const status = normalizeType(readString(item.status) ?? '');
+    const prompt = normalizeInline(readString(item.prompt), 220);
+    const receiverThreadIds = readReceiverThreadIds(item);
+    const primaryReceiverThreadId = normalizeInline(receiverThreadIds[0], 120);
+    const newThreadId = normalizeInline(
+      readString(item.newThreadId) ??
+        readString(item.new_thread_id) ??
+        primaryReceiverThreadId,
+      120
+    );
+    const senderThreadId = normalizeInline(
+      readString(item.senderThreadId) ?? readString(item.sender_thread_id),
+      120
+    );
+    const agentStatus = normalizeInline(
+      readString(item.agentStatus) ?? readString(item.agent_status),
+      120
+    );
+
+    const title = (() => {
+      if (tool === 'spawnagent') {
+        if (status === 'failed' || status === 'error') {
+          return '• Sub-agent spawn failed';
+        }
+        if (status === 'completed' || status === 'complete' || status === 'succeeded') {
+          return '• Spawned sub-agent';
+        }
+        return '• Spawning sub-agent';
+      }
+
+      if (tool === 'sendinput') {
+        return status === 'failed' || status === 'error'
+          ? '• Sub-agent update failed'
+          : '• Sent follow-up to sub-agent';
+      }
+
+      if (tool === 'wait') {
+        return status === 'failed' || status === 'error'
+          ? '• Waiting on sub-agent failed'
+          : '• Waiting on sub-agent';
+      }
+
+      if (tool === 'closeagent') {
+        return status === 'failed' || status === 'error'
+          ? '• Closing sub-agent failed'
+          : '• Closed sub-agent thread';
+      }
+
+      return status === 'failed' || status === 'error'
+        ? '• Sub-agent action failed'
+        : '• Updated sub-agent thread';
+    })();
+
+    const detailParts = [
+      prompt ? `Prompt: ${prompt}` : null,
+      newThreadId ? `Thread: ${newThreadId}` : null,
+      primaryReceiverThreadId ? `Target: ${primaryReceiverThreadId}` : null,
+      senderThreadId ? `From: ${senderThreadId}` : null,
+      agentStatus ? `Status: ${agentStatus}` : null,
+    ].filter(Boolean);
+
+    return withNestedDetail(title, detailParts.join('\n') || null);
+  }
+
   if (type === 'websearch') {
     const query = normalizeInline(readString(item.query), 180);
     const actionRecord = toRecord(item.action);
@@ -528,6 +896,55 @@ function toToolLikeMessage(item: Record<string, unknown>): string | null {
   return null;
 }
 
+function toSubAgentMeta(item: Record<string, unknown>): ChatMessageSubAgentMeta | undefined {
+  const tool = readString(item.tool) ?? undefined;
+  const prompt = normalizeInline(readString(item.prompt), 4000) ?? undefined;
+  const senderThreadId =
+    normalizeInline(
+      readString(item.senderThreadId) ?? readString(item.sender_thread_id),
+      200
+    ) ?? undefined;
+  const agentStatus =
+    normalizeInline(
+      readString(item.agentStatus) ?? readString(item.agent_status),
+      200
+    ) ?? undefined;
+  const receiverThreadIds = readReceiverThreadIds(item);
+
+  if (!tool && !prompt && !senderThreadId && receiverThreadIds.length === 0 && !agentStatus) {
+    return undefined;
+  }
+
+  return {
+    tool,
+    prompt,
+    senderThreadId,
+    receiverThreadIds,
+    agentStatus,
+  };
+}
+
+function readReceiverThreadIds(item: Record<string, unknown>): string[] {
+  const pluralIds = [
+    ...readStringArray(item.receiverThreadIds),
+    ...readStringArray(item.receiver_thread_ids),
+  ];
+  if (pluralIds.length > 0) {
+    return Array.from(new Set(pluralIds));
+  }
+
+  const singularIds = [
+    readString(item.newThreadId),
+    readString(item.new_thread_id),
+    readString(item.receiverThreadId),
+    readString(item.receiver_thread_id),
+  ]
+    .map((value) => value?.trim() ?? '')
+    .filter((value): value is string => value.length > 0);
+
+  return singularIds;
+}
+
 function normalizeType(value: string): string {
   return value.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
 }