@blade-hq/agent-kit 0.4.5 → 0.4.7

package/dist/react/api/licenses.js

@@ -1,1473 +1,14 @@
-// src/client/resources/models.ts
-import { type } from "arktype";
-var ModelOption = type({
-  id: "string",
-  label: "string"
-});
-var ModelsConfig = type({
-  default: "string",
-  models: ModelOption.array()
-});
-
-// src/client/socket.ts
-import { io } from "socket.io-client";
-
-// src/react/schemas/partner-skill.ts
-import { type as type2 } from "arktype";
-var PartnerSkillName = type2("/^[a-z0-9-]+\\/[a-z0-9-]+$/");
-var PartnerSkillFile = type2({
-  path: "string > 0",
-  content: "string"
-});
-var PartnerSkillInstallPayload = type2({
-  name: PartnerSkillName,
-  files: PartnerSkillFile.array().atLeastLength(1)
-});
-var PartnerSkillInstallResult = type2({
-  name: PartnerSkillName,
-  skill_dir: "string",
-  file_count: "number.integer >= 0",
-  overwritten: "boolean"
-});
-
-// src/react/stores/ui-bridge-store.ts
-import { create } from "zustand";
-
-// src/react/stores/client-aware.ts
-function createClientActions(set) {
-  return {
-    _client: null,
-    setClient: (client) => set({ _client: client })
-  };
-}
-
-// src/react/stores/ui-bridge-store.ts
-function buildSignalId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `bridge-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
-function clearSignalRecord(record, sessionId) {
-  if (!(sessionId in record)) {
-    return record;
-  }
-  const next = { ...record };
-  delete next[sessionId];
-  return next;
-}
-var useUiBridgeStore = create()((set, get) => ({
-  ...createClientActions(set),
-  pendingContexts: {},
-  draftAppends: {},
-  sendRequests: {},
-  addPendingContext: (sessionId, context) => set((state) => ({
-    pendingContexts: {
-      ...state.pendingContexts,
-      [sessionId]: [
-        ...state.pendingContexts[sessionId] ?? [],
-        {
-          id: buildSignalId(),
-          label: context.label,
-          content: context.content
-        }
-      ]
-    }
-  })),
-  removePendingContext: (sessionId, contextId) => set((state) => {
-    const contexts = state.pendingContexts[sessionId];
-    if (!contexts?.length) {
-      return state;
-    }
-    const nextContexts = contexts.filter((context) => context.id !== contextId);
-    if (nextContexts.length === contexts.length) {
-      return state;
-    }
-    return {
-      pendingContexts: nextContexts.length > 0 ? {
-        ...state.pendingContexts,
-        [sessionId]: nextContexts
-      } : clearSignalRecord(state.pendingContexts, sessionId)
-    };
-  }),
-  consumePendingContexts: (sessionId) => {
-    const signals = get().pendingContexts[sessionId] ?? [];
-    if (signals.length === 0) return [];
-    set((state) => ({
-      pendingContexts: clearSignalRecord(state.pendingContexts, sessionId)
-    }));
-    return signals;
-  },
-  clearPendingContexts: (sessionId) => set((state) => ({
-    pendingContexts: clearSignalRecord(state.pendingContexts, sessionId)
-  })),
-  addDraftAppend: (sessionId, text) => set((state) => ({
-    draftAppends: {
-      ...state.draftAppends,
-      [sessionId]: [
-        ...state.draftAppends[sessionId] ?? [],
-        {
-          id: buildSignalId(),
-          text
-        }
-      ]
-    }
-  })),
-  consumeDraftAppends: (sessionId) => {
-    const signals = get().draftAppends[sessionId] ?? [];
-    if (signals.length === 0) return [];
-    set((state) => ({
-      draftAppends: clearSignalRecord(state.draftAppends, sessionId)
-    }));
-    return signals;
-  },
-  clearDraftAppends: (sessionId) => set((state) => ({
-    draftAppends: clearSignalRecord(state.draftAppends, sessionId)
-  })),
-  addSendRequest: (sessionId) => set((state) => ({
-    sendRequests: {
-      ...state.sendRequests,
-      [sessionId]: [
-        ...state.sendRequests[sessionId] ?? [],
-        {
-          id: buildSignalId()
-        }
-      ]
-    }
-  })),
-  consumeSendRequests: (sessionId) => {
-    const signals = get().sendRequests[sessionId] ?? [];
-    if (signals.length === 0) return [];
-    set((state) => ({
-      sendRequests: clearSignalRecord(state.sendRequests, sessionId)
-    }));
-    return signals;
-  },
-  clearSendRequests: (sessionId) => set((state) => ({
-    sendRequests: clearSignalRecord(state.sendRequests, sessionId)
-  })),
-  clearSession: (sessionId) => set((state) => ({
-    pendingContexts: clearSignalRecord(state.pendingContexts, sessionId),
-    draftAppends: clearSignalRecord(state.draftAppends, sessionId),
-    sendRequests: clearSignalRecord(state.sendRequests, sessionId)
-  }))
-}));
-
-// src/react/lib/chat.ts
-function normalizeMessageContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) return content;
-  return String(content ?? "");
-}
-
-// src/react/stores/auth-store.ts
-import { create as create6 } from "zustand";
-import { createJSONStorage, persist } from "zustand/middleware";
-
-// src/react/api/auth.ts
-var r = () => getClient().auth;
-var getMe = (...args) => r().getMe(...args);
-var logout = (...args) => r().logout(...args);
-
-// src/react/sockets/socket-state.ts
-var agentSocket = null;
-
-// src/react/stores/session-store.ts
-import { create as create5 } from "zustand";
-
-// src/react/api/sessions.ts
-var r2 = () => getClient().sessions;
-var listSessions = (...args) => r2().listSessions(...args);
-var createSession = (...args) => r2().createSession(...args);
-var getSession = (...args) => r2().getSession(...args);
-var pinSession = (...args) => r2().pinSession(...args);
-var updateSharing = (...args) => r2().updateSharing(...args);
-var getSessionTasks = (...args) => r2().getSessionTasks(...args);
-var getSessionTurns = (...args) => r2().getSessionTurns(...args);
-var deleteSession = (...args) => r2().deleteSession(...args);
-
-// src/react/stores/chat-store.ts
-import { create as create3 } from "zustand";
-
-// src/react/components/chat/display-utils.ts
-var TOOL_NAME_ALIASES = {
-  agent: "Agent",
-  ask_user_question: "AskUserQuestion",
-  bash: "Bash",
-  bg_bash: "BgBash",
-  edit: "Edit",
-  exit_plan_mode: "ExitPlanMode",
-  file_edit: "Edit",
-  file_read: "Read",
-  file_write: "Write",
-  finish_task: "FinishTask",
-  get_skill_content: "GetSkillContent",
-  glob: "Glob",
-  grep: "Grep",
-  list_skill_tools: "ListSkillTools",
-  load_skill_tools: "LoadSkillTools",
-  ls: "Ls",
-  read: "Read",
-  run_skill_tool: "RunSkillTool",
-  search_skills: "SearchSkills",
-  web_fetch: "WebFetch",
-  web_search: "WebSearch",
-  write: "Write"
-};
-var TOOL_DISPLAY_LABELS = {
-  Bash: "\u6267\u884C\u547D\u4EE4",
-  BgBash: "\u540E\u53F0\u6267\u884C\u547D\u4EE4",
-  Read: "\u8BFB\u53D6\u6587\u4EF6",
-  Write: "\u5199\u5165\u6587\u4EF6",
-  Edit: "\u7F16\u8F91\u6587\u4EF6",
-  Ls: "\u5217\u51FA\u76EE\u5F55",
-  Glob: "\u5339\u914D\u6587\u4EF6",
-  Grep: "\u641C\u7D22\u6587\u672C",
-  WebSearch: "\u641C\u7D22\u7F51\u9875",
-  WebFetch: "\u6574\u7406\u7F51\u9875\u5185\u5BB9",
-  Agent: "\u6D3E\u751F\u5B50\u667A\u80FD\u4F53",
-  AskUserQuestion: "\u5411\u7528\u6237\u63D0\u95EE",
-  SearchSkills: "\u641C\u7D22\u6280\u80FD",
-  GetSkillContent: "\u8BFB\u53D6\u6280\u80FD",
-  ListSkillTools: "\u67E5\u770B\u5DE5\u5177\u5217\u8868",
-  LoadSkillTools: "\u52A0\u8F7D\u6280\u80FD",
-  RunSkillTool: "\u6267\u884C\u6280\u80FD\u5DE5\u5177",
-  FinishTask: "\u4EFB\u52A1\u5B8C\u6210",
-  ExitPlanMode: "\u63D0\u4EA4\u8BA1\u5212",
-  ListSessions: "\u5217\u51FA\u5386\u53F2\u4F1A\u8BDD",
-  GetSessionHistory: "\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2"
-};
-var GENERIC_DISPLAY_NAMES = new Set(Object.values(TOOL_DISPLAY_LABELS));
-function formatToolName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) return name;
-  const stripped = trimmed.split(":").pop()?.split("/").pop()?.split(".").pop()?.trim() || trimmed;
-  const normalized = stripped.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
-  return TOOL_NAME_ALIASES[normalized] ?? stripped;
-}
-
-// src/react/stores/ui-store.ts
-import { create as create2 } from "zustand";
-var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-function resolveEffectiveTheme(theme) {
-  if (theme !== "system") return theme;
-  return isBrowser && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-}
-function applyTheme(theme) {
-  if (!isBrowser) return;
-  const effective = resolveEffectiveTheme(theme);
-  document.documentElement.setAttribute("data-theme", effective);
-}
-var storedTheme = isBrowser ? localStorage.getItem("blade-theme") ?? "light" : "light";
-applyTheme(storedTheme);
-if (isBrowser) {
-  window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
-    const current = useUiStore?.getState?.()?.theme;
-    if (current === "system") applyTheme("system");
-  });
-}
-function removeArtifactAtIndex(state, index) {
-  const next = state.artifacts.filter((_, i) => i !== index);
-  let nextActive = state.activeArtifactIndex;
-  if (next.length === 0) {
-    return { artifacts: [], activeArtifactIndex: -1, rightPanelCollapsed: true };
-  }
-  if (index < nextActive) {
-    nextActive -= 1;
-  } else if (index === nextActive) {
-    nextActive = Math.min(index, next.length - 1);
-  }
-  return { artifacts: next, activeArtifactIndex: nextActive };
-}
-function upsertArtifactState(state, target, options) {
-  const reveal = options?.reveal ?? true;
-  const activate = options?.activate ?? true;
-  const targetKey = target.key ?? target.title;
-  const applyUiState = (partial) => ({
-    ...partial,
-    ...reveal ? { rightPanelCollapsed: false, activeRightTab: "preview" } : {}
-  });
-  const existing = state.artifacts.findIndex((artifact) => targetKey && (artifact.key ?? artifact.title) === targetKey);
-  if (existing >= 0) {
-    const updated = [...state.artifacts];
-    updated[existing] = target;
-    return applyUiState({
-      artifacts: updated,
-      activeArtifactIndex: activate ? existing : state.activeArtifactIndex
-    });
-  }
-  const next = [...state.artifacts, target];
-  return applyUiState({
-    artifacts: next,
-    activeArtifactIndex: activate ? next.length - 1 : state.activeArtifactIndex >= 0 ? state.activeArtifactIndex : 0
-  });
-}
-var useUiStore = create2()((set) => ({
-  ...createClientActions(set),
-  leftPanelSize: 20,
-  rightPanelSize: 25,
-  leftPanelCollapsed: false,
-  rightPanelCollapsed: false,
-  activeRightTab: "situation",
-  artifacts: [],
-  activeArtifactIndex: -1,
-  theme: storedTheme,
-  setLeftPanelSize: (size) => set({ leftPanelSize: size }),
-  setRightPanelSize: (size) => set({ rightPanelSize: size }),
-  setLeftPanelCollapsed: (collapsed) => set({ leftPanelCollapsed: collapsed }),
-  setRightPanelCollapsed: (collapsed) => set({ rightPanelCollapsed: collapsed }),
-  toggleLeftPanel: () => set((s) => ({ leftPanelCollapsed: !s.leftPanelCollapsed })),
-  toggleRightPanel: () => set((s) => ({ rightPanelCollapsed: !s.rightPanelCollapsed })),
-  setActiveRightTab: (tab) => set({ activeRightTab: tab }),
-  pushArtifact: (target) => set((state) => upsertArtifactState(state, target)),
-  upsertArtifact: (target, options) => set((state) => upsertArtifactState(state, target, options)),
-  setActiveArtifact: (index) => set({ activeArtifactIndex: index }),
-  closeArtifact: (index) => set((state) => removeArtifactAtIndex(state, index)),
-  removeArtifactByKey: (key) => set((state) => {
-    const index = state.artifacts.findIndex((artifact) => (artifact.key ?? artifact.title) === key);
-    if (index < 0) return state;
-    return removeArtifactAtIndex(state, index);
-  }),
-  clearArtifacts: () => set({ artifacts: [], activeArtifactIndex: -1 }),
-  setPreviewTarget: (target) => set(() => {
-    if (target === null) {
-      return { artifacts: [], activeArtifactIndex: -1 };
-    }
-    return {
-      artifacts: [target],
-      activeArtifactIndex: 0,
-      rightPanelCollapsed: false,
-      activeRightTab: "preview"
-    };
-  }),
-  setTheme: (theme) => {
-    localStorage.setItem("blade-theme", theme);
-    applyTheme(theme);
-    set({ theme });
-  }
-}));
-
-// src/react/stores/chat-store.ts
-var _getActiveSessionId = null;
-function setChatStoreSessionAccessor(fn) {
-  _getActiveSessionId = fn;
-}
-function parseAgentDescription(argumentsJson) {
-  try {
-    return JSON.parse(argumentsJson)?.description ?? "\u5B50\u667A\u80FD\u4F53";
-  } catch {
-    return "\u5B50\u667A\u80FD\u4F53";
-  }
-}
-function inferLoopStatusFromMessages(messages) {
-  const toolCalls = messages.flatMap((message) => message.tool_calls ?? []);
-  if (messages.some((message) => message.status === "streaming")) return "running";
-  if (toolCalls.some((toolCall) => toolCall.status === "awaiting_answer")) return "awaiting_answer";
-  if (toolCalls.some((toolCall) => toolCall.status === "error")) return "error";
-  if (toolCalls.some((toolCall) => toolCall.status === "cancelled")) return "cancelled";
-  if (toolCalls.some((toolCall) => toolCall.status === "pending")) return "running";
-  return "done";
-}
-function inferLoopStatusFromTurns(turns, messages) {
-  const latestAgentNotification = [...turns].reverse().flatMap((turn) => turn.blocks).find((block) => {
-    if (block.type !== "system_notification" || !isRecord(block.content)) return false;
-    return block.content.notification_type === "agent:start" || block.content.notification_type === "agent:end";
-  });
-  if (latestAgentNotification?.type === "system_notification" && isRecord(latestAgentNotification.content)) {
-    const notificationType = latestAgentNotification.content.notification_type;
-    const status = latestAgentNotification.content.status;
-    if (notificationType === "agent:start" || status === "running") return "running";
-    if (status === "error") return "error";
-    if (status === "cancelled") return "cancelled";
-  }
-  return inferLoopStatusFromMessages(messages);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parentForkToolCallIdFromTurn(turn) {
-  if (typeof turn.parent_fork_tool_call_id === "string" && turn.parent_fork_tool_call_id.length > 0) {
-    return turn.parent_fork_tool_call_id;
-  }
-  for (const block of turn.blocks) {
-    if (block.type !== "system_notification" || !isRecord(block.content)) continue;
-    const metadata = block.content.metadata;
-    if (!isRecord(metadata)) continue;
-    const parentId = metadata.parent_fork_tool_call_id;
-    if (typeof parentId === "string" && parentId.length > 0) return parentId;
-  }
-  return null;
-}
-function buildMessageContent(turn) {
-  const textBlocks = turn.blocks.filter((block) => block.type === "text");
-  if (textBlocks.length === 0) return "";
-  if (textBlocks.length === 1) return normalizeMessageContent(textBlocks[0].content);
-  return textBlocks.map((block) => {
-    if (typeof block.content === "string") return block.content;
-    return JSON.stringify(block.content);
-  }).join("");
-}
-function buildReasoning(turn) {
-  const thinking = turn.blocks.filter((block) => block.type === "thinking").map((block) => typeof block.content === "string" ? block.content : JSON.stringify(block.content)).filter(Boolean);
-  if (thinking.length === 0) return void 0;
-  return thinking.join("\n\n");
-}
-function isModeChangeContent(value) {
-  return typeof value === "object" && value !== null && typeof value.from === "string" && typeof value.to === "string";
-}
-function extractModeFromBlocks(blocks) {
-  const modeBlock = blocks.find((block) => block.type === "mode_change");
-  if (modeBlock && isModeChangeContent(modeBlock.content)) {
-    return modeBlock.content.to === "planning" || modeBlock.content.to === "executing" ? modeBlock.content.to : null;
-  }
-  if (blocks.some((block) => block.type === "planning_enter")) return "planning";
-  if (blocks.some((block) => block.type === "planning_exit")) return "executing";
-  return null;
-}
-function projectionToMessage(turn) {
-  if (turn.kind === "compaction" && turn.compaction_id) {
-    return {
-      role: "assistant",
-      content: turn.summary_preview ?? "",
-      kind: "compaction",
-      loop_name: turn.loop_id,
-      entry_id: turn.turn_id,
-      status: turn.status,
-      compaction: {
-        compaction_id: turn.compaction_id,
-        summary_preview: turn.summary_preview,
-        summary_full: turn.summary_full,
-        archived_count: turn.archived_count,
-        archived_files: turn.archived_files,
-        archived_tool_calls: turn.archived_tool_calls,
-        tokens_before: turn.tokens_before,
-        tokens_after: turn.tokens_after,
-        saved_ratio: turn.saved_ratio,
-        trigger: turn.trigger,
-        failure_reason: turn.failure_reason,
-        fallback_applied: turn.fallback_applied
-      }
-    };
-  }
-  const planningBlock = turn.blocks.find(
-    (block) => block.type === "mode_change" || block.type === "planning_enter" || block.type === "planning_exit" || block.type === "plan_status"
-  );
-  if (planningBlock) {
-    if (planningBlock.type === "plan_status") {
-      return {
-        role: "tool",
-        content: typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}, null, 2),
-        kind: "plan_status",
-        loop_name: turn.loop_id,
-        entry_id: turn.turn_id,
-        status: turn.status
-      };
-    }
-    return {
-      role: "assistant",
-      content: planningBlock.type === "mode_change" ? typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}) : "",
-      kind: planningBlock.type,
-      loop_name: turn.loop_id,
-      entry_id: turn.turn_id,
-      status: turn.status
-    };
-  }
-  if (turn.blocks.some((block) => block.type === "ask_user_answer")) {
-    return null;
-  }
-  const content = buildMessageContent(turn);
-  const reasoning = buildReasoning(turn);
-  const toolCalls = turn.tool_calls.length > 0 ? turn.tool_calls.map((toolCall) => ({
-    id: toolCall.id,
-    name: toolCall.tool_name,
-    display_name: toolCall.display_name,
-    arguments: toolCall.arguments,
-    result: toolCall.result ?? void 0,
-    pending_question_ref: toolCall.pending_question_ref ?? void 0,
-    status: toolCall.status === "pending" || toolCall.status === "awaiting_answer" || toolCall.status === "done" || toolCall.status === "error" || toolCall.status === "cancelled" ? toolCall.status : "pending",
-    ...typeof toolCall.duration_ms === "number" ? { duration_ms: toolCall.duration_ms } : {}
-  })) : void 0;
-  if (turn.role === "system" && !content && !toolCalls?.length) {
-    return null;
-  }
-  return {
-    role: turn.role === "system" ? "assistant" : turn.role,
-    content,
-    blocks: turn.blocks,
-    ...reasoning ? { reasoning } : {},
-    ...toolCalls ? { tool_calls: toolCalls } : {},
-    loop_name: turn.loop_id,
-    entry_id: turn.turn_id,
-    status: turn.status,
-    ...typeof turn.duration_ms === "number" ? { duration_ms: turn.duration_ms } : {},
-    ...turn.started_at ? { timestamp: turn.started_at } : {},
-    ...turn.memory_refs?.length ? { memory_refs: turn.memory_refs } : {}
-  };
-}
-function rebuildAgentLoops(turns) {
-  const messages = turns.map(projectionToMessage).filter(Boolean);
-  const childLoopNames = [...new Set(turns.map((turn) => turn.loop_id).filter((name) => name !== "root"))];
-  if (childLoopNames.length === 0) return {};
-  const agentToolCalls = messages.filter((message) => message.role === "assistant" && (message.loop_name ?? "root") === "root").flatMap((message) => message.tool_calls ?? []).filter((toolCall) => formatToolName(toolCall.name) === "Agent");
-  const loops = {};
-  const agentToolCallsById = new Map(agentToolCalls.map((toolCall) => [toolCall.id, toolCall]));
-  const explicitParentToolCallIds = new Set(
-    turns.map(parentForkToolCallIdFromTurn).filter((id) => id !== null)
-  );
-  const usedToolCallIds = /* @__PURE__ */ new Set();
-  for (const loopName of childLoopNames) {
-    const loopMessages = messages.filter((message) => (message.loop_name ?? "root") === loopName);
-    const loopTurns = turns.filter((turn) => turn.loop_id === loopName);
-    const parentToolCallId = loopTurns.map(parentForkToolCallIdFromTurn).find(Boolean);
-    const explicitToolCall = parentToolCallId && !usedToolCallIds.has(parentToolCallId) ? agentToolCallsById.get(parentToolCallId) ?? null : null;
-    const fallbackToolCall = explicitToolCall === null ? agentToolCalls.find(
-      (toolCall2) => !usedToolCallIds.has(toolCall2.id) && !explicitParentToolCallIds.has(toolCall2.id)
-    ) : null;
-    const toolCall = explicitToolCall ?? fallbackToolCall;
-    if (!toolCall) continue;
-    usedToolCallIds.add(toolCall.id);
-    loops[loopName] = {
-      toolCallId: toolCall.id,
-      description: parseAgentDescription(toolCall.arguments),
-      status: inferLoopStatusFromTurns(loopTurns, loopMessages)
-    };
-  }
-  return loops;
-}
-function applyPlanningSideEffects(sessionId, turns) {
-  const latestMode = [...turns].reverse().map((turn) => extractModeFromBlocks(turn.blocks)).find((mode) => mode !== null);
-  if (latestMode !== "planning") return;
-  if (_getActiveSessionId?.() !== sessionId) return;
-  const ui = useUiStore.getState();
-  ui.setActiveRightTab("situation");
-  if (ui.rightPanelCollapsed) {
-    ui.toggleRightPanel();
-  }
-}
-function materialize(turns) {
-  const messages = turns.map(projectionToMessage).filter((message) => message !== null);
-  const activeCompaction = [...turns].reverse().find(
-    (turn) => turn.kind === "compaction" && turn.status === "streaming" && typeof turn.compaction_id === "string"
-  );
-  return {
-    messages,
-    agentLoops: rebuildAgentLoops(turns),
-    activeCompaction: activeCompaction ? {
-      turn_id: activeCompaction.turn_id,
-      status: activeCompaction.status,
-      compaction_id: activeCompaction.compaction_id,
-      summary_preview: activeCompaction.summary_preview,
-      summary_full: activeCompaction.summary_full,
-      archived_count: activeCompaction.archived_count,
-      archived_files: activeCompaction.archived_files,
-      archived_tool_calls: activeCompaction.archived_tool_calls,
-      tokens_before: activeCompaction.tokens_before,
-      tokens_after: activeCompaction.tokens_after,
-      saved_ratio: activeCompaction.saved_ratio,
-      trigger: activeCompaction.trigger,
-      failure_reason: activeCompaction.failure_reason,
-      fallback_applied: activeCompaction.fallback_applied
-    } : null
-  };
-}
-var ERROR_ANCHOR_PREFIX = "error-anchor:";
-function updateSessionState(state, sessionId, turns) {
-  const orderedTurns = [...turns].sort((left, right) => left.sequence - right.sequence);
-  const { messages, agentLoops, activeCompaction } = materialize(orderedTurns);
-  applyPlanningSideEffects(sessionId, orderedTurns);
-  const lastTurnId = orderedTurns[orderedTurns.length - 1]?.turn_id ?? null;
-  const preservedErrors = lastTurnId ? (state.messages[sessionId] ?? []).filter(
-    (m) => m.role === "error" && typeof m.entry_id === "string" && m.entry_id.startsWith(`${ERROR_ANCHOR_PREFIX}${lastTurnId}:`)
-  ) : [];
-  const mergedMessages = preservedErrors.length > 0 ? [...messages, ...preservedErrors] : messages;
-  return {
-    turns: { ...state.turns, [sessionId]: orderedTurns },
-    messages: { ...state.messages, [sessionId]: mergedMessages },
-    agentLoops: { ...state.agentLoops, [sessionId]: agentLoops },
-    activeCompactions: { ...state.activeCompactions, [sessionId]: activeCompaction }
-  };
-}
-var useChatStore = create3()((set) => ({
-  ...createClientActions(set),
-  turns: {},
-  messages: {},
-  askAnswers: {},
-  isStreaming: {},
-  agentLoops: {},
-  activeCompactions: {},
-  addUserMessage: (sessionId, content) => {
-    set((state) => {
-      const existing = state.turns[sessionId] ?? [];
-      const turnId = `local-user-${Date.now()}`;
-      const optimisticTurn = {
-        id: turnId,
-        sequence: Math.max(0, ...existing.map((turn) => turn.sequence)) + 1,
-        turn_id: turnId,
-        loop_id: "root",
-        role: "user",
-        status: "completed",
-        blocks: [{ type: "text", content }],
-        tool_calls: [],
-        model: null,
-        usage: null,
-        duration_ms: 0
-      };
-      return updateSessionState(state, sessionId, [...existing, optimisticTurn]);
-    });
-  },
-  setTurns: (sessionId, turns) => {
-    set((state) => updateSessionState(state, sessionId, [...turns]));
-  },
-  upsertTurn: (sessionId, turn) => {
-    set((state) => {
-      const existing = [...state.turns[sessionId] ?? []];
-      const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
-      if (index >= 0) {
-        existing[index] = turn;
-      } else {
-        existing.push(turn);
-      }
-      return {
-        ...updateSessionState(state, sessionId, existing)
-      };
-    });
-  },
-  applyTurnPatch: (sessionId, patch) => {
-    set((state) => {
-      const turn = patch.data.turn;
-      if (!turn) return state;
-      const existing = [...state.turns[sessionId] ?? []];
-      const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
-      const lastSequence = index >= 0 ? existing[index].sequence : null;
-      if (lastSequence !== null && patch.sequence <= lastSequence) {
-        return state;
-      }
-      const nextTurn = {
-        ...turn,
-        sequence: patch.sequence
-      };
-      if (index >= 0) {
-        existing[index] = nextTurn;
-      } else {
-        existing.push(nextTurn);
-      }
-      return {
-        ...updateSessionState(state, sessionId, existing)
-      };
-    });
-  },
-  addErrorMessage: (sessionId, content) => {
-    set((state) => {
-      const turns = state.turns[sessionId] ?? [];
-      const anchorTurnId = turns[turns.length - 1]?.turn_id ?? null;
-      const entry_id = anchorTurnId ? `${ERROR_ANCHOR_PREFIX}${anchorTurnId}:${Date.now()}` : void 0;
-      return {
-        messages: {
-          ...state.messages,
-          [sessionId]: [
-            ...state.messages[sessionId] ?? [],
-            { role: "error", content, loop_name: "root", entry_id }
-          ]
-        }
-      };
-    });
-  },
-  markInterrupted: (sessionId) => {
-    set((state) => {
-      const turns = (state.turns[sessionId] ?? []).map((turn) => {
-        if (turn.status !== "streaming") return turn;
-        return {
-          ...turn,
-          status: "interrupted",
-          tool_calls: turn.tool_calls.map(
-            (toolCall) => toolCall.status === "pending" || toolCall.status === "awaiting_answer" ? { ...toolCall, status: "cancelled" } : toolCall
-          )
-        };
-      });
-      return {
-        ...updateSessionState(state, sessionId, turns)
-      };
-    });
-  },
-  markFailed: (sessionId) => {
-    set((state) => {
-      const turns = (state.turns[sessionId] ?? []).map((turn) => {
-        if (turn.status !== "streaming") return turn;
-        return {
-          ...turn,
-          status: "failed",
-          tool_calls: turn.tool_calls.map(
-            (toolCall) => toolCall.status === "pending" || toolCall.status === "awaiting_answer" ? { ...toolCall, status: "error" } : toolCall
-          )
-        };
-      });
-      return {
-        ...updateSessionState(state, sessionId, turns)
-      };
-    });
-  },
-  setStreaming: (sessionId, streaming) => {
-    set((state) => ({
-      isStreaming: { ...state.isStreaming, [sessionId]: streaming }
-    }));
-  },
-  setAskAnswers: (sessionId, answers) => {
-    set((state) => ({
-      askAnswers: {
-        ...state.askAnswers,
-        [sessionId]: answers
-      }
-    }));
-  },
-  clearMessages: (sessionId) => {
-    set((state) => {
-      const { [sessionId]: _turns, ...restTurns } = state.turns;
-      const { [sessionId]: _messages, ...restMessages } = state.messages;
-      const { [sessionId]: _answers, ...restAnswers } = state.askAnswers;
-      const { [sessionId]: _loops, ...restLoops } = state.agentLoops;
-      const { [sessionId]: _compaction, ...restCompactions } = state.activeCompactions;
-      return {
-        turns: restTurns,
-        messages: restMessages,
-        askAnswers: restAnswers,
-        agentLoops: restLoops,
-        activeCompactions: restCompactions
-      };
-    });
-  }
-}));
-
-// src/react/stores/task-store.ts
-import { create as create4 } from "zustand";
-var EMPTY_TASKS = [];
-var useTaskStore = create4()((set, get) => ({
-  ...createClientActions(set),
-  tasks: {},
-  setTasks: (sessionId, tasks) => {
-    set((state) => ({
-      tasks: { ...state.tasks, [sessionId]: tasks }
-    }));
-  },
-  getTasks: (sessionId) => {
-    return get().tasks[sessionId] ?? EMPTY_TASKS;
-  }
-}));
-
-// src/react/stores/session-store.ts
-var DEFAULT_SESSION_MODE = "executing";
-var onSessionChange = null;
-function invalidateHomeSidebarSessions() {
-  const queryClient = globalThis.__agentQueryClient;
-  if (!queryClient) return;
-  void queryClient.invalidateQueries({ queryKey: ["sessions", "home-sidebar"] });
-}
-function isSessionAccessRevoked(error) {
-  if (error instanceof Error) {
-    const msg = error.message;
-    return msg.includes("API 403") || msg.includes("API 404");
-  }
-  return false;
-}
-function removeSessionArtifacts(sessionId) {
-  useChatStore.getState().clearMessages(sessionId);
-  useTaskStore.getState().setTasks(sessionId, []);
-}
-function pruneSessionState(state, sessionId) {
-  const nextFresh = new Set(state._freshSessions);
-  nextFresh.delete(sessionId);
-  const { [sessionId]: _mode, ...modes } = state.modes;
-  const { [sessionId]: _rewindDraft, ...rewindDrafts } = state.rewindDrafts;
-  return {
-    sessions: state.sessions.filter((session) => session.id !== sessionId),
-    activeSessionId: state.activeSessionId === sessionId ? null : state.activeSessionId,
-    modes,
-    rewindDrafts,
-    _freshSessions: nextFresh
-  };
-}
-function navigateAwayFromSession(sessionId) {
-  if (typeof window === "undefined") return;
-  if (window.location.pathname !== `/chat/${sessionId}`) return;
-  window.history.replaceState(window.history.state, "", "/chat");
-  window.dispatchEvent(new PopStateEvent("popstate"));
-}
-function handleUnreadableSession(set, get, sessionId) {
-  const wasActive = get().activeSessionId === sessionId;
-  removeSessionArtifacts(sessionId);
-  set((state) => pruneSessionState(state, sessionId));
-  if (wasActive) {
-    onSessionChange?.(null);
-    navigateAwayFromSession(sessionId);
-  }
-  invalidateHomeSidebarSessions();
-}
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function extractModeFromBlocks2(blocks) {
-  const modeBlock = blocks.find((block) => block.type === "mode_change");
-  if (modeBlock && isPlainRecord(modeBlock.content) && (modeBlock.content.to === "planning" || modeBlock.content.to === "executing")) {
-    return modeBlock.content.to;
-  }
-  if (blocks.some((block) => block.type === "planning_enter")) return "planning";
-  if (blocks.some((block) => block.type === "planning_exit")) return "executing";
-  return null;
-}
-function toSelectionMap(value) {
-  if (!isPlainRecord(value)) return {};
-  const entries = Object.entries(value).map(([questionKey, optionIndexes]) => {
-    if (!Array.isArray(optionIndexes)) return null;
-    const parsedIndexes = optionIndexes.map((item) => typeof item === "number" ? item : Number(item)).filter((item) => Number.isInteger(item));
-    return [Number(questionKey), parsedIndexes];
-  }).filter((entry) => entry !== null);
-  return Object.fromEntries(entries);
-}
-function toCustomMap(value) {
-  if (!isPlainRecord(value)) return {};
-  const entries = Object.entries(value).filter(([, text]) => typeof text === "string").map(([questionKey, text]) => [Number(questionKey), text]);
-  return Object.fromEntries(entries);
-}
-function extractAskAnswers(turns) {
-  const answers = {};
-  for (const turn of turns) {
-    for (const block of turn.blocks) {
-      if (block.type !== "ask_user_answer" || typeof block.tool_call_id !== "string") continue;
-      answers[block.tool_call_id] = {
-        selections: toSelectionMap(isPlainRecord(block.content) ? block.content.selections : void 0),
-        custom: toCustomMap(isPlainRecord(block.content) ? block.content.custom : void 0)
-      };
-    }
-  }
-  return answers;
-}
-function registerCreatedSessionState(set, session, mode = DEFAULT_SESSION_MODE) {
-  useChatStore.getState().setTurns(session.id, []);
-  useTaskStore.getState().setTasks(session.id, []);
-  set((state) => ({
-    sessions: [session, ...state.sessions.filter((item) => item.id !== session.id)],
-    modes: { ...state.modes, [session.id]: state.modes[session.id] ?? mode },
-    _freshSessions: new Set(state._freshSessions).add(session.id)
-  }));
-}
-async function revalidateViewerSessions(existingSessions) {
-  const viewerSessions = existingSessions.filter((session) => session.viewer_role === "viewer");
-  if (viewerSessions.length === 0) {
-    return [];
-  }
-  const refreshed = await Promise.all(
-    viewerSessions.map(async (session) => {
-      try {
-        return await getSession(session.id);
-      } catch (error) {
-        if (isSessionAccessRevoked(error)) {
-          return null;
-        }
-        return session;
-      }
-    })
-  );
-  return refreshed.filter((session) => session !== null);
-}
-var useSessionStore = create5()((set, get) => ({
-  ...createClientActions(set),
-  sessions: [],
-  activeSessionId: null,
-  loading: false,
-  modes: {},
-  rewindDrafts: {},
-  _freshSessions: /* @__PURE__ */ new Set(),
-  fetchSessions: async () => {
-    set({ loading: true });
-    try {
-      const currentState = get();
-      const [sessions, viewerSessions] = await Promise.all([
-        listSessions(),
-        revalidateViewerSessions(currentState.sessions)
-      ]);
-      const knownSessionIds = new Set(sessions.map((session) => session.id));
-      const mergedSessions = [
-        ...sessions,
-        ...viewerSessions.filter((session) => !knownSessionIds.has(session.id))
-      ];
-      const removedSessionIds = currentState.sessions.filter(
-        (session) => session.viewer_role === "viewer" && !mergedSessions.some((candidate) => candidate.id === session.id)
-      ).map((session) => session.id);
-      const activeSessionId = currentState.activeSessionId;
-      for (const sessionId of removedSessionIds) {
-        removeSessionArtifacts(sessionId);
-      }
-      let nextState = {
-        sessions: mergedSessions,
-        activeSessionId: currentState.activeSessionId,
-        loading: false,
-        modes: currentState.modes,
-        rewindDrafts: currentState.rewindDrafts,
-        _freshSessions: currentState._freshSessions
-      };
-      for (const sessionId of removedSessionIds) {
-        nextState = {
-          ...nextState,
-          ...pruneSessionState(
-            {
-              ...currentState,
-              sessions: nextState.sessions ?? currentState.sessions,
-              activeSessionId: nextState.activeSessionId ?? currentState.activeSessionId,
-              loading: nextState.loading ?? currentState.loading,
-              modes: nextState.modes ?? currentState.modes,
-              rewindDrafts: nextState.rewindDrafts ?? currentState.rewindDrafts,
-              _freshSessions: nextState._freshSessions ?? currentState._freshSessions
-            },
-            sessionId
-          )
-        };
-      }
-      set(nextState);
-      if (activeSessionId && removedSessionIds.includes(activeSessionId)) {
-        onSessionChange?.(null);
-        navigateAwayFromSession(activeSessionId);
-      }
-      invalidateHomeSidebarSessions();
-    } catch (error) {
-      set({ loading: false });
-      throw error;
-    }
-  },
-  createSession: async (intent) => {
-    const { session_id } = await createSession(intent);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    get().registerCreatedSession({
-      id: session_id,
-      intent: intent ?? "",
-      status: "created",
-      created_at: now,
-      updated_at: now
-    });
-    get().setActiveSession(session_id);
-    invalidateHomeSidebarSessions();
-    get().fetchSessions().catch(() => {
-    });
-    return session_id;
-  },
-  registerCreatedSession: (session, mode = DEFAULT_SESSION_MODE) => {
-    registerCreatedSessionState(set, session, mode);
-  },
-  upsertSession: (session) => {
-    set((state) => ({
-      sessions: state.sessions.some((item) => item.id === session.id) ? state.sessions.map((item) => item.id === session.id ? { ...item, ...session } : item) : [session, ...state.sessions]
-    }));
-  },
-  isFreshSession: (sessionId) => get()._freshSessions.has(sessionId),
-  setActiveSession: (id) => {
-    set({ activeSessionId: id });
-    onSessionChange?.(id);
-    getSession(id).then((detail) => {
-      set((state) => ({
-        sessions: state.sessions.some((s) => s.id === id) ? state.sessions.map(
-          (s) => s.id === id ? { ...s, status: detail.status, updated_at: detail.updated_at } : s
-        ) : [detail, ...state.sessions]
-      }));
-    }).catch(() => {
-    });
-    const tasksPromise = getSessionTasks(id).catch(() => null);
-    Promise.all([getSessionTurns(id), tasksPromise]).then(([turns, tasks]) => {
-      if (tasks) useTaskStore.getState().setTasks(id, tasks);
-      useChatStore.getState().setAskAnswers(id, extractAskAnswers(turns));
-      let inferredMode = DEFAULT_SESSION_MODE;
-      for (const turn of turns) {
-        const nextMode = extractModeFromBlocks2(turn.blocks);
-        if (nextMode) {
-          inferredMode = nextMode;
-        }
-      }
-      set((state) => {
-        if (state.modes[id] == null) {
-          return { modes: { ...state.modes, [id]: inferredMode } };
-        }
-        return state;
-      });
-      const isFresh = get()._freshSessions.has(id);
-      if (isFresh) {
-        set((state) => {
-          const next = new Set(state._freshSessions);
-          next.delete(id);
-          return { _freshSessions: next };
-        });
-        if (turns.length > 0) {
-          useChatStore.getState().setTurns(id, turns);
-        }
-      } else {
-        useChatStore.getState().setTurns(id, turns);
-      }
-    }).catch((error) => {
-      if (isSessionAccessRevoked(error)) {
-        handleUnreadableSession(set, get, id);
-        return;
-      }
-      console.error("Failed to load session data", error);
-    });
-  },
-  clearActiveSession: () => {
-    set({ activeSessionId: null });
-    onSessionChange?.(null);
-  },
-  deleteSession: async (id) => {
-    await deleteSession(id);
-    invalidateHomeSidebarSessions();
-    const wasActive = get().activeSessionId === id;
-    await get().fetchSessions();
-    if (!wasActive) {
-      return;
-    }
-    const nextId = get().sessions[0]?.id ?? null;
-    if (nextId) {
-      get().setActiveSession(nextId);
-      return;
-    }
-    get().clearActiveSession();
-  },
-  updateSessionStatus: (sessionId, status) => {
-    set((state) => ({
-      sessions: state.sessions.map((s) => s.id === sessionId ? { ...s, status } : s)
-    }));
-    if (status === "failed" || status === "interrupted") {
-      useChatStore.getState().setStreaming(sessionId, false);
-      if (status === "interrupted") {
-        useChatStore.getState().markInterrupted(sessionId);
-      } else {
-        useChatStore.getState().markFailed(sessionId);
-      }
-    }
-  },
-  updateSessionIntent: (sessionId, intent) => {
-    set((state) => ({
-      sessions: state.sessions.map((s) => s.id === sessionId ? { ...s, intent } : s)
-    }));
-  },
-  patchSession: (sessionId, patch) => {
-    set((state) => ({
-      sessions: state.sessions.map(
-        (s) => s.id === sessionId ? { ...s, ...patch } : s
-      )
-    }));
-  },
-  pinSession: async (sessionId, pinned) => {
-    const updated = await pinSession(sessionId, pinned);
-    set((state) => ({
-      sessions: state.sessions.map(
-        (s) => s.id === sessionId ? { ...s, is_pinned: updated.is_pinned, pinned_at: updated.pinned_at } : s
-      )
-    }));
-    invalidateHomeSidebarSessions();
-  },
-  setRewindDraft: (sessionId, text) => {
-    set((state) => {
-      if (text == null) {
-        const { [sessionId]: _, ...rest } = state.rewindDrafts;
-        return { rewindDrafts: rest };
-      }
-      return {
-        rewindDrafts: {
-          ...state.rewindDrafts,
-          [sessionId]: text
-        }
-      };
-    });
-  },
-  setMode: (sessionId, mode) => {
-    set((state) => ({ modes: { ...state.modes, [sessionId]: mode } }));
-  },
-  togglePlanningMode: (sessionId) => {
-    const current = get().modes[sessionId] ?? DEFAULT_SESSION_MODE;
-    const next = current === "executing" ? "planning" : "executing";
-    set((state) => ({ modes: { ...state.modes, [sessionId]: next } }));
-  },
-  toggleSharing: async (sessionId) => {
-    const session = get().sessions.find((s) => s.id === sessionId);
-    if (!session) return;
-    const newShared = !session.shared;
-    const result = await updateSharing(sessionId, newShared);
-    set((state) => ({
-      sessions: state.sessions.map(
-        (s) => s.id === sessionId ? { ...s, shared: result.shared } : s
-      )
-    }));
-  },
-  reset: () => {
-    set({
-      sessions: [],
-      activeSessionId: null,
-      loading: false,
-      modes: {},
-      rewindDrafts: {},
-      _freshSessions: /* @__PURE__ */ new Set()
-    });
-    invalidateHomeSidebarSessions();
-  }
-}));
-setChatStoreSessionAccessor(() => useSessionStore.getState().activeSessionId);
-
-// src/react/stores/auth-store.ts
-var noopStorage = {
-  getItem: () => null,
-  setItem: () => {
-  },
-  removeItem: () => {
-  }
-};
-function shouldClearPersistedAuthState(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return parsed.state?.token == null && parsed.state?.user == null;
-  } catch {
-    return false;
-  }
-}
-var authStorage = createJSONStorage(() => {
-  if (typeof localStorage === "undefined") {
-    return noopStorage;
-  }
-  return {
-    getItem: (name) => localStorage.getItem(name),
-    setItem: (name, value) => {
-      if (shouldClearPersistedAuthState(value)) {
-        localStorage.removeItem(name);
-        return;
-      }
-      localStorage.setItem(name, value);
-    },
-    removeItem: (name) => localStorage.removeItem(name)
-  };
-});
-function finishAuth(set, payload) {
-  set({
-    token: payload.token,
-    socketAuthToken: null,
-    user: payload.user,
-    loading: false,
-    error: null
-  });
-  agentSocket?.reconnect();
-  useSessionStore.getState().fetchSessions().catch(() => {
-  });
-}
-function finishCookieHydration(set, payload) {
-  set({
-    token: null,
-    socketAuthToken: payload.token,
-    user: payload.user,
-    loading: false,
-    error: null
-  });
-  agentSocket?.reconnect();
-  useSessionStore.getState().fetchSessions().catch(() => {
-  });
-}
-function toUser(info) {
-  return {
-    id: info.id,
-    username: info.username,
-    display_name: info.display_name,
-    avatar_url: info.avatar_url,
-    is_admin: info.is_admin
-  };
-}
-var useAuthStore = create6()(
-  persist(
-    (set, get) => ({
-      ...createClientActions(set),
-      token: null,
-      socketAuthToken: null,
-      user: null,
-      loading: false,
-      error: null,
-      logout: () => {
-        void logout().catch(() => {
-        });
-        set({ token: null, socketAuthToken: null, user: null, error: null });
-        agentSocket?.disconnect();
-        useSessionStore.getState().reset();
-      },
-      checkAuth: async () => {
-        const token = get().token;
-        if (!token) return;
-        try {
-          const auth = await getMe();
-          finishAuth(set, { token: auth.token, user: toUser(auth) });
-        } catch {
-          set({ token: null, socketAuthToken: null, user: null, error: null });
-          useSessionStore.getState().reset();
-        }
-      },
-      hydrateFromCookie: async () => {
-        set({ loading: true, error: null });
-        const previousToken = get().token;
-        if (previousToken) {
-          try {
-            const auth = await getMe();
-            finishAuth(set, { token: auth.token, user: toUser(auth) });
-            return;
-          } catch {
-            set({ token: null, socketAuthToken: null, user: null, error: null });
-            useSessionStore.getState().reset();
-          }
-        }
-        try {
-          const auth = await getMe();
-          finishCookieHydration(set, { token: auth.token, user: toUser(auth) });
-        } catch {
-          set({
-            token: null,
-            socketAuthToken: null,
-            user: null,
-            loading: false,
-            error: null
-          });
-          useSessionStore.getState().reset();
-        }
-      }
-    }),
-    {
-      name: "agent-auth",
-      storage: authStorage,
-      partialize: (state) => {
-        if (state.socketAuthToken) {
-          return { token: null, user: null };
-        }
-        return { token: state.token, user: state.user };
-      }
-    }
-  )
-);
-
-// src/react/stores/background-store.ts
-import { create as create7 } from "zustand";
-var useBackgroundStore = create7()((set) => ({
-  ...createClientActions(set),
-  tasks: {},
-  selectedTaskId: {},
-  setTasks: (sessionId, tasks) => set((state) => ({
-    tasks: { ...state.tasks, [sessionId]: tasks },
-    selectedTaskId: {
-      ...state.selectedTaskId,
-      [sessionId]: state.selectedTaskId[sessionId] ?? tasks[0]?.id ?? null
-    }
-  })),
-  upsertTask: (sessionId, task) => set((state) => {
-    const existing = state.tasks[sessionId] ?? [];
-    const index = existing.findIndex((item) => item.id === task.id);
-    const next = [...existing];
-    if (index >= 0) {
-      next[index] = { ...next[index], ...task };
-    } else {
-      next.unshift(task);
-    }
-    return {
-      tasks: { ...state.tasks, [sessionId]: next },
-      selectedTaskId: {
-        ...state.selectedTaskId,
-        [sessionId]: state.selectedTaskId[sessionId] ?? task.id
-      }
-    };
-  }),
-  selectTask: (sessionId, taskId) => set((state) => ({
-    selectedTaskId: { ...state.selectedTaskId, [sessionId]: taskId }
-  }))
-}));
-
-// src/react/stores/card-state-store.ts
-import { create as create8 } from "zustand";
-var useCardStateStore = create8((set, get) => ({
-  ...createClientActions(set),
-  states: {},
-  getCardState: (cardId) => {
-    return get().states[cardId];
-  },
-  setCardState: (cardId, state) => {
-    set((prev) => ({
-      states: { ...prev.states, [cardId]: state }
-    }));
-  },
-  removeCardState: (cardId) => {
-    set((prev) => {
-      const { [cardId]: _, ...rest } = prev.states;
-      return { states: rest };
-    });
-  },
-  clearAllStates: () => {
-    set({ states: {} });
-  }
-}));
-
-// src/react/stores/connection-store.ts
-import { create as create9 } from "zustand";
-var initialConnectionState = {
-  status: "disconnected",
-  reconnectAttempt: 0,
-  lastConnectedAt: null,
-  lastDisconnectedAt: null,
-  hasEverConnected: false
-};
-var useConnectionStore = create9()((set) => ({
-  ...createClientActions(set),
-  ...initialConnectionState,
-  markConnecting: (attempt = 0) => set({
-    status: "connecting",
-    reconnectAttempt: attempt
-  }),
-  markConnected: () => set({
-    status: "connected",
-    reconnectAttempt: 0,
-    lastConnectedAt: Date.now(),
-    hasEverConnected: true
-  }),
-  markDisconnected: () => set({
-    status: "disconnected",
-    reconnectAttempt: 0,
-    lastDisconnectedAt: Date.now()
-  }),
-  reset: () => set(initialConnectionState)
-}));
-
-// src/react/stores/runtime-store.ts
-import { create as create10 } from "zustand";
-var useRuntimeStore = create10()((set) => ({
-  ...createClientActions(set),
-  events: {},
-  addEvent: (sessionId, event) => set((state) => {
-    const current = state.events[sessionId] ?? [];
-    const nextEvent = {
-      ...event,
-      id: `${Date.now()}-${current.length}`,
-      sessionId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return {
-      events: {
-        ...state.events,
-        [sessionId]: [...current.slice(-59), nextEvent]
-      }
-    };
-  }),
-  clearSession: (sessionId) => set((state) => ({
-    events: { ...state.events, [sessionId]: [] }
-  }))
-}));
-
-// src/react/stores/gis-store.ts
-import { create as create11 } from "zustand";
-var EMPTY_GOALS = [];
-var EMPTY_RESOURCES = [];
-var EMPTY_TARGETS = [];
-var EMPTY_COMMANDS = [];
-function newCommandId() {
-  if (typeof globalThis !== "undefined" && "crypto" in globalThis) {
-    return globalThis.crypto?.randomUUID?.() ?? `gis-map-${Date.now()}-${Math.random()}`;
-  }
-  return `gis-map-${Date.now()}-${Math.random()}`;
-}
-var useGisStore = create11()((set, get) => ({
-  ...createClientActions(set),
-  goalsBySession: {},
-  resourcesBySession: {},
-  targetsBySession: {},
-  pendingMapCommandsBySession: {},
-  setGoals: (sessionId, goals) => {
-    set((state) => ({
-      goalsBySession: { ...state.goalsBySession, [sessionId]: goals }
-    }));
-  },
-  setResources: (sessionId, resources) => {
-    set((state) => ({
-      resourcesBySession: { ...state.resourcesBySession, [sessionId]: resources }
-    }));
-  },
-  setTargets: (sessionId, targets) => {
-    set((state) => ({
-      targetsBySession: { ...state.targetsBySession, [sessionId]: targets }
-    }));
-  },
-  pushMapCommand: (sessionId, command) => {
-    set((state) => ({
-      pendingMapCommandsBySession: {
-        ...state.pendingMapCommandsBySession,
-        [sessionId]: [
-          ...state.pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS,
-          {
-            ...command,
-            id: newCommandId(),
-            createdAt: Date.now()
-          }
-        ]
-      }
-    }));
-  },
-  consumeMapCommand: (sessionId, commandId) => {
-    set((state) => ({
-      pendingMapCommandsBySession: {
-        ...state.pendingMapCommandsBySession,
-        [sessionId]: (state.pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS).filter(
-          (command) => command.id !== commandId
-        )
-      }
-    }));
-  },
-  getGoals: (sessionId) => get().goalsBySession[sessionId] ?? EMPTY_GOALS,
-  getResources: (sessionId) => get().resourcesBySession[sessionId] ?? EMPTY_RESOURCES,
-  getTargets: (sessionId) => get().targetsBySession[sessionId] ?? EMPTY_TARGETS,
-  getPendingMapCommands: (sessionId) => get().pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS
-}));
-
-// src/react/stores/answer-callback-store.ts
-import { create as create12 } from "zustand";
-var useAnswerCallbackStore = create12()((set) => ({
-  ...createClientActions(set),
-  callbacks: {},
-  setAnswerCallback: (sessionId, callback) => {
-    set((state) => ({
-      callbacks: {
-        ...state.callbacks,
-        [sessionId]: callback
-      }
-    }));
-  }
-}));
-
-// src/react/stores/runtime-features-store.ts
-import { create as create13 } from "zustand";
-var useRuntimeFeaturesStore = create13((set) => ({
-  ...createClientActions(set),
-  asrEnabled: false,
-  asrProvider: "volcengine",
-  publicSharingEnabled: false,
-  memoryEnabled: false,
-  setFeatures: (features) => set((prev) => ({
-    asrEnabled: features.asrEnabled ?? prev.asrEnabled,
-    asrProvider: features.asrProvider ?? prev.asrProvider,
-    publicSharingEnabled: features.publicSharingEnabled ?? prev.publicSharingEnabled,
-    memoryEnabled: features.memoryEnabled ?? prev.memoryEnabled
-  }))
-}));
-
-// src/react/bootstrap.ts
-var bootstrappedClient = null;
-function getBootstrappedClient() {
-  if (!bootstrappedClient) {
-    throw new Error("bootstrapBladeClient() must be called before any SDK usage");
-  }
-  return bootstrappedClient;
-}
-
-// src/react/api/client.ts
-function getClient() {
-  return getBootstrappedClient();
-}
-
-// src/react/api/licenses.ts
-var r3 = () => getClient().licenses;
-var getDeviceUuid = (...args) => r3().getDeviceUuid(...args);
-var validateLicense = (...args) => r3().validateLicense(...args);
-var getLicenseStatus = (...args) => r3().getLicenseStatus(...args);
-var uploadLicense = (...args) => r3().uploadLicense(...args);
+import {
+  getDeviceUuid,
+  getLicenseStatus,
+  uploadLicense,
+  validateLicense
+} from "../../chunk-TC5BBLWO.js";
+import "../../chunk-4VWLTG5L.js";
+import "../../chunk-J3XVFPOV.js";
+import "../../chunk-OKQWPNE3.js";
+import "../../chunk-JCJFFJ42.js";
+import "../../chunk-PZ5AY32C.js";
 export {
   getDeviceUuid,
   getLicenseStatus,