@ateam-ai-mobile/core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,389 @@
+import * as zustand from 'zustand';
+
+/**
+ * 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). */
+interface OutgoingAttachment {
+    data: string;
+    mimeType: string;
+    name: string;
+}
+/** Attachment as rendered in a message bubble (local or remote preview URI). */
+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).
+ */
+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;
+}
+
+/**
+ * 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.
+ */
+
+/** 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. */
+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).
+ */
+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;
+}
+interface AdasUser {
+    actorId: string;
+    name?: string;
+    email?: string;
+}
+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;
+}
+/** 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. */
+declare function initAdas(config: AdasConfig): void;
+declare function isAdasInitialized(): boolean;
+declare function getConfig(): AdasConfig;
+declare function getCoreApiUrl(): string;
+declare function getCoreWsUrl(): string;
+declare function getVoiceApiUrl(): string;
+declare function getTenant(): string;
+declare function getUser(): AdasUser | null;
+declare function getToken(): string | null;
+
+type FetchOptions = RequestInit & {
+    baseUrl?: 'core' | 'voice';
+};
+/**
+ * Base API client with JWT injection and 401 refresh handling.
+ *
+ * Auth failure semantics (preserved from the reference app): a transient
+ * 5xx or network blip on the RETRY after a successful refresh must NOT be
+ * treated as sign-out. notifyAuthFailure() fires only when auth is genuinely
+ * broken:
+ *   - Refresh itself was rejected with 401/403          → auth failure
+ *   - Retry with the fresh JWT still returns 401/403    → auth failure
+ * Anything else throws but keeps the session intact — the caller may retry
+ * on the next user action.
+ */
+declare function apiFetch<T = unknown>(path: string, options?: FetchOptions): Promise<T>;
+/**
+ * Fetch with raw response (non-JSON responses, streaming bodies).
+ */
+declare function apiFetchRaw(path: string, options?: FetchOptions): Promise<Response>;
+
+/**
+ * Call a tool on a specific connector via POST /api/connectors/:id/call.
+ *
+ * NOTE: intentionally bypasses the /mcp proxy (which routes to adas-mcp).
+ * adas-mcp only knows skill-generated tools, NOT raw connector tools like
+ * triggers.list — the direct connector API is the reliable path.
+ */
+declare function connectorCall(connectorId: string, tool: string, args?: Record<string, any>): Promise<{
+    ok: boolean;
+    result: any;
+    error?: string;
+}>;
+/** Raw JSON-RPC passthrough to /mcp. Returns the full JSON-RPC response. */
+declare function mcpFetch(body: any): Promise<any>;
+/** JSON-RPC tools/call to /mcp (for core tools like cp.fe_api). */
+declare function mcpToolCall(toolName: string, args?: Record<string, any>): Promise<any>;
+/** Post a plugin command result back to Core. */
+declare function postCommandResult(correlationId: string, result: any, error?: string): Promise<void>;
+/**
+ * Unwrap MCP JSON-RPC text content → parsed business data.
+ * Server returns: { content: [{ type: "text", text: "{...}" }] }
+ */
+declare function unwrapMcpResult(result: any): any;
+
+interface ToolCall {
+    name: string;
+    args: Record<string, unknown>;
+    result: unknown;
+    skill?: string;
+}
+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;
+    };
+}
+type MessageAttachment = AttachmentPreview;
+/**
+ * UI Action chip — emitted by the polisher LLM, validated by cp.uiActions_api.
+ */
+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>;
+}
+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;
+}
+
+interface ChatState {
+    messages: Message[];
+    loading: boolean;
+    error: string | null;
+    activeJobId: string | null;
+    conversationLoaded: boolean;
+    /** Load conversation history from Core */
+    loadConversation: () => Promise<void>;
+    /** Send a message via POST /api/chat — creates a job, streams progress */
+    sendMessage: (text: string, skillSlug?: string, attachments?: OutgoingAttachment[]) => Promise<void>;
+    /** Respond to a paused sys.askUser question */
+    respondToQuestion: (jobId: string, inputId: string, answer: string) => Promise<void>;
+    /** Update in-flight job progress (called by the stream handler) */
+    updateJobProgress: (jobId: string, progress: Partial<JobProgress>) => void;
+    /** Reset chat (also re-fetches history on next mount — used on auth switch) */
+    clearChat: () => void;
+    /** Start a fresh empty chat without re-fetching history */
+    newChat: () => void;
+}
+/**
+ * Sentinel delimiters used to embed structured table data inside a flat
+ * message string. UI layers split on these and render the contents with a
+ * native table component instead of markdown tables — markdown tables look
+ * terrible on narrow phone screens.
+ *
+ * Unicode Private Use Area chars (U+E100/U+E101) so they never collide with
+ * anything the model could legitimately emit.
+ */
+declare const TABLE_BLOCK_OPEN = "\uE100";
+declare const TABLE_BLOCK_CLOSE = "\uE101";
+/**
+ * Extract display text from a conversation turn's assistant blocks.
+ * Handles multiple block kinds (text, code, json, markdown, table, html).
+ */
+declare function blocksToText(blocks?: Array<{
+    kind: string;
+    content: any;
+}>): string;
+declare const useChatStore: zustand.UseBoundStore<zustand.StoreApi<ChatState>>;
+/** Tear down the live connection (env/auth switch, SDK unmount). */
+declare function closeChatStream(): void;
+
+/**
+ * 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;
+interface BufferedCommand {
+    pluginId: string;
+    command: string;
+    args?: any;
+    correlationId?: string;
+    _bufferedAt: number;
+}
+declare class PluginCommandEmitter {
+    private listeners;
+    private recent;
+    on(event: string, fn: Listener): () => void;
+    off(event: string, fn: Listener): void;
+    emit(event: string, data: any): void;
+    /** 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[];
+}
+/** App-wide bus for plugin commands arriving over the chat stream. */
+declare const pluginCommandEmitter: PluginCommandEmitter;
+
+declare const colors: {
+    readonly dark: {
+        readonly bgPrimary: "#0a0e14";
+        readonly bgSecondary: "#111820";
+        readonly bgTertiary: "#1a2230";
+        readonly bgInput: "#0d1219";
+        readonly bgHover: "#1e2a3a";
+        readonly border: "rgba(255, 255, 255, 0.08)";
+        readonly borderHover: "rgba(255, 255, 255, 0.15)";
+        readonly textPrimary: "#e8ecf1";
+        readonly textSecondary: "#8b95a5";
+        readonly textMuted: "#5a6577";
+        readonly accent: "#2563eb";
+        readonly accentHover: "#3b82f6";
+        readonly accentSoft: "rgba(37, 99, 235, 0.15)";
+        readonly green: "#16a34a";
+        readonly greenSoft: "rgba(22, 163, 74, 0.15)";
+        readonly red: "#dc2626";
+        readonly redSoft: "rgba(220, 38, 38, 0.15)";
+        readonly amber: "#f59e0b";
+        readonly amberSoft: "rgba(245, 158, 11, 0.15)";
+        readonly purple: "#8b5cf6";
+        readonly purpleSoft: "rgba(139, 92, 246, 0.15)";
+        readonly userBubble: "#2563eb";
+        readonly botBubble: "#1a2230";
+        readonly botBubbleBorder: "rgba(255, 255, 255, 0.08)";
+    };
+    readonly light: {
+        readonly bgPrimary: "#ffffff";
+        readonly bgSecondary: "#f8f9fa";
+        readonly bgTertiary: "#f1f3f5";
+        readonly bgInput: "#ffffff";
+        readonly bgHover: "#e9ecef";
+        readonly border: "rgba(0, 0, 0, 0.08)";
+        readonly borderHover: "rgba(0, 0, 0, 0.15)";
+        readonly textPrimary: "#1a1a2e";
+        readonly textSecondary: "#6b7280";
+        readonly textMuted: "#9ca3af";
+        readonly accent: "#2563eb";
+        readonly accentHover: "#1d4ed8";
+        readonly accentSoft: "rgba(37, 99, 235, 0.1)";
+        readonly green: "#16a34a";
+        readonly greenSoft: "rgba(22, 163, 74, 0.1)";
+        readonly red: "#dc2626";
+        readonly redSoft: "rgba(220, 38, 38, 0.1)";
+        readonly amber: "#f59e0b";
+        readonly amberSoft: "rgba(245, 158, 11, 0.1)";
+        readonly purple: "#8b5cf6";
+        readonly purpleSoft: "rgba(139, 92, 246, 0.1)";
+        readonly userBubble: "#2563eb";
+        readonly botBubble: "#f1f3f5";
+        readonly botBubbleBorder: "rgba(0, 0, 0, 0.08)";
+    };
+};
+declare const ada: {
+    readonly paper: "#FAF6EE";
+    readonly paperSoft: "#F2EADC";
+    readonly paperDeep: "#EBE0CC";
+    readonly ink: "#1a1410";
+    readonly inkSoft: "#5a4d3f";
+    readonly inkMuted: "#9a8870";
+    readonly border: "rgba(26, 20, 16, 0.08)";
+    readonly borderStrong: "rgba(26, 20, 16, 0.16)";
+    readonly orange: "#FF7A28";
+    readonly orangeDeep: "#B8410A";
+    readonly orangeSoft: "rgba(255, 122, 40, 0.14)";
+    readonly userBubble: "#1a1410";
+    readonly userBubbleText: "#FAF6EE";
+    readonly botBubble: "#F2EADC";
+    readonly botBubbleBorder: "rgba(26, 20, 16, 0.06)";
+    readonly botBubbleText: "#1a1410";
+};
+declare const spacing: {
+    readonly xs: 4;
+    readonly sm: 8;
+    readonly md: 12;
+    readonly lg: 16;
+    readonly xl: 20;
+    readonly xxl: 24;
+    readonly xxxl: 32;
+};
+declare const fontSize: {
+    readonly xs: 11;
+    readonly sm: 13;
+    readonly md: 15;
+    readonly lg: 17;
+    readonly xl: 20;
+    readonly xxl: 24;
+    readonly title: 28;
+};
+declare const borderRadius: {
+    readonly sm: 8;
+    readonly md: 12;
+    readonly lg: 16;
+    readonly xl: 20;
+    readonly full: 9999;
+};
+
+export { type AdasConfig, type AdasUser, type AttachmentCache, type AttachmentPreview, type BufferedCommand, type JobProgress, type Message, type MessageAttachment, type OutgoingAttachment, PluginCommandEmitter, type RefreshOutcome, TABLE_BLOCK_CLOSE, TABLE_BLOCK_OPEN, type TokenProvider, type ToolCall, type UIAction, ada, apiFetch, apiFetchRaw, blocksToText, borderRadius, closeChatStream, colors, connectorCall, fontSize, getConfig, getCoreApiUrl, getCoreWsUrl, getTenant, getToken, getUser, getVoiceApiUrl, initAdas, isAdasInitialized, mcpFetch, mcpToolCall, pluginCommandEmitter, postCommandResult, spacing, unwrapMcpResult, useChatStore };