@ateam-ai-mobile/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1027 @@
+// src/config.ts
+var _config = null;
+function initAdas(config) {
+  _config = config;
+}
+function isAdasInitialized() {
+  return _config !== null;
+}
+function getConfig() {
+  if (!_config) {
+    throw new Error("[adas] SDK not initialized \u2014 call initAdas(config) before using any ADAS API");
+  }
+  return _config;
+}
+function getCoreApiUrl() {
+  return getConfig().coreUrl.replace(/\/$/, "");
+}
+function getCoreWsUrl() {
+  return getCoreApiUrl().replace(/^http/, "ws");
+}
+function getVoiceApiUrl() {
+  const url = getConfig().voiceUrl;
+  if (!url) throw new Error("[adas] voiceUrl not configured");
+  return url.replace(/\/$/, "");
+}
+function getTenant() {
+  return getConfig().tenant || "";
+}
+function getUser() {
+  return getConfig().getUser?.() || null;
+}
+function getToken() {
+  return getConfig().tokenProvider.getToken();
+}
+async function refreshToken() {
+  return getConfig().tokenProvider.refresh();
+}
+function notifyAuthFailure() {
+  getConfig().tokenProvider.onAuthFailure?.();
+}
+
+// src/api/client.ts
+async function apiFetch(path, options = {}) {
+  const { baseUrl = "core", ...fetchOptions } = options;
+  const base = baseUrl === "voice" ? getVoiceApiUrl() : getCoreApiUrl();
+  const url = `${base}${path}`;
+  const token = getToken();
+  const headers = {
+    ...fetchOptions.headers
+  };
+  if (token && !headers["Authorization"]) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (!headers["Content-Type"] && fetchOptions.body && typeof fetchOptions.body === "string") {
+    headers["Content-Type"] = "application/json";
+  }
+  const res = await fetch(url, { ...fetchOptions, headers });
+  if (res.status === 401 && token) {
+    console.warn(`[adas] 401 on ${path} \u2014 attempting refresh`);
+    const outcome = await refreshToken();
+    if (outcome.ok === "ok") {
+      const newToken = getToken();
+      headers["Authorization"] = `Bearer ${newToken}`;
+      const retryRes = await fetch(url, { ...fetchOptions, headers });
+      if (retryRes.ok) {
+        return retryRes.json();
+      }
+      if (retryRes.status === 401 || retryRes.status === 403) {
+        console.warn(`[adas] retry after refresh still ${retryRes.status} on ${path} \u2014 auth failure`);
+        notifyAuthFailure();
+        throw new Error("Session expired");
+      }
+      const text = await retryRes.text().catch(() => "");
+      throw new Error(`API ${retryRes.status}: ${text}`);
+    }
+    if (outcome.ok === "auth_failed") {
+      console.warn(`[adas] refresh auth_failed on ${path} (${outcome.reason}) \u2014 auth failure`);
+      notifyAuthFailure();
+      throw new Error("Session expired");
+    }
+    throw new Error(`API 401: refresh transient (${outcome.reason})`);
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+async function apiFetchRaw(path, options = {}) {
+  const { baseUrl = "core", ...fetchOptions } = options;
+  const base = baseUrl === "voice" ? getVoiceApiUrl() : getCoreApiUrl();
+  const url = `${base}${path}`;
+  const token = getToken();
+  const headers = {
+    ...fetchOptions.headers
+  };
+  if (token && !headers["Authorization"]) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return fetch(url, { ...fetchOptions, headers });
+}
+
+// src/api/mcp.ts
+async function connectorCall(connectorId, tool, args = {}) {
+  try {
+    const res = await apiFetchRaw(
+      `/api/connectors/${encodeURIComponent(connectorId)}/call`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tool, args })
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      return { ok: false, result: null, error: `HTTP ${res.status}: ${text}` };
+    }
+    const data = await res.json();
+    if (data.ok !== void 0) return data;
+    return { ok: true, result: data };
+  } catch (err) {
+    return { ok: false, result: null, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function mcpFetch(body) {
+  const res = await apiFetchRaw("/mcp", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: typeof body === "string" ? body : JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`MCP fetch failed: HTTP ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+async function mcpToolCall(toolName, args = {}) {
+  return mcpFetch({
+    jsonrpc: "2.0",
+    id: Date.now(),
+    method: "tools/call",
+    params: { name: toolName, arguments: args }
+  });
+}
+async function postCommandResult(correlationId, result, error) {
+  await apiFetchRaw("/api/plugin-command-result", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ correlationId, result, error })
+  });
+}
+function unwrapMcpResult(result) {
+  if (!result) return result;
+  if (!result.content) return result;
+  const textItem = Array.isArray(result.content) ? result.content.find((c) => c.type === "text") : null;
+  if (!textItem?.text) return result;
+  try {
+    return JSON.parse(textItem.text);
+  } catch {
+    return textItem.text;
+  }
+}
+
+// src/chat/store.ts
+import { create } from "zustand";
+
+// src/utils/emitter.ts
+var RECENT_TTL_MS = 1e4;
+var RECENT_MAX = 20;
+var PluginCommandEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    // 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.
+    this.recent = [];
+  }
+  on(event, fn) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(fn);
+    return () => this.off(event, fn);
+  }
+  off(event, fn) {
+    this.listeners.get(event)?.delete(fn);
+  }
+  emit(event, data) {
+    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) {
+    const now = Date.now();
+    const out = [];
+    const remaining = [];
+    for (const cmd of this.recent) {
+      if (now - cmd._bufferedAt > RECENT_TTL_MS) continue;
+      if (cmd.pluginId === pluginId) out.push(cmd);
+      else remaining.push(cmd);
+    }
+    this.recent = remaining;
+    return out;
+  }
+};
+var pluginCommandEmitter = new PluginCommandEmitter();
+
+// src/chat/store.ts
+function coreHeaders() {
+  const token = getToken();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return headers;
+}
+function isTerminalStatus(status) {
+  const s = typeof status === "string" ? status.toLowerCase() : "";
+  return s === "done" || s === "error" || s === "failed" || s === "completed";
+}
+function normalizeJobStatus(snap) {
+  const status = typeof snap?.status === "string" ? snap.status.toLowerCase() : "";
+  if (status === "done" || status === "completed") return "done";
+  if (status === "error" || status === "failed") return "error";
+  if (status === "paused" || status === "waiting") return "paused";
+  if (status === "unknown") return "unknown";
+  return "running";
+}
+function extractPendingQuestion(snap) {
+  return snap?.pendingQuestion || snap?.state?.pendingQuestion || snap?.state?.waiting || null;
+}
+function extractActorId(snap) {
+  const actorId = snap?.actorId || snap?.actor?.actorId || snap?.actor?.id || snap?.state?.actorId || snap?.state?.actor?.actorId || snap?.state?.actor?.id;
+  return typeof actorId === "string" && actorId.length > 0 ? actorId : void 0;
+}
+function extractLiveProgress(snap) {
+  const lp = snap?.liveProgress || snap?.state?.__live_progress;
+  const latest = Array.isArray(lp) ? lp[lp.length - 1] : lp;
+  if (!latest?.message) return void 0;
+  return {
+    message: String(latest.message || ""),
+    ...latest.step != null ? { step: latest.step } : {},
+    ...latest.total != null ? { total: latest.total } : {}
+  };
+}
+function extractCurrentTool(state) {
+  const exec = state?.steps?.__exec;
+  if (!exec || typeof exec !== "object") return void 0;
+  const latest = Object.keys(exec).map((k) => ({ k, n: parseInt(k.replace("iter_", ""), 10) })).filter(({ n }) => !isNaN(n)).sort((a, b) => b.n - a.n)[0];
+  if (!latest) return void 0;
+  const steps = exec[latest.k];
+  if (!Array.isArray(steps) || !steps.length) return void 0;
+  const last = steps[steps.length - 1];
+  return last?.tool || last?.phase;
+}
+function snapshotToProgress(snap, rootJobId) {
+  const pq = extractPendingQuestion(snap);
+  const progress = {
+    jobId: rootJobId,
+    actorId: extractActorId(snap),
+    status: pq ? "paused" : normalizeJobStatus(snap),
+    subStatus: snap?.subStatus || snap?.phase || snap?.state?.visual?.phase,
+    phase: snap?.phase || snap?.state?.visual?.phase,
+    iteration: snap?.iteration || snap?.state?.plannerIter,
+    skillSlug: snap?.skillSlug || snap?.activeSkill,
+    currentTool: snap?.currentTool || snap?.lastTool || extractCurrentTool(snap?.state)
+  };
+  const liveProgress = extractLiveProgress(snap);
+  if (liveProgress) progress.liveProgress = liveProgress;
+  if (pq) {
+    progress.pendingQuestion = {
+      inputId: pq.correlation_id || pq.correlationId || pq.inputId || "",
+      question: pq.prompt_message || pq.question || "The assistant needs your input",
+      inputType: pq.inputType || "text",
+      options: pq.options || pq.requested_fields,
+      placeholder: pq.placeholder
+    };
+  }
+  return progress;
+}
+function isTerminalSnapshot(snap) {
+  if (extractPendingQuestion(snap)) return false;
+  return snap?.done === true || isTerminalStatus(snap?.status);
+}
+var TABLE_BLOCK_OPEN = "\uE100";
+var TABLE_BLOCK_CLOSE = "\uE101";
+function renderTableShape(content) {
+  if (!content || typeof content !== "object") return null;
+  const cols = Array.isArray(content.columns) ? content.columns : null;
+  const rows = Array.isArray(content.rows) ? content.rows : null;
+  if (!cols || !rows) return null;
+  const payload = encodeURIComponent(JSON.stringify({ columns: cols, rows }));
+  return `${TABLE_BLOCK_OPEN}${payload}${TABLE_BLOCK_CLOSE}`;
+}
+function blocksToText(blocks) {
+  if (!blocks || blocks.length === 0) return "";
+  return blocks.map((b) => {
+    if (b.kind === "text" || b.kind === "markdown" || b.kind === "description") {
+      return typeof b.content === "string" ? b.content : "";
+    }
+    if (b.kind === "code") {
+      const code = typeof b.content === "object" ? b.content.content : b.content;
+      return `\`\`\`
+${code}
+\`\`\``;
+    }
+    if (b.kind === "table" && b.content && typeof b.content === "object") {
+      const md = renderTableShape(b.content);
+      if (md) return md;
+    }
+    if (b.kind === "json") {
+      if (b.content && typeof b.content === "object" && "pendingQuestion" in b.content) return "";
+      const md = renderTableShape(b.content);
+      if (md) return md;
+      return "```json\n" + JSON.stringify(b.content, null, 2) + "\n```";
+    }
+    if (b.kind === "html") {
+      return typeof b.content === "string" ? b.content : "";
+    }
+    return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+  }).filter(Boolean).join("\n\n");
+}
+function blocksToAttachments(blocks) {
+  if (!blocks || blocks.length === 0) return void 0;
+  const atts = [];
+  for (const b of blocks) {
+    if ((b.kind === "image" || b.kind === "file") && (b.url || b.hash)) {
+      atts.push({
+        mimeType: b.mimeType || (b.kind === "image" ? "image/jpeg" : "application/octet-stream"),
+        name: b.name || "attachment",
+        previewUri: b.url ? `${getCoreApiUrl()}${b.url}` : void 0
+      });
+    }
+  }
+  return atts.length > 0 ? atts : void 0;
+}
+var useChatStore = create((set, get) => ({
+  messages: [],
+  loading: false,
+  error: null,
+  activeJobId: null,
+  conversationLoaded: false,
+  // -----------------------------------------------------------------------
+  // Load conversation history from Core
+  // GET /api/conversation → array of turns [{user, assistant, jobId, ...}]
+  // -----------------------------------------------------------------------
+  loadConversation: async () => {
+    try {
+      const attachmentCache = getConfig().attachmentCache;
+      await attachmentCache?.ready();
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=20`, {
+        headers: coreHeaders()
+      });
+      if (!res.ok) {
+        console.warn("[adas-chat] Failed to load conversation:", res.status);
+        set({ conversationLoaded: true });
+        return;
+      }
+      const data = await res.json();
+      if (!data.ok || !data.items) {
+        set({ conversationLoaded: true });
+        return;
+      }
+      const items = [...data.items].reverse();
+      const persistedMessages = [];
+      const seenJobIds = /* @__PURE__ */ new Set();
+      for (const turn of items) {
+        if (turn.jobId && seenJobIds.has(turn.jobId)) continue;
+        if (turn.jobId) seenJobIds.add(turn.jobId);
+        const userText = blocksToText(turn.user?.blocks);
+        let userAtts = blocksToAttachments(turn.user?.blocks);
+        if (!userAtts && turn.jobId) {
+          userAtts = attachmentCache?.get(turn.jobId);
+        }
+        const turnChainId = typeof turn.chainId === "string" ? turn.chainId : void 0;
+        if (userText || userAtts) {
+          persistedMessages.push({
+            id: `user-${turn.jobId}`,
+            role: "user",
+            content: userText || "",
+            timestamp: new Date(turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...userAtts ? { attachments: userAtts } : {},
+            ...turnChainId ? { chainId: turnChainId } : {}
+          });
+        }
+        const assistantText = blocksToText(turn.assistant?.blocks);
+        const assistantAtts = blocksToAttachments(turn.assistant?.blocks);
+        const assistantActions = Array.isArray(turn.assistant?.actions) ? turn.assistant.actions : void 0;
+        const turnKind = typeof turn.kind === "string" ? turn.kind : void 0;
+        if (assistantText || assistantAtts || assistantActions?.length) {
+          persistedMessages.push({
+            id: `bot-${turn.jobId}`,
+            role: "assistant",
+            content: assistantText || "",
+            timestamp: new Date(turn.finishedAt || turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...assistantAtts ? { attachments: assistantAtts } : {},
+            ...assistantActions?.length ? { actions: assistantActions } : {},
+            ...turnChainId ? { chainId: turnChainId } : {},
+            ...turnKind ? { kind: turnKind } : {}
+          });
+        }
+      }
+      const current = get().messages;
+      const keptPlaceholders = [];
+      for (const m of current) {
+        if (!m.id.startsWith("job-") || !m.jobProgress || !m.chainId) continue;
+        const matchIdx = persistedMessages.findIndex(
+          (pm) => pm.role === "assistant" && pm.chainId === m.chainId
+        );
+        if (matchIdx >= 0) {
+          const st = m.jobProgress.status;
+          if (st === "running" || st === "paused") {
+            persistedMessages[matchIdx] = { ...persistedMessages[matchIdx], jobProgress: m.jobProgress };
+          }
+        } else {
+          keptPlaceholders.push(m);
+        }
+      }
+      const isLocalUserId = (id) => /^user-\d+$/.test(id);
+      const keptUserBubbles = current.filter((m) => {
+        if (m.role !== "user" || !isLocalUserId(m.id)) return false;
+        if (!m.chainId) return true;
+        return !persistedMessages.some(
+          (pm) => pm.role === "user" && pm.chainId === m.chainId
+        );
+      });
+      const finalMessages = [...persistedMessages, ...keptUserBubbles, ...keptPlaceholders];
+      finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+      let firstRunning = keptPlaceholders.find((m) => m.jobProgress?.status === "running");
+      try {
+        const chainRes = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
+          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
+              };
+              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
+                });
+              }
+              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 = {
+                  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());
+              streamJob(chainId, getTenant(), getToken());
+            }
+          }
+        }
+      } catch {
+      }
+      set({
+        messages: finalMessages,
+        conversationLoaded: true,
+        error: null,
+        activeJobId: firstRunning?.jobProgress?.jobId || null,
+        loading: !!firstRunning
+      });
+    } catch (err) {
+      console.warn("[adas-chat] Error loading conversation:", err.message);
+      set({ conversationLoaded: true });
+    }
+  },
+  // -----------------------------------------------------------------------
+  // Send message via Core API
+  // POST /api/chat { goal } → { jobId } → stream → fetch turn result
+  // -----------------------------------------------------------------------
+  sendMessage: async (text, skillSlug, attachments) => {
+    const userMsg = {
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: text,
+      timestamp: /* @__PURE__ */ new Date(),
+      ...attachments?.length ? {
+        attachments: attachments.map((a) => ({
+          mimeType: a.mimeType,
+          name: a.name,
+          previewUri: a.mimeType.startsWith("image/") ? `data:${a.mimeType};base64,${a.data}` : void 0
+        }))
+      } : {}
+    };
+    set((s) => ({ messages: [...s.messages, userMsg], loading: true, error: null }));
+    try {
+      const actor = getUser();
+      const body = {
+        goal: text,
+        // Opt in to the Chain Additions router (attach/cancel/new while a
+        // chain runs). Backend ignores it where not applicable — safe to send.
+        chainRouting: true,
+        triggerContext: {
+          channel: "mobile",
+          replyContext: { chatId: actor?.actorId || "unknown" }
+        }
+      };
+      if (skillSlug) body.skillSlug = skillSlug;
+      if (attachments?.length) body.attachments = attachments;
+      const res = await fetch(`${getCoreApiUrl()}/api/chat`, {
+        method: "POST",
+        headers: coreHeaders(),
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        let errMsg = `Server error (${res.status})`;
+        try {
+          const text2 = await res.text();
+          if (text2.startsWith("<") || text2.startsWith("<!")) {
+            errMsg = res.status === 502 ? "Server is temporarily unavailable. Please try again." : `Server error (${res.status})`;
+          } else {
+            const parsed = JSON.parse(text2);
+            errMsg = parsed.error || errMsg;
+          }
+        } catch {
+        }
+        throw new Error(errMsg);
+      }
+      const data = await res.json();
+      if (!data.ok) {
+        throw new Error(data.error || "Failed to send message");
+      }
+      if (data.mode === "chain_addition" || data.mode === "chain_cancel") {
+        const ack = data.mode === "chain_addition" ? data.ack || "Got it \u2014 added to the running task." : "Stopping the task\u2026";
+        set((s) => ({
+          messages: s.messages.map((m) => m.id === userMsg.id && data.chainId ? { ...m, chainId: data.chainId } : m).concat({
+            id: `ack-${Date.now()}`,
+            role: "assistant",
+            content: ack,
+            timestamp: /* @__PURE__ */ new Date(),
+            ...data.chainId ? { chainId: data.chainId } : {}
+          })
+        }));
+        return;
+      }
+      const jobId = data.id || data.jobId;
+      if (!jobId) {
+        throw new Error("No job ID returned");
+      }
+      if (attachments?.length) {
+        await getConfig().attachmentCache?.save(jobId, attachments);
+      }
+      const progressMsg = {
+        id: `job-${jobId}`,
+        role: "assistant",
+        content: "Working on it...",
+        timestamp: /* @__PURE__ */ new Date(),
+        jobProgress: {
+          jobId,
+          actorId: actor?.actorId,
+          status: "running",
+          subStatus: "Starting...",
+          chainStartedAt: Date.now()
+        },
+        chainId: jobId
+      };
+      set((s) => ({
+        messages: s.messages.map(
+          (m) => m.id === userMsg.id ? { ...m, chainId: jobId } : m
+        ).concat(progressMsg),
+        activeJobId: jobId
+      }));
+      streamJob(jobId, getTenant(), getToken());
+    } catch (err) {
+      set((s) => ({
+        messages: [...s.messages, {
+          id: `error-${Date.now()}`,
+          role: "system",
+          content: `Error: ${err.message}`,
+          timestamp: /* @__PURE__ */ new Date()
+        }],
+        loading: false
+      }));
+    }
+  },
+  // -----------------------------------------------------------------------
+  // Respond to sys.askUser paused question
+  // -----------------------------------------------------------------------
+  respondToQuestion: async (jobId, inputId, answer) => {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/respond`, {
+        method: "POST",
+        headers: coreHeaders(),
+        body: JSON.stringify({ inputId, answer })
+      });
+      const data = await res.json();
+      if (!data.ok) {
+        console.warn("[adas-chat] Failed to respond to question:", data.error);
+      }
+    } catch (err) {
+      console.warn("[adas-chat] Error responding to question:", err.message);
+    }
+  },
+  // -----------------------------------------------------------------------
+  // Update job progress (called by the stream handler)
+  // -----------------------------------------------------------------------
+  updateJobProgress: (jobId, progress) => {
+    set((s) => ({
+      messages: s.messages.map((m) => {
+        if (m.jobProgress?.jobId === jobId) {
+          const updated = { ...m.jobProgress, ...progress };
+          if (progress.status && progress.status !== "paused") {
+            updated.pendingQuestion = void 0;
+          }
+          const isPersisted = m.id.startsWith("bot-");
+          const content = isPersisted ? m.content : progress.resultMessage || progress.pendingQuestion?.question || m.content;
+          const actions = isPersisted ? m.actions : progress.resultActions?.length ? progress.resultActions : m.actions;
+          return {
+            ...m,
+            jobProgress: updated,
+            content,
+            ...actions ? { actions } : {}
+          };
+        }
+        return m;
+      }),
+      loading: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? false : s.loading,
+      activeJobId: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? null : s.activeJobId
+    }));
+  },
+  clearChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: false
+    });
+  },
+  newChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: true
+    });
+  }
+}));
+var _processedPluginCmds = /* @__PURE__ */ new Set();
+function dispatchPluginCommands(cmds) {
+  for (const cmd of cmds) {
+    const corrId = cmd?.correlationId || cmd?.correlation_id;
+    if (corrId && _processedPluginCmds.has(corrId)) continue;
+    if (corrId) _processedPluginCmds.add(corrId);
+    pluginCommandEmitter.emit("plugin-command", cmd);
+    const pluginId = cmd?.pluginId || cmd?.plugin_id || cmd?.args?.plugin_id;
+    if (pluginId) {
+      const props = cmd?.props ?? cmd?.args?.props ?? void 0;
+      pluginCommandEmitter.emit("focus-plugin", { pluginId, props });
+    }
+  }
+}
+var _ws = null;
+var _wsReady = false;
+var _currentJobId = null;
+function ensureWs(tenant, token) {
+  if (_ws && _wsReady) return _ws;
+  const wsUrl = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(token || "")}&tenant=${encodeURIComponent(tenant)}`;
+  const ws = new WebSocket(wsUrl);
+  _ws = ws;
+  _wsReady = false;
+  ws.onopen = () => {
+    _wsReady = true;
+    if (_currentJobId) {
+      ws.send(JSON.stringify({ type: "subscribe", jobId: _currentJobId }));
+    }
+  };
+  ws.onmessage = (ev) => {
+    try {
+      const msg = JSON.parse(typeof ev.data === "string" ? ev.data : "");
+      const { event, data } = msg;
+      const { updateJobProgress } = useChatStore.getState();
+      const jobId = data && (data.id || data.chainId) || _currentJobId;
+      if (event === "plugin_command") {
+        dispatchPluginCommands([data]);
+        return;
+      }
+      if (event === "plugin-command-ack" || event === "pong") return;
+      if (!jobId) return;
+      switch (event) {
+        case "init":
+        case "job":
+        case "update": {
+          const snap = data;
+          const progress = snapshotToProgress(snap, jobId);
+          if (isTerminalSnapshot(snap)) {
+            if (snap.status === "done" && (snap.isHandoff || snap.state?.handoffTransfer)) {
+              updateJobProgress(jobId, { status: "running" });
+              return;
+            }
+            _currentJobId = null;
+            if (progress.status === "paused" && progress.pendingQuestion) {
+              updateJobProgress(jobId, progress);
+            } else {
+              fetchTurnResult(jobId, snap);
+            }
+            return;
+          }
+          updateJobProgress(jobId, progress);
+          break;
+        }
+        case "chain_final":
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+        case "final":
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+      }
+    } catch (err) {
+      console.warn("[adas-chat] WS parse error:", err);
+    }
+  };
+  ws.onerror = () => {
+    _ws = null;
+    _wsReady = false;
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
+  };
+  ws.onclose = () => {
+    _ws = null;
+    _wsReady = false;
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
+  };
+  return ws;
+}
+function streamJob(jobId, tenant, token) {
+  _currentJobId = jobId;
+  const ws = ensureWs(tenant, token);
+  if (_wsReady) {
+    ws.send(JSON.stringify({ type: "subscribe", jobId }));
+  }
+}
+function closeChatStream() {
+  _currentJobId = null;
+  if (_ws) {
+    try {
+      _ws.close();
+    } catch {
+    }
+  }
+  _ws = null;
+  _wsReady = false;
+}
+async function fetchTurnResult(jobId, jobSnap) {
+  if (_processedPluginCmds.size > 200) _processedPluginCmds.clear();
+  const { updateJobProgress } = useChatStore.getState();
+  const status = normalizeJobStatus(jobSnap) === "error" ? "error" : "done";
+  if (jobSnap.isHandoff || jobSnap.state?.handoffTransfer || jobSnap.result?.contentType === "handoff") {
+    try {
+      for (let i = 0; i < 40; i++) {
+        const statusRes = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+          headers: coreHeaders()
+        });
+        if (statusRes.ok) {
+          const statusData = await statusRes.json();
+          if (statusData.done && !statusData.isHandoff) {
+            break;
+          }
+          updateJobProgress(jobId, { status: "running" });
+        }
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+    } catch {
+    }
+  }
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=1`, {
+        headers: coreHeaders()
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const items = Array.isArray(data.items) ? data.items : [];
+        const turn = items[0];
+        if (turn?.assistant || turn?.turn?.assistant) {
+          const assistant = turn.assistant || turn.turn?.assistant;
+          const text = blocksToText(assistant.blocks);
+          const actions = Array.isArray(assistant.actions) && assistant.actions.length ? assistant.actions : void 0;
+          if (text) {
+            updateJobProgress(jobId, {
+              status,
+              resultMessage: text,
+              ...actions ? { resultActions: actions } : {}
+            });
+            return;
+          }
+        }
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 800));
+  }
+  const fallback = jobSnap.result?.message || jobSnap.state?.finalReply || (status === "error" ? "Something went wrong. Please try again." : "Done.");
+  updateJobProgress(jobId, { status, resultMessage: fallback });
+}
+async function pollJob(jobId, token) {
+  const { updateJobProgress } = useChatStore.getState();
+  for (let i = 0; i < 120; i++) {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+        headers: {
+          ...token ? { Authorization: `Bearer ${token}` } : {}
+        }
+      });
+      if (!res.ok) {
+        if (res.status === 404) return;
+        continue;
+      }
+      const snap = await res.json();
+      const progress = snapshotToProgress(snap, jobId);
+      if (progress.status === "paused" && progress.pendingQuestion) {
+        updateJobProgress(jobId, progress);
+        return;
+      }
+      updateJobProgress(jobId, progress);
+      if (isTerminalSnapshot(snap)) {
+        fetchTurnResult(jobId, snap);
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  updateJobProgress(jobId, {
+    status: "error",
+    resultMessage: "Job timed out. Please try again."
+  });
+}
+
+// src/theme/tokens.ts
+var 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)"
+  }
+};
+var 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"
+};
+var spacing = {
+  xs: 4,
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  xxl: 24,
+  xxxl: 32
+};
+var fontSize = {
+  xs: 11,
+  sm: 13,
+  md: 15,
+  lg: 17,
+  xl: 20,
+  xxl: 24,
+  title: 28
+};
+var borderRadius = {
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  full: 9999
+};
+export {
+  PluginCommandEmitter,
+  TABLE_BLOCK_CLOSE,
+  TABLE_BLOCK_OPEN,
+  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
+};
+//# sourceMappingURL=index.mjs.map