@ateam-ai-mobile/core 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai-mobile/core",
-  "version": "0.1.1",
+  "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.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api/tenants.ts

@@ -1,4 +1,6 @@
 import { apiFetch } from './client';
+import { getConsumerAuthApiUrl, getToken, getConfig, type AdasSession } from '../config';
+import { useChatStore, closeChatStream } from '../chat/store';
 
 export interface TenantMembership {
   id: string;
@@ -9,14 +11,65 @@ export interface TenantMembership {
 /**
  * List the tenants the CURRENT user belongs to (GET /api/tenants/list).
  *
- * For consumer JWTs the backend resolves memberships by login identity
- * (google/apple oauth or embed id) across active tenants; builder JWTs get
- * their user-doc memberships. Returns [] when signed out or unknown.
- *
- * Note: switching tenant still requires a NEW JWT for that tenant (the
- * token is tenant-scoped) — the host owns that re-auth flow.
+ * The list is membership-scoped: for consumer JWTs the backend returns ONLY
+ * tenants where the user's login identity (google/apple oauth or embed id)
+ * has an active actor; builder JWTs get their user-doc memberships. It never
+ * 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 : [];
 }
+
+/**
+ * Re-scope the whole session to another tenant the user already belongs to.
+ *
+ * The backend treats the JWT tenant claim as the sole source of truth, so
+ * switching = minting a fresh JWT for the target tenant's actor. The SDK
+ * owns the call (POST consumer-auth /platform/consumer/switch-tenant, authed
+ * by the current token); the HOST persists the new session via
+ * `config.onSession` (the SDK never stores credentials). The chat stream is
+ * then torn down and cleared so it reconnects against the new tenant.
+ *
+ * Requires `consumerAuthUrl` and `onSession` in the initAdas() config.
+ * Throws on any non-OK response (e.g. not a member of the target tenant).
+ */
+export async function switchTenant(targetTenantId: string): Promise<AdasSession> {
+  const token = getToken();
+  if (!token) throw new Error('[adas] switchTenant: not signed in');
+
+  const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/switch-tenant`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ target_tenant: targetTenantId }),
+  });
+
+  const data = await res.json().catch(() => null);
+  if (!res.ok || !data?.ok || !data.jwt) {
+    throw new Error(data?.error || `switchTenant failed (${res.status})`);
+  }
+
+  const session: AdasSession = {
+    jwt: data.jwt,
+    tenant: data.tenant,
+    actor: data.actor,
+  };
+
+  // Host persists the new token + active tenant BEFORE we reconnect, so the
+  // fresh stream/requests pick up the target-tenant credentials.
+  const onSession = getConfig().onSession;
+  if (!onSession) {
+    throw new Error('[adas] switchTenant: config.onSession is required to persist the new session');
+  }
+  await onSession(session);
+
+  // Tear down the old-tenant stream and history; the chat screen reloads
+  // against the new tenant on its next mount / loadConversation().
+  closeChatStream();
+  useChatStore.getState().clearChat();
+
+  return session;
+}

package/src/chat/store.ts

@@ -128,6 +128,10 @@ function snapshotToProgress(snap: any, rootJobId: string): Partial<JobProgress>
   const liveProgress = extractLiveProgress(snap);
   if (liveProgress) progress.liveProgress = liveProgress;
 
+  // Human-language status (additive; absent when disabled/uncached).
+  if (typeof snap?.humanStatus === 'string' && snap.humanStatus) progress.humanStatus = snap.humanStatus;
+  if (snap?.humanLabels && typeof snap.humanLabels === 'object') progress.humanLabels = snap.humanLabels;
+
   if (pq) {
     progress.pendingQuestion = {
       inputId: pq.correlation_id || pq.correlationId || pq.inputId || '',

package/src/chat/types.ts

@@ -26,6 +26,12 @@ export interface JobProgress {
   resultActions?: UIAction[];
   /** Live progress from adas_emit_progress() — latest event from a running fat tool */
   liveProgress?: { message: string; step?: number; total?: number };
+  /** One warm, present-tense, localized line describing the current action
+   *  (backend statusI18n). Absent when disabled / not yet cached → fall back
+   *  to raw tokens. */
+  humanStatus?: string;
+  /** Lookup { rawToken → friendly phrase } for tokens in this snapshot. */
+  humanLabels?: Record<string, string>;
   pendingQuestion?: {
     inputId: string;
     question: string;

package/src/config.ts

@@ -57,6 +57,10 @@ export interface AdasConfig {
   coreUrl: UrlSource;
   /** Voice service base URL (optional — only voice features need it). */
   voiceUrl?: UrlSource;
+  /** Consumer-auth base URL, e.g. https://consumer-auth.ateam-ai.com. Only
+   *  needed for `switchTenant()` (re-scoping the session to another tenant
+   *  the user belongs to). */
+  consumerAuthUrl?: UrlSource;
   tokenProvider: TokenProvider;
   /** Tenant slug — used for plugin URL resolution and voice, never sent as a
    *  header (the backend derives the tenant from the JWT). Pass a getter when
@@ -70,6 +74,18 @@ export interface AdasConfig {
    *  survive app restarts. No-op when omitted (previews live in memory for
    *  the session only). @ateam-ai-mobile/ui ships an Expo/RN implementation. */
   attachmentCache?: AttachmentCache;
+  /** Called by `switchTenant()` with the freshly-minted session for the
+   *  target tenant. The host MUST persist it here (store the new JWT so
+   *  tokenProvider.getToken() returns it, and update the active tenant) —
+   *  the SDK never stores credentials. Awaited before the chat reconnects. */
+  onSession?: (session: AdasSession) => void | Promise<void>;
+}
+
+/** A tenant-scoped session minted by the platform (e.g. via switchTenant). */
+export interface AdasSession {
+  jwt: string;
+  tenant: { id: string; name: string };
+  actor: { id: string; email: string | null; roles: string[] };
 }
 
 let _config: AdasConfig | null = null;
@@ -110,6 +126,12 @@ export function getVoiceApiUrl(): string {
   return resolveUrl(url);
 }
 
+export function getConsumerAuthApiUrl(): string {
+  const url = getConfig().consumerAuthUrl;
+  if (!url) throw new Error('[adas] consumerAuthUrl not configured — required for switchTenant()');
+  return resolveUrl(url);
+}
+
 export function getTenant(): string {
   const t = getConfig().tenant;
   return (typeof t === 'function' ? t() : t) || '';

package/src/index.ts

@@ -23,11 +23,12 @@ export {
   getCoreApiUrl,
   getCoreWsUrl,
   getVoiceApiUrl,
+  getConsumerAuthApiUrl,
   getTenant,
   getUser,
   getToken,
 } from './config';
-export type { AdasConfig, TokenProvider, RefreshOutcome, AdasUser } from './config';
+export type { AdasConfig, TokenProvider, RefreshOutcome, AdasUser, AdasSession } from './config';
 
 // API client
 export { apiFetch, apiFetchRaw } from './api/client';
@@ -42,7 +43,7 @@ export {
 } from './api/mcp';
 
 // Tenant memberships
-export { listMyTenants } from './api/tenants';
+export { listMyTenants, switchTenant } from './api/tenants';
 export type { TenantMembership } from './api/tenants';
 
 // Chat