@ateam-ai-mobile/core 0.1.0

package/src/chat/types.ts

@@ -0,0 +1,76 @@
+import type { AttachmentPreview } from '../storage/types';
+
+export interface ToolCall {
+  name: string;
+  args: Record<string, unknown>;
+  result: unknown;
+  skill?: string;
+}
+
+export interface JobProgress {
+  jobId: string;
+  /** Actor that owns the running chain — needed when restoring active work. */
+  actorId?: string;
+  status: 'running' | 'done' | 'error' | 'paused' | 'unknown';
+  subStatus?: string;
+  phase?: string;
+  iteration?: number;
+  /** Active skill slug at this point in the chain (e.g. "messaging-agent") */
+  skillSlug?: string;
+  /** Most recent tool being invoked by the active skill */
+  currentTool?: string;
+  /** Wall-clock timestamp when the chain started — used for elapsed timer */
+  chainStartedAt?: number;
+  resultMessage?: string;
+  /** UI Action chips to attach to the assistant bubble when this job finishes. */
+  resultActions?: UIAction[];
+  /** Live progress from adas_emit_progress() — latest event from a running fat tool */
+  liveProgress?: { message: string; step?: number; total?: number };
+  pendingQuestion?: {
+    inputId: string;
+    question: string;
+    inputType: 'text' | 'choice' | 'confirm';
+    options?: string[];
+    placeholder?: string;
+  };
+}
+
+export type MessageAttachment = AttachmentPreview;
+
+/**
+ * UI Action chip — emitted by the polisher LLM, validated by cp.uiActions_api.
+ */
+export interface UIAction {
+  intent: 'view_entity' | 'suggested_action' | 'quick_toggle' | 'cross_plugin';
+  label: string;
+  description?: string;
+  icon?: string;
+  /** Short plugin id (e.g. "triggers-panel") — what the LLM picks from the inventory. */
+  target: string;
+  /** Full plugin id — added by validator, used by the host to navigate. */
+  pluginId?: string;
+  /** Already-substituted iframe URL — used by web; mobile ignores it. */
+  resolvedUrl?: string;
+  /** Intent-specific payload. */
+  payload: Record<string, any>;
+}
+
+export interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: Date;
+  toolCalls?: ToolCall[];
+  jobProgress?: JobProgress;
+  /** Skill that handled this turn */
+  skillSlug?: string;
+  /** Attached images/files */
+  attachments?: MessageAttachment[];
+  /** UI Action chips beneath assistant bubbles */
+  actions?: UIAction[];
+  /** Chain id from /api/conversation — used to attach live progress to the
+   *  correct persisted turn instead of fabricating a duplicate bubble. */
+  chainId?: string;
+  /** Turn variant. 'notification' = proactive/system-initiated. */
+  kind?: 'notification' | string;
+}

package/src/config.ts

@@ -0,0 +1,118 @@
+/**
+ * SDK configuration — the single injection point between the host app and
+ * the ADAS core. The host owns authentication, identity, and URL discovery;
+ * the SDK reads everything through the config registered via initAdas().
+ *
+ * There is intentionally ONE active config per JS context (module singleton):
+ * the chat store, WebSocket, and API client below it are app-wide singletons
+ * too, and a second tenant/backend inside one app is not a supported v1 case.
+ */
+
+import type { AttachmentCache } from './storage/types';
+
+/** Result of a host-driven token refresh. Mirrors the semantics the API
+ *  client depends on: only 'auth_failed' logs the user out; 'transient'
+ *  (network blip, 5xx) keeps the session so the next call can retry. */
+export interface RefreshOutcome {
+  ok: 'ok' | 'auth_failed' | 'transient';
+  status: number;
+  reason?: string;
+}
+
+/**
+ * Host-implemented auth bridge. The SDK never shows login UI and never
+ * stores credentials — the host authenticates its own users and hands the
+ * SDK a way to read/refresh the ADAS JWT it minted for them (via the
+ * server-to-server token exchange).
+ */
+export interface TokenProvider {
+  /** Current ADAS JWT, or null when signed out. Called on every request —
+   *  keep it synchronous and cheap (read from memory, not disk). */
+  getToken(): string | null;
+  /** Called on 401. Host should mint/refresh the ADAS token and return the
+   *  outcome; 'ok' makes the SDK retry the failed request once. */
+  refresh(): Promise<RefreshOutcome>;
+  /** Auth is genuinely dead (refresh rejected, or retry still 401). Host
+   *  should treat this as sign-out for the embedded experience. */
+  onAuthFailure?: () => void;
+}
+
+export interface AdasUser {
+  actorId: string;
+  name?: string;
+  email?: string;
+}
+
+export interface AdasConfig {
+  /** Core API base URL, e.g. https://app.ateam-ai.com */
+  coreUrl: string;
+  /** Voice service base URL (optional — only voice features need it). */
+  voiceUrl?: string;
+  tokenProvider: TokenProvider;
+  /** Tenant slug — informational/telemetry only. The backend derives the
+   *  tenant from the JWT; the SDK never sends a tenant header. */
+  tenant?: string;
+  /** Current end user as known to the host. actorId is used as the chat
+   *  reply context; without it, replies route to 'unknown'. */
+  getUser?: () => AdasUser | null;
+  /** Optional persistence for outgoing image/file attachments so previews
+   *  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;
+}
+
+let _config: AdasConfig | null = null;
+
+/** Register the SDK configuration. Call once at app start, before any other
+ *  SDK API. Calling again replaces the config (e.g. env switch) — combine
+ *  with chat.clearChat() and closeChatStream() for a clean swap. */
+export function initAdas(config: AdasConfig): void {
+  _config = config;
+}
+
+export function isAdasInitialized(): boolean {
+  return _config !== null;
+}
+
+export function getConfig(): AdasConfig {
+  if (!_config) {
+    throw new Error('[adas] SDK not initialized — call initAdas(config) before using any ADAS API');
+  }
+  return _config;
+}
+
+export function getCoreApiUrl(): string {
+  return getConfig().coreUrl.replace(/\/$/, '');
+}
+
+export function getCoreWsUrl(): string {
+  return getCoreApiUrl().replace(/^http/, 'ws');
+}
+
+export function getVoiceApiUrl(): string {
+  const url = getConfig().voiceUrl;
+  if (!url) throw new Error('[adas] voiceUrl not configured');
+  return url.replace(/\/$/, '');
+}
+
+export function getTenant(): string {
+  return getConfig().tenant || '';
+}
+
+export function getUser(): AdasUser | null {
+  return getConfig().getUser?.() || null;
+}
+
+// ─── Internal token helpers (thin wrappers over the host's TokenProvider) ──
+
+export function getToken(): string | null {
+  return getConfig().tokenProvider.getToken();
+}
+
+export async function refreshToken(): Promise<RefreshOutcome> {
+  return getConfig().tokenProvider.refresh();
+}
+
+export function notifyAuthFailure(): void {
+  getConfig().tokenProvider.onAuthFailure?.();
+}

package/src/index.ts

@@ -0,0 +1,72 @@
+/**
+ * @ateam-ai-mobile/core — headless ADAS SDK for React Native.
+ *
+ * The host app owns authentication and navigation; this package provides
+ * everything between the ADAS backend and the UI: config/auth bridge, API
+ * client, chat store with live job streaming, MCP tool calls, and theme
+ * tokens. No Expo dependencies — works in Expo and bare RN apps alike.
+ *
+ * Quick start:
+ *   initAdas({
+ *     coreUrl: 'https://app.ateam-ai.com',
+ *     tokenProvider: { getToken, refresh, onAuthFailure },
+ *     getUser: () => ({ actorId: currentUser.id }),
+ *   });
+ *   const { messages, sendMessage } = useChatStore();
+ */
+
+// Config & auth bridge
+export {
+  initAdas,
+  isAdasInitialized,
+  getConfig,
+  getCoreApiUrl,
+  getCoreWsUrl,
+  getVoiceApiUrl,
+  getTenant,
+  getUser,
+  getToken,
+} from './config';
+export type { AdasConfig, TokenProvider, RefreshOutcome, AdasUser } from './config';
+
+// API client
+export { apiFetch, apiFetchRaw } from './api/client';
+
+// MCP / connector calls
+export {
+  connectorCall,
+  mcpFetch,
+  mcpToolCall,
+  postCommandResult,
+  unwrapMcpResult,
+} from './api/mcp';
+
+// Chat
+export {
+  useChatStore,
+  closeChatStream,
+  blocksToText,
+  TABLE_BLOCK_OPEN,
+  TABLE_BLOCK_CLOSE,
+} from './chat/store';
+export type {
+  Message,
+  MessageAttachment,
+  JobProgress,
+  UIAction,
+  ToolCall,
+} from './chat/types';
+
+// Storage adapter contracts
+export type {
+  AttachmentCache,
+  AttachmentPreview,
+  OutgoingAttachment,
+} from './storage/types';
+
+// Plugin command bus
+export { pluginCommandEmitter, PluginCommandEmitter } from './utils/emitter';
+export type { BufferedCommand } from './utils/emitter';
+
+// Theme tokens
+export { colors, ada, spacing, fontSize, borderRadius } from './theme/tokens';

package/src/storage/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Storage adapter contracts. The core is platform-agnostic (no Expo, no
+ * AsyncStorage imports) — hosts or @ateam-ai-mobile/ui plug in concrete implementations.
+ */
+
+/** Outgoing attachment as sent to /api/chat (base64 payload). */
+export interface OutgoingAttachment {
+  data: string;
+  mimeType: string;
+  name: string;
+}
+
+/** Attachment as rendered in a message bubble (local or remote preview URI). */
+export interface AttachmentPreview {
+  mimeType: string;
+  name: string;
+  previewUri?: string;
+}
+
+/**
+ * Persists outgoing attachments keyed by jobId so image previews survive
+ * app restarts (/api/conversation does not echo user attachments back).
+ */
+export interface AttachmentCache {
+  /** Resolve once the index is loaded — get() before this may return undefined. */
+  ready(): Promise<void>;
+  save(jobId: string, attachments: OutgoingAttachment[]): Promise<void>;
+  get(jobId: string): AttachmentPreview[] | undefined;
+}

package/src/theme/tokens.ts

@@ -0,0 +1,105 @@
+// ADAS design tokens — shared by @ateam-ai-mobile/ui and host apps that want to match.
+
+export const colors = {
+  dark: {
+    bgPrimary: '#0a0e14',
+    bgSecondary: '#111820',
+    bgTertiary: '#1a2230',
+    bgInput: '#0d1219',
+    bgHover: '#1e2a3a',
+    border: 'rgba(255, 255, 255, 0.08)',
+    borderHover: 'rgba(255, 255, 255, 0.15)',
+    textPrimary: '#e8ecf1',
+    textSecondary: '#8b95a5',
+    textMuted: '#5a6577',
+    accent: '#2563eb',
+    accentHover: '#3b82f6',
+    accentSoft: 'rgba(37, 99, 235, 0.15)',
+    green: '#16a34a',
+    greenSoft: 'rgba(22, 163, 74, 0.15)',
+    red: '#dc2626',
+    redSoft: 'rgba(220, 38, 38, 0.15)',
+    amber: '#f59e0b',
+    amberSoft: 'rgba(245, 158, 11, 0.15)',
+    purple: '#8b5cf6',
+    purpleSoft: 'rgba(139, 92, 246, 0.15)',
+    // Message-specific
+    userBubble: '#2563eb',
+    botBubble: '#1a2230',
+    botBubbleBorder: 'rgba(255, 255, 255, 0.08)',
+  },
+  light: {
+    bgPrimary: '#ffffff',
+    bgSecondary: '#f8f9fa',
+    bgTertiary: '#f1f3f5',
+    bgInput: '#ffffff',
+    bgHover: '#e9ecef',
+    border: 'rgba(0, 0, 0, 0.08)',
+    borderHover: 'rgba(0, 0, 0, 0.15)',
+    textPrimary: '#1a1a2e',
+    textSecondary: '#6b7280',
+    textMuted: '#9ca3af',
+    accent: '#2563eb',
+    accentHover: '#1d4ed8',
+    accentSoft: 'rgba(37, 99, 235, 0.1)',
+    green: '#16a34a',
+    greenSoft: 'rgba(22, 163, 74, 0.1)',
+    red: '#dc2626',
+    redSoft: 'rgba(220, 38, 38, 0.1)',
+    amber: '#f59e0b',
+    amberSoft: 'rgba(245, 158, 11, 0.1)',
+    purple: '#8b5cf6',
+    purpleSoft: 'rgba(139, 92, 246, 0.1)',
+    userBubble: '#2563eb',
+    botBubble: '#f1f3f5',
+    botBubbleBorder: 'rgba(0, 0, 0, 0.08)',
+  },
+} as const;
+
+// Ada palette — warm, paper, personal. Used by the consumer chat experience.
+export const ada = {
+  paper: '#FAF6EE',
+  paperSoft: '#F2EADC',
+  paperDeep: '#EBE0CC',
+  ink: '#1a1410',
+  inkSoft: '#5a4d3f',
+  inkMuted: '#9a8870',
+  border: 'rgba(26, 20, 16, 0.08)',
+  borderStrong: 'rgba(26, 20, 16, 0.16)',
+  orange: '#FF7A28',
+  orangeDeep: '#B8410A',
+  orangeSoft: 'rgba(255, 122, 40, 0.14)',
+  userBubble: '#1a1410',
+  userBubbleText: '#FAF6EE',
+  botBubble: '#F2EADC',
+  botBubbleBorder: 'rgba(26, 20, 16, 0.06)',
+  botBubbleText: '#1a1410',
+} as const;
+
+export const spacing = {
+  xs: 4,
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  xxl: 24,
+  xxxl: 32,
+} as const;
+
+export const fontSize = {
+  xs: 11,
+  sm: 13,
+  md: 15,
+  lg: 17,
+  xl: 20,
+  xxl: 24,
+  title: 28,
+} as const;
+
+export const borderRadius = {
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  full: 9999,
+} as const;

package/src/utils/emitter.ts

@@ -0,0 +1,74 @@
+/**
+ * Lightweight event emitter bridging the chat job stream → plugin bridges
+ * (React Native has no Node 'events' module).
+ *
+ * Events: 'plugin-command' (raw command), 'focus-plugin' ({ pluginId, props }),
+ * 'plugin-close' ({ pluginId }), 'prepare-chat-message' ({ text }).
+ */
+
+type Listener = (data: any) => void;
+
+export interface BufferedCommand {
+  pluginId: string;
+  command: string;
+  args?: any;
+  correlationId?: string;
+  _bufferedAt: number;
+}
+
+const RECENT_TTL_MS = 10000;
+const RECENT_MAX = 20;
+
+export class PluginCommandEmitter {
+  private listeners = new Map<string, Set<Listener>>();
+  // Ring buffer of plugin commands seen recently. Lets a plugin that mounts
+  // AFTER its first command was emitted (e.g. a surface mounted by the
+  // dispatcher in response to focus-plugin) still pick that command up via
+  // `drainPluginCommands(pluginId)`. Self-cleans on TTL + size cap.
+  private recent: BufferedCommand[] = [];
+
+  on(event: string, fn: Listener): () => void {
+    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+    this.listeners.get(event)!.add(fn);
+    return () => this.off(event, fn);
+  }
+
+  off(event: string, fn: Listener): void {
+    this.listeners.get(event)?.delete(fn);
+  }
+
+  emit(event: string, data: any): void {
+    if (event === 'plugin-command' && data && data.pluginId && data.command && data.command !== '__focus') {
+      this.recent.push({
+        pluginId: data.pluginId,
+        command: data.command,
+        args: data.args,
+        correlationId: data.correlationId,
+        _bufferedAt: Date.now(),
+      });
+      if (this.recent.length > RECENT_MAX) this.recent.shift();
+    }
+    this.listeners.get(event)?.forEach((fn) => {
+      try { fn(data); } catch {}
+    });
+  }
+
+  /** Pop and return any plugin-commands targeted at `pluginId` that were
+   *  emitted within the last RECENT_TTL_MS. Used by the native bridge on
+   *  mount so the surface-dispatcher path doesn't drop the first command. */
+  drainPluginCommands(pluginId: string): BufferedCommand[] {
+    const now = Date.now();
+    const out: BufferedCommand[] = [];
+    const remaining: BufferedCommand[] = [];
+    for (const cmd of this.recent) {
+      if (now - cmd._bufferedAt > RECENT_TTL_MS) continue; // expired, drop
+      if (cmd.pluginId === pluginId) out.push(cmd);
+      else remaining.push(cmd);
+    }
+    this.recent = remaining;
+    return out;
+  }
+}
+
+/** App-wide bus for plugin commands arriving over the chat stream. */
+export const pluginCommandEmitter = new PluginCommandEmitter();