@blade-hq/agent-kit 0.0.0-placeholder.0 → 0.4.4

package/dist/react/components/session/index.js

@@ -0,0 +1,2175 @@
+// 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/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/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 getSessionCheckpoints = (...args) => r2().getSessionCheckpoints(...args);
+var checkoutSession = (...args) => r2().checkoutSession(...args);
+var deleteSession = (...args) => r2().deleteSession(...args);
+
+// src/react/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/react/components/session/SessionDetail.tsx
+import * as Tooltip from "@radix-ui/react-tooltip";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { HelpCircle } from "lucide-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ROW_HEIGHT = 32;
+var SVG_WIDTH = 44;
+function SessionDetailTrigger({
+  onClick,
+  showReplayDot = false
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick,
+        className: "flex items-center gap-1.5 text-[10px] font-medium tracking-[0.18em] text-[hsl(var(--muted-foreground))] uppercase transition-colors hover:text-[hsl(var(--foreground))]",
+        children: [
+          /* @__PURE__ */ jsx("span", { children: "\u5386\u53F2\u56DE\u6EAF" }),
+          /* @__PURE__ */ jsx(HelpCircle, { size: 12 })
+        ]
+      }
+    ),
+    showReplayDot ? /* @__PURE__ */ jsx(Tooltip.Provider, { delayDuration: 150, children: /* @__PURE__ */ jsxs(Tooltip.Root, { children: [
+      /* @__PURE__ */ jsx(Tooltip.Trigger, { asChild: true, children: /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "h-[5px] w-[5px] shrink-0 rounded-full bg-amber-400",
+          "aria-label": "\u5F53\u524D\u5C5E\u4E8E\u56DE\u653E\u6A21\u5F0F"
+        }
+      ) }),
+      /* @__PURE__ */ jsx(Tooltip.Portal, { children: /* @__PURE__ */ jsxs(
+        Tooltip.Content,
+        {
+          side: "top",
+          className: "z-[60] rounded-md border border-[hsl(var(--border))] bg-[hsl(var(--popover))] px-2 py-1 text-[11px] text-[hsl(var(--popover-foreground))] shadow-lg",
+          children: [
+            "\u5F53\u524D\u5C5E\u4E8E\u56DE\u653E\u6A21\u5F0F",
+            /* @__PURE__ */ jsx(Tooltip.Arrow, { className: "fill-[hsl(var(--popover))]" })
+          ]
+        }
+      ) })
+    ] }) }) : null
+  ] });
+}
+function SessionDetail({ session }) {
+  const [pendingNodeId, setPendingNodeId] = useState(null);
+  const isStreaming = useChatStore((state) => state.isStreaming[session.id] ?? false);
+  const setRewindDraft = useSessionStore((state) => state.setRewindDraft);
+  const setActiveSession = useSessionStore((state) => state.setActiveSession);
+  const queryClient = useQueryClient();
+  const { data: tree } = useQuery({
+    queryKey: ["checkpoints", session.id],
+    queryFn: ({ signal }) => getSessionCheckpoints(session.id, { signal })
+  });
+  const prevStreamingRef = useRef(isStreaming);
+  useEffect(() => {
+    if (prevStreamingRef.current && !isStreaming) {
+      void queryClient.invalidateQueries({ queryKey: ["checkpoints", session.id] });
+    }
+    prevStreamingRef.current = isStreaming;
+  }, [isStreaming, queryClient, session.id]);
+  const hasHistory = (tree?.nodes.length ?? 0) > 0;
+  const layout = useMemo(() => buildLayoutNodes(tree), [tree]);
+  const nodeMap = useMemo(
+    () => new Map((tree?.nodes ?? []).map((node) => [node.id, node])),
+    [tree]
+  );
+  const isBusy = isStreaming || pendingNodeId !== null;
+  const graphHeight = Math.max((layout.maxRow + 1) * ROW_HEIGHT, ROW_HEIGHT);
+  const graphWidth = Math.max(SVG_WIDTH, getColumnX(layout.maxColumn) + 12);
+  async function checkoutNode(node, position) {
+    if (isBusy) {
+      return;
+    }
+    setPendingNodeId(node.id);
+    try {
+      const result = await checkoutSession(session.id, node.id, position);
+      if (result.position === "before" && result.content.trim()) {
+        setRewindDraft(session.id, result.content);
+      } else {
+        setRewindDraft(session.id, "");
+      }
+      setActiveSession(session.id);
+      await queryClient.invalidateQueries({ queryKey: ["checkpoints", session.id] });
+    } finally {
+      setPendingNodeId(null);
+    }
+  }
+  async function handleVirtualClick(node) {
+    if (isBusy || !node.isVirtual) return;
+    const leafId = node.content;
+    if (!leafId) return;
+    if (node.isActive) return;
+    const sourceNode = nodeMap.get(leafId);
+    if (!sourceNode) return;
+    await checkoutNode(sourceNode, "turn_end");
+  }
+  async function handleNodeSelect(node) {
+    if (isBusy) {
+      return;
+    }
+    const sourceNode = nodeMap.get(node.id);
+    if (!sourceNode) {
+      return;
+    }
+    await checkoutNode(sourceNode, "before");
+  }
+  if (!hasHistory) return null;
+  return /* @__PURE__ */ jsx(Tooltip.Provider, { delayDuration: 200, children: /* @__PURE__ */ jsx("div", { className: "flex max-h-52 justify-center overflow-x-auto overflow-y-auto", children: /* @__PURE__ */ jsxs("div", { className: "relative", style: { height: graphHeight, width: graphWidth }, children: [
+    /* @__PURE__ */ jsx(
+      "svg",
+      {
+        "aria-hidden": "true",
+        className: "pointer-events-none absolute left-0 top-0 z-10 overflow-visible",
+        width: graphWidth,
+        height: graphHeight,
+        viewBox: `0 0 ${graphWidth} ${graphHeight}`,
+        fill: "none",
+        children: layout.nodes.map((node) => {
+          if (node.parentRow == null || node.parentColumn == null) {
+            return null;
+          }
+          const childStroke = node.isActive ? "hsl(var(--primary))" : "hsl(var(--muted-foreground))";
+          return /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: buildEdgePath(
+                getColumnX(node.parentColumn),
+                getRowY(node.parentRow),
+                getColumnX(node.column),
+                getRowY(node.row)
+              ),
+              stroke: childStroke,
+              strokeOpacity: node.isActive ? 0.95 : 0.45,
+              strokeWidth: node.isActive ? 1.8 : 1.4,
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeDasharray: node.isVirtual ? "3 3" : void 0
+            },
+            `path-${node.id}`
+          );
+        })
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "relative z-0 h-full", children: layout.nodes.map((node) => {
+      const isPendingNode = pendingNodeId === node.id;
+      const color = node.isActive ? "hsl(var(--primary))" : "hsl(var(--muted-foreground))";
+      const previewText = node.isVirtual ? isPendingNode ? "\u5207\u6362\u4E2D..." : "" : isPendingNode ? "\u5207\u6362\u4E2D..." : node.preview;
+      const shouldShowTooltip = !node.isVirtual || Boolean(previewText);
+      const button = /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => void (node.isVirtual ? handleVirtualClick(node) : handleNodeSelect(node)),
+          disabled: isBusy,
+          "aria-current": !node.isVirtual && node.isCurrent ? "step" : void 0,
+          "aria-label": node.isVirtual ? "\u5207\u6362\u5230\u8BE5\u5206\u652F" : node.preview,
+          className: cn(
+            "absolute z-20 h-8 w-6 overflow-visible",
+            isBusy ? "cursor-not-allowed opacity-60" : "cursor-pointer"
+          ),
+          style: {
+            top: node.row * ROW_HEIGHT,
+            left: getColumnX(node.column) - 12
+          },
+          children: /* @__PURE__ */ jsx(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "absolute left-0 top-0 h-8 w-6",
+              children: /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  "aria-hidden": "true",
+                  role: "img",
+                  className: "pointer-events-none absolute left-0 top-0 h-full w-full overflow-visible",
+                  width: 24,
+                  height: ROW_HEIGHT,
+                  viewBox: `0 0 24 ${ROW_HEIGHT}`,
+                  fill: "none",
+                  children: node.isVirtual ? /* @__PURE__ */ jsx(
+                    "circle",
+                    {
+                      cx: 12,
+                      cy: ROW_HEIGHT / 2,
+                      r: 3.5,
+                      fill: "none",
+                      stroke: color,
+                      strokeWidth: 1.2,
+                      strokeDasharray: "2 2",
+                      opacity: 0.7
+                    }
+                  ) : /* @__PURE__ */ jsxs("g", { children: [
+                    node.isCurrent ? /* @__PURE__ */ jsx(
+                      "circle",
+                      {
+                        cx: 12,
+                        cy: ROW_HEIGHT / 2,
+                        r: 9,
+                        fill: color,
+                        opacity: 0.18
+                      }
+                    ) : null,
+                    /* @__PURE__ */ jsx(
+                      "circle",
+                      {
+                        cx: 12,
+                        cy: ROW_HEIGHT / 2,
+                        r: node.isCurrent ? 5.5 : 4,
+                        fill: color
+                      }
+                    )
+                  ] })
+                }
+              )
+            }
+          )
+        }
+      );
+      if (!shouldShowTooltip) {
+        return /* @__PURE__ */ jsx("div", { children: button }, node.id);
+      }
+      return /* @__PURE__ */ jsxs(Tooltip.Root, { children: [
+        /* @__PURE__ */ jsx(Tooltip.Trigger, { asChild: true, children: button }),
+        /* @__PURE__ */ jsx(Tooltip.Portal, { children: /* @__PURE__ */ jsx(
+          Tooltip.Content,
+          {
+            side: "right",
+            sideOffset: 8,
+            className: cn(
+              "rounded-md border border-border bg-popover px-2 py-1 text-xs text-foreground shadow-md",
+              !node.isVirtual && node.isCurrent && "font-semibold"
+            ),
+            children: previewText
+          }
+        ) })
+      ] }, node.id);
+    }) })
+  ] }) }) });
+}
+function buildLayoutNodes(tree) {
+  if (!tree || tree.nodes.length === 0) {
+    return { nodes: [], hasCycle: false, maxColumn: 0, maxRow: 0 };
+  }
+  const nodeMap = new Map(tree.nodes.map((node) => [node.id, node]));
+  const order = new Map(tree.nodes.map((node, index) => [node.id, index]));
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const node of tree.nodes) {
+    const parentId = node.parent_id && nodeMap.has(node.parent_id) ? node.parent_id : null;
+    const siblings = childrenMap.get(parentId) ?? [];
+    siblings.push(node);
+    childrenMap.set(parentId, siblings);
+  }
+  const activeIds = /* @__PURE__ */ new Set();
+  const activeVisited = /* @__PURE__ */ new Set();
+  const leafId = tree.leaf_id;
+  let current = tree.leaf_id;
+  while (current && nodeMap.has(current) && !activeVisited.has(current)) {
+    activeIds.add(current);
+    activeVisited.add(current);
+    current = nodeMap.get(current)?.parent_id ?? null;
+  }
+  const layoutNodes = [];
+  const placed = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  let nextColumn = 1;
+  let maxColumn = 0;
+  let maxRow = 0;
+  let hasCycle = false;
+  const rootSort = (a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0);
+  const childSort = (a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0);
+  const allocateColumn = () => {
+    const fresh = nextColumn;
+    nextColumn += 1;
+    return fresh;
+  };
+  function walk(node, parent, column, row) {
+    if (visiting.has(node.id)) {
+      hasCycle = true;
+      return;
+    }
+    if (placed.has(node.id)) {
+      return;
+    }
+    visiting.add(node.id);
+    maxColumn = Math.max(maxColumn, column);
+    maxRow = Math.max(maxRow, row);
+    const layoutNode = {
+      id: node.id,
+      column,
+      row,
+      parentRow: parent?.row ?? null,
+      parentColumn: parent?.column ?? null,
+      isActive: activeIds.has(node.id),
+      isCurrent: node.id === leafId,
+      isVirtual: false,
+      preview: formatPreview(node.content_preview),
+      content: node.content
+    };
+    layoutNodes.push(layoutNode);
+    placed.add(node.id);
+    const children = [...childrenMap.get(node.id) ?? []].sort(childSort);
+    if (children.length === 0) {
+      const virtualRow = row + 1;
+      maxRow = Math.max(maxRow, virtualRow);
+      layoutNodes.push({
+        id: `__virtual__${node.id}`,
+        column,
+        row: virtualRow,
+        parentRow: layoutNode.row,
+        parentColumn: layoutNode.column,
+        isActive: activeIds.has(node.id),
+        isCurrent: false,
+        isVirtual: true,
+        preview: "",
+        content: node.id
+      });
+    } else {
+      for (const [index, child] of children.entries()) {
+        if (visiting.has(child.id)) {
+          hasCycle = true;
+          continue;
+        }
+        const childColumn = index === 0 ? column : allocateColumn();
+        walk(child, layoutNode, childColumn, row + 1);
+      }
+    }
+    visiting.delete(node.id);
+  }
+  const roots = [...childrenMap.get(null) ?? []].sort(rootSort);
+  for (const [index, root] of roots.entries()) {
+    const rootColumn = index === 0 ? 0 : allocateColumn();
+    walk(root, null, rootColumn, 0);
+  }
+  for (const node of [...tree.nodes].sort(rootSort)) {
+    if (!placed.has(node.id)) {
+      hasCycle = true;
+      const rootColumn = layoutNodes.length === 0 ? 0 : allocateColumn();
+      walk(node, null, rootColumn, 0);
+    }
+  }
+  return {
+    nodes: layoutNodes,
+    hasCycle,
+    maxColumn,
+    maxRow
+  };
+}
+function formatPreview(preview) {
+  const normalized = preview.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : "(\u7A7A\u6D88\u606F)";
+}
+function getColumnX(column) {
+  return 12 + column * 24;
+}
+function getRowY(row) {
+  return row * ROW_HEIGHT + ROW_HEIGHT / 2;
+}
+function buildEdgePath(fromX, fromY, toX, toY) {
+  if (fromX === toX || fromY === toY) {
+    return `M ${fromX} ${fromY} L ${toX} ${toY}`;
+  }
+  const r3 = Math.min(5, Math.abs(toX - fromX), Math.abs(toY - fromY));
+  const dx = toX > fromX ? 1 : -1;
+  return [
+    `M ${fromX} ${fromY}`,
+    `H ${toX - dx * r3}`,
+    `A ${r3} ${r3} 0 0 ${dx > 0 ? 1 : 0} ${toX} ${fromY + r3}`,
+    `V ${toY}`
+  ].join(" ");
+}
+
+// src/react/components/session/SessionList.tsx
+import { Plus } from "lucide-react";
+import { useState as useState2 } from "react";
+
+// src/react/hooks/use-session.ts
+function useSession() {
+  const sessions = useSessionStore((s) => s.sessions);
+  const activeSessionId = useSessionStore((s) => s.activeSessionId);
+  const loading = useSessionStore((s) => s.loading);
+  const fetchSessions = useSessionStore((s) => s.fetchSessions);
+  const createSession2 = useSessionStore((s) => s.createSession);
+  const setActiveSession = useSessionStore((s) => s.setActiveSession);
+  const deleteSession2 = useSessionStore((s) => s.deleteSession);
+  const activeSession = sessions.find((s) => s.id === activeSessionId) ?? null;
+  return {
+    sessions,
+    activeSessionId,
+    activeSession,
+    loading,
+    fetchSessions,
+    createSession: createSession2,
+    setActiveSession,
+    deleteSession: deleteSession2
+  };
+}
+
+// src/react/components/session/SessionListItem.tsx
+import { Loader2 } from "lucide-react";
+
+// src/react/components/session/StatusBadge.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var statusConfig = {
+  created: {
+    className: "bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]",
+    label: "\u5DF2\u521B\u5EFA"
+  },
+  running: { className: "bg-blue-500/15 text-blue-400", label: "\u8FD0\u884C\u4E2D" },
+  completed: { className: "bg-emerald-500/15 text-emerald-400", label: "\u5DF2\u5B8C\u6210" },
+  failed: {
+    className: "bg-[hsl(var(--destructive)/0.15)] text-[hsl(var(--destructive))]",
+    label: "\u5931\u8D25"
+  },
+  interrupted: { className: "bg-amber-500/15 text-amber-400", label: "\u5DF2\u4E2D\u65AD" },
+  waiting_for_input: { className: "bg-violet-500/15 text-violet-400", label: "\u7B49\u5F85\u8F93\u5165" },
+  pending: {
+    className: "bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]",
+    label: "\u5F85\u5904\u7406"
+  },
+  in_progress: { className: "bg-blue-500/15 text-blue-400", label: "\u8FDB\u884C\u4E2D" },
+  done: { className: "bg-emerald-500/15 text-emerald-400", label: "\u5B8C\u6210" },
+  info: {
+    className: "bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]",
+    label: "\u4FE1\u606F"
+  },
+  error: {
+    className: "bg-[hsl(var(--destructive)/0.15)] text-[hsl(var(--destructive))]",
+    label: "\u9519\u8BEF"
+  },
+  skipped: {
+    className: "bg-[hsl(var(--muted)/0.5)] text-[hsl(var(--muted-foreground)/0.6)]",
+    label: "\u5DF2\u8DF3\u8FC7"
+  },
+  example: {
+    className: "bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]",
+    label: "\u793A\u4F8B"
+  }
+};
+var defaultConfig = {
+  className: "bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]",
+  label: ""
+};
+function StatusBadge({ status }) {
+  const config = statusConfig[status] ?? defaultConfig;
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      className: cn(
+        "inline-flex items-center rounded-full px-2 py-0.5 text-[10px] font-medium tracking-wide",
+        config.className
+      ),
+      children: config.label || status
+    }
+  );
+}
+
+// src/react/components/session/session-utils.ts
+var SESSION_GROUPS = ["today", "yesterday", "week", "older"];
+var SESSION_GROUP_LABELS = {
+  today: "\u4ECA\u5929",
+  yesterday: "\u6628\u5929",
+  week: "\u672C\u5468",
+  older: "\u66F4\u65E9"
+};
+var RELATIVE_TIME_FORMATTER = new Intl.RelativeTimeFormat("zh-CN", {
+  numeric: "auto"
+});
+function getSessionTimestamp(session) {
+  const value = Date.parse(session.updated_at || session.created_at);
+  return Number.isNaN(value) ? 0 : value;
+}
+function getSessionLabel(session, fallback = "\u672A\u547D\u540D\u5BF9\u8BDD") {
+  const normalized = session.intent?.trim();
+  return normalized ? normalized : fallback;
+}
+function shouldShowSessionInHistory(session) {
+  return !(session.status === "created" && !session.intent.trim());
+}
+function isReplaySession(session) {
+  return session.replay_state?.status === "replay";
+}
+function getDisplaySessionStatus(session) {
+  if (session.replay_state?.status === "autonomous" && session.replay_state.autonomous_reason === "completed") {
+    return "completed";
+  }
+  return session.status;
+}
+function startOfDay(date) {
+  const copy = new Date(date);
+  copy.setHours(0, 0, 0, 0);
+  return copy;
+}
+function startOfWeek(date) {
+  const copy = startOfDay(date);
+  const day = copy.getDay();
+  const diff = day === 0 ? 6 : day - 1;
+  copy.setDate(copy.getDate() - diff);
+  return copy;
+}
+function getSessionGroup(timestamp, now = /* @__PURE__ */ new Date()) {
+  if (!timestamp) {
+    return "older";
+  }
+  const sessionDate = new Date(timestamp);
+  const today = startOfDay(now);
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const thisWeek = startOfWeek(now);
+  if (sessionDate >= today) {
+    return "today";
+  }
+  if (sessionDate >= yesterday) {
+    return "yesterday";
+  }
+  if (sessionDate >= thisWeek) {
+    return "week";
+  }
+  return "older";
+}
+function formatRelativeTime(timestamp, now = Date.now()) {
+  if (!timestamp) {
+    return "\u65F6\u95F4\u672A\u77E5";
+  }
+  const diffSeconds = Math.round((timestamp - now) / 1e3);
+  const absSeconds = Math.abs(diffSeconds);
+  if (absSeconds < 60) {
+    return "\u521A\u521A";
+  }
+  const units = [
+    ["minute", 60],
+    ["hour", 60 * 60],
+    ["day", 60 * 60 * 24],
+    ["week", 60 * 60 * 24 * 7],
+    ["month", 60 * 60 * 24 * 30],
+    ["year", 60 * 60 * 24 * 365]
+  ];
+  for (let index = 0; index < units.length; index += 1) {
+    const [unit, threshold] = units[index];
+    const nextThreshold = units[index + 1]?.[1];
+    if (!nextThreshold || absSeconds < nextThreshold) {
+      return RELATIVE_TIME_FORMATTER.format(Math.round(diffSeconds / threshold), unit);
+    }
+  }
+  return RELATIVE_TIME_FORMATTER.format(Math.round(diffSeconds / (60 * 60 * 24 * 365)), "year");
+}
+function getStatusMeta(status) {
+  switch (status) {
+    case "running":
+      return {
+        dotClass: "bg-emerald-400",
+        toneClass: "border-emerald-500/20 bg-emerald-500/8 text-emerald-300",
+        label: "\u8FD0\u884C\u4E2D"
+      };
+    case "failed":
+      return {
+        dotClass: "bg-rose-400",
+        toneClass: "border-rose-500/20 bg-rose-500/8 text-rose-300",
+        label: "\u5F02\u5E38"
+      };
+    case "waiting_for_input":
+      return {
+        dotClass: "bg-violet-400",
+        toneClass: "border-violet-500/20 bg-violet-500/8 text-violet-300",
+        label: "\u5F85\u8865\u5145"
+      };
+    case "completed":
+      return {
+        dotClass: "bg-sky-400",
+        toneClass: "border-sky-500/20 bg-sky-500/8 text-sky-300",
+        label: "\u5DF2\u5B8C\u6210"
+      };
+    case "interrupted":
+      return {
+        dotClass: "bg-amber-400",
+        toneClass: "border-amber-500/20 bg-amber-500/8 text-amber-300",
+        label: "\u5DF2\u4E2D\u65AD"
+      };
+    default:
+      return {
+        dotClass: "bg-[hsl(var(--muted-foreground))]",
+        toneClass: "border-[hsl(var(--border))] bg-[hsl(var(--accent))] text-[hsl(var(--muted-foreground))]",
+        label: "\u51C6\u5907\u4E2D"
+      };
+  }
+}
+
+// src/react/components/session/SessionListItem.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function SessionListItem({ session, active, onClick }) {
+  const isReplay = isReplaySession(session);
+  return /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: cn(
+        "flex w-full flex-col gap-1 rounded-md border-l-2 px-3 py-2 text-left text-sm transition-all hover:bg-[hsl(var(--accent))]",
+        active ? "border-l-[hsl(var(--primary))] bg-[hsl(var(--accent))]" : "border-l-transparent"
+      ),
+      children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+          session.status === "running" && /* @__PURE__ */ jsx3(Loader2, { size: 11, className: "shrink-0 animate-spin text-blue-400" }),
+          /* @__PURE__ */ jsx3("span", { className: "truncate text-[13px] font-medium leading-snug", children: getSessionLabel(session) }),
+          isReplay ? /* @__PURE__ */ jsx3(
+            "span",
+            {
+              className: "h-[5px] w-[5px] shrink-0 rounded-full bg-amber-400",
+              title: "\u5F53\u524D\u5C5E\u4E8E\u56DE\u653E\u6A21\u5F0F",
+              "aria-label": "\u5F53\u524D\u5C5E\u4E8E\u56DE\u653E\u6A21\u5F0F"
+            }
+          ) : null
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx3(StatusBadge, { status: getDisplaySessionStatus(session) }),
+          /* @__PURE__ */ jsx3("span", { className: "font-mono text-[10px] text-[hsl(var(--muted-foreground))]", children: session.id.slice(0, 8) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/react/components/session/SessionList.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function SessionList({ sessions, onSessionCreated, onSessionSelect }) {
+  const { createSession: createSession2, activeSessionId } = useSession();
+  const [error, setError] = useState2(null);
+  const handleCreateSession = async () => {
+    setError(null);
+    try {
+      const sessionId = await createSession2();
+      onSessionCreated?.(sessionId);
+      onSessionSelect(sessionId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(`\u521B\u5EFA\u5BF9\u8BDD\u5931\u8D25: ${message}`);
+      setTimeout(() => setError(null), 5e3);
+    }
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: "flex flex-col pt-1", children: [
+    /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        type: "button",
+        onClick: handleCreateSession,
+        className: "mx-2 mt-1.5 flex items-center gap-2 rounded-md border border-dashed border-[hsl(var(--border))] px-3 py-2 text-sm text-[hsl(var(--muted-foreground))] transition-all hover:border-[hsl(var(--ring))] hover:text-[hsl(var(--primary))]",
+        children: [
+          /* @__PURE__ */ jsx4(Plus, { size: 13 }),
+          "\u65B0\u5EFA\u4F1A\u8BDD"
+        ]
+      }
+    ),
+    error ? /* @__PURE__ */ jsx4("p", { className: "mx-2 mt-2 rounded-lg bg-[hsl(var(--destructive)/0.1)] px-3 py-2 text-sm text-[hsl(var(--destructive))]", children: error }) : null,
+    /* @__PURE__ */ jsx4(
+      SessionListEntries,
+      {
+        sessions,
+        activeSessionId,
+        onSessionSelect
+      }
+    )
+  ] });
+}
+function SessionListEntries({
+  sessions,
+  activeSessionId,
+  onSessionSelect
+}) {
+  return /* @__PURE__ */ jsx4("div", { className: "mt-2 flex flex-col gap-0.5 px-1.5", children: sessions.filter(shouldShowSessionInHistory).map((session) => /* @__PURE__ */ jsx4(
+    SessionListItem,
+    {
+      session,
+      active: session.id === activeSessionId,
+      onClick: () => onSessionSelect(session.id)
+    },
+    session.id
+  )) });
+}
+export {
+  RELATIVE_TIME_FORMATTER,
+  SESSION_GROUPS,
+  SESSION_GROUP_LABELS,
+  SessionDetail,
+  SessionDetailTrigger,
+  SessionList,
+  SessionListItem,
+  StatusBadge,
+  formatRelativeTime,
+  getDisplaySessionStatus,
+  getSessionGroup,
+  getSessionLabel,
+  getSessionTimestamp,
+  getStatusMeta,
+  isReplaySession,
+  shouldShowSessionInHistory,
+  startOfDay,
+  startOfWeek
+};
+//# sourceMappingURL=index.js.map