@blade-hq/agent-kit 0.4.1 → 0.4.4

package/dist/react/api/vibe-coding.js

@@ -0,0 +1,1503 @@
+// 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/vibe-coding.ts
+var r3 = () => getClient().vibeCoding;
+var createVibeCodingSession = (...args) => r3().createVibeCodingSession(...args);
+var listVibeCodingSessionInfos = (...args) => r3().listVibeCodingSessionInfos(...args);
+var getVibeCodingSessionDebugStatus = (...args) => r3().getVibeCodingSessionDebugStatus(...args);
+var getVibeCodingSessionStatus = (...args) => r3().getVibeCodingSessionStatus(...args);
+var getVibeCodingDeployStatus = (...args) => r3().getVibeCodingDeployStatus(...args);
+var startVibeCodingService = (...args) => r3().startVibeCodingService(...args);
+var stopVibeCodingService = (...args) => r3().stopVibeCodingService(...args);
+var updateVibeCodingDebugService = (...args) => r3().updateVibeCodingDebugService(...args);
+var deployVibeCodingSession = (...args) => r3().deployVibeCodingSession(...args);
+var listVibeCodingDeployVersions = (...args) => r3().listVibeCodingDeployVersions(...args);
+var startVibeCodingDeployService = (...args) => r3().startVibeCodingDeployService(...args);
+var stopVibeCodingDeployService = (...args) => r3().stopVibeCodingDeployService(...args);
+var deleteVibeCodingDeployVersion = (...args) => r3().deleteVibeCodingDeployVersion(...args);
+var deleteVibeCodingSession = (...args) => r3().deleteVibeCodingSession(...args);
+var probeVibeCodingService = (...args) => r3().probeVibeCodingService(...args);
+var exportVibeCodingSession = (...args) => r3().exportVibeCodingSession(...args);
+var importVibeCodingSession = (...args) => r3().importVibeCodingSession(...args);
+export {
+  createVibeCodingSession,
+  deleteVibeCodingDeployVersion,
+  deleteVibeCodingSession,
+  deployVibeCodingSession,
+  exportVibeCodingSession,
+  getVibeCodingDeployStatus,
+  getVibeCodingSessionDebugStatus,
+  getVibeCodingSessionStatus,
+  importVibeCodingSession,
+  listVibeCodingDeployVersions,
+  listVibeCodingSessionInfos,
+  probeVibeCodingService,
+  startVibeCodingDeployService,
+  startVibeCodingService,
+  stopVibeCodingDeployService,
+  stopVibeCodingService,
+  updateVibeCodingDebugService
+};
+//# sourceMappingURL=vibe-coding.js.map