@ateam-ai-mobile/core 0.1.3 → 0.1.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ateam-ai-mobile/core",
-  "version": "0.1.3",
-  "description": "Headless ADAS SDK core \u2014 auth bridge, API client, chat/job streaming, MCP calls, theme tokens. No UI, no Expo dependencies.",
+  "version": "0.1.5",
+  "description": "Headless ADAS SDK core — auth bridge, API client, chat/job streaming, MCP calls, theme tokens. No UI, no Expo dependencies.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -24,4 +24,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/api/tenants.ts

@@ -1,4 +1,3 @@
-import { apiFetch } from './client';
 import { getConsumerAuthApiUrl, getToken, getConfig, type AdasSession } from '../config';
 import { useChatStore, closeChatStream } from '../chat/store';
 
@@ -17,8 +16,22 @@ export interface TenantMembership {
  * leaks the full tenant list. Returns [] when signed out or unknown.
  */
 export async function listMyTenants(): Promise<TenantMembership[]> {
-  const data = await apiFetch<{ ok: boolean; tenants?: TenantMembership[] }>('/api/tenants/list');
-  return data.ok && Array.isArray(data.tenants) ? data.tenants : [];
+  const token = getToken();
+  if (!token) return [];
+  try {
+    const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/my-tenants`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok || !data?.ok || !Array.isArray(data.tenants)) return [];
+    return data.tenants.map((t: any) => ({
+      id: t.id,
+      name: t.name || t.id,
+      role: t.role ?? null,
+    }));
+  } catch {
+    return [];
+  }
 }
 
 /**

package/src/chat/store.ts

@@ -353,85 +353,105 @@ export const useChatStore = create<ChatState>((set, get) => ({
 
       let firstRunning: Message | undefined = keptPlaceholders.find(m => m.jobProgress?.status === 'running');
 
-      // Cold-start / post-refresh reattach: the WS subscription dies on app
-      // restart. /api/chain/current is the single hydration endpoint that
-      // says "is a chain still in flight for this actor?". If yes, re-open
-      // the live subscription on the same chainId so the pill comes back.
+      // Cold-start / post-refresh reattach: WS subscriptions die on app
+      // restart. Fetch ALL active chains for this actor (chain-native SlimChain
+      // API) and reattach EACH — multiple concurrent chains must all come back
+      // in progress, not just the most-recently-updated one. Falls back to the
+      // legacy single-chain /api/chain/current on older backends.
       try {
-        const chainRes = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
+        let activeChains: any[] = [];
+        const chainsRes = await fetch(`${getCoreApiUrl()}/api/chains/active`, {
           headers: coreHeaders(),
         });
-        if (chainRes.ok) {
-          const chainBody = await chainRes.json();
-          const slim = chainBody?.data;
-          if (slim?.id) {
-            const chainId = String(slim.id);
-            const alreadyTracked = finalMessages.some(m =>
-              m.role === 'assistant' && m.jobProgress?.jobId === chainId
-            );
-            if (!alreadyTracked) {
-              const progress = snapshotToProgress(slim, chainId);
-              const chainCreatedAt = typeof slim.createdAt === 'number'
-                ? slim.createdAt
-                : (typeof slim.lastUpdate === 'number' ? slim.lastUpdate : Date.now());
-              const chainLastUpdate = typeof slim.lastUpdate === 'number' ? slim.lastUpdate : chainCreatedAt;
-              const jobProgress = {
-                jobId: chainId,
-                actorId: extractActorId(slim),
-                status: 'running',
-                chainStartedAt: chainCreatedAt,
-                ...progress,
-              } as JobProgress;
-
-              // Synthesize the user bubble if a hard refresh wiped the
-              // optimistic one and the chain hasn't persisted its turn yet.
-              const goal = typeof slim.goal === 'string' ? slim.goal : '';
-              const userExists = finalMessages.some(m =>
-                m.role === 'user' && (m.chainId === chainId || (goal && m.content === goal))
-              );
-              if (goal && !userExists) {
-                finalMessages.push({
-                  id: `user-${chainId}`,
-                  role: 'user',
-                  content: goal,
-                  timestamp: new Date(chainCreatedAt),
-                  chainId,
-                });
-              }
-
-              // Assistant side: attach to matching persisted turn if one
-              // exists; otherwise push a placeholder bubble.
-              let matchIdx = -1;
-              for (let i = finalMessages.length - 1; i >= 0; i--) {
-                const m = finalMessages[i];
-                if (m.role === 'assistant' && m.chainId === chainId) {
-                  matchIdx = i;
-                  break;
-                }
-              }
-              if (matchIdx >= 0) {
-                finalMessages[matchIdx] = { ...finalMessages[matchIdx], jobProgress };
-                if (jobProgress.status === 'running') firstRunning = finalMessages[matchIdx];
-              } else {
-                const reattachBubble: Message = {
-                  id: `job-${chainId}`,
-                  role: 'assistant',
-                  content: 'Working on it...',
-                  timestamp: new Date(chainLastUpdate),
-                  jobProgress,
-                  chainId,
-                };
-                finalMessages.push(reattachBubble);
-                if (jobProgress.status === 'running') firstRunning = reattachBubble;
-              }
-
-              finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-
-              // Re-open the live subscription.
-              streamJob(chainId, getTenant(), getToken());
+        if (chainsRes.ok) {
+          const body = await chainsRes.json();
+          activeChains = Array.isArray(body?.chains) ? body.chains : [];
+        } else {
+          // Legacy backend without the plural endpoint — single most-recent chain.
+          const legacy = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
+            headers: coreHeaders(),
+          });
+          if (legacy.ok) {
+            const lb = await legacy.json();
+            if (lb?.data?.id) activeChains = [lb.data];
+          }
+        }
+
+        for (const slim of activeChains) {
+          if (!slim?.id) continue;
+          const chainId = String(slim.id);
+          const alreadyTracked = finalMessages.some(m =>
+            m.role === 'assistant' && m.jobProgress?.jobId === chainId
+          );
+          if (alreadyTracked) continue;
+
+          // Chain-native status: prefer the whole-chain aggregate (chainStatus)
+          // over the active job's per-job status, so e.g. a chain still running
+          // across a handoff isn't shown as "done". A pending question still
+          // overrides to "paused" inside snapshotToProgress.
+          const progress = snapshotToProgress(
+            { ...slim, status: slim.chainStatus || slim.status },
+            chainId,
+          );
+          const chainCreatedAt = typeof slim.createdAt === 'number'
+            ? slim.createdAt
+            : (typeof slim.lastUpdate === 'number' ? slim.lastUpdate : Date.now());
+          const chainLastUpdate = typeof slim.lastUpdate === 'number' ? slim.lastUpdate : chainCreatedAt;
+          const jobProgress = {
+            jobId: chainId,
+            actorId: extractActorId(slim),
+            status: 'running',
+            chainStartedAt: chainCreatedAt,
+            ...progress,
+          } as JobProgress;
+
+          // Synthesize the user bubble if a hard refresh wiped the optimistic
+          // one and the chain hasn't persisted its turn yet.
+          const goal = typeof slim.goal === 'string' ? slim.goal : '';
+          const userExists = finalMessages.some(m =>
+            m.role === 'user' && (m.chainId === chainId || (goal && m.content === goal))
+          );
+          if (goal && !userExists) {
+            finalMessages.push({
+              id: `user-${chainId}`,
+              role: 'user',
+              content: goal,
+              timestamp: new Date(chainCreatedAt),
+              chainId,
+            });
+          }
+
+          // Assistant side: attach to matching persisted turn if one exists;
+          // otherwise push a placeholder bubble.
+          let matchIdx = -1;
+          for (let i = finalMessages.length - 1; i >= 0; i--) {
+            const m = finalMessages[i];
+            if (m.role === 'assistant' && m.chainId === chainId) {
+              matchIdx = i;
+              break;
             }
           }
+          if (matchIdx >= 0) {
+            finalMessages[matchIdx] = { ...finalMessages[matchIdx], jobProgress };
+            if (jobProgress.status === 'running' && !firstRunning) firstRunning = finalMessages[matchIdx];
+          } else {
+            const reattachBubble: Message = {
+              id: `job-${chainId}`,
+              role: 'assistant',
+              content: 'Working on it...',
+              timestamp: new Date(chainLastUpdate),
+              jobProgress,
+              chainId,
+            };
+            finalMessages.push(reattachBubble);
+            if (jobProgress.status === 'running' && !firstRunning) firstRunning = reattachBubble;
+          }
+
+          // Re-open the live subscription for this chain.
+          streamJob(chainId, getTenant(), getToken());
         }
+
+        finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
       } catch {}
 
       set({

package/src/index.ts

@@ -27,6 +27,7 @@ export {
   getTenant,
   getUser,
   getToken,
+  refreshToken,
 } from './config';
 export type { AdasConfig, TokenProvider, RefreshOutcome, AdasUser, AdasSession } from './config';