@blade-hq/agent-kit 0.4.1 → 0.4.5

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

@@ -0,0 +1,2886 @@
+// src/react/components/workspace/WorkspaceFilesPanel.tsx
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { FileText, FolderTree, FolderUp, Loader2 as Loader22, PanelRightOpen, RefreshCw, Upload } from "lucide-react";
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState3 } from "react";
+
+// 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/lib/ui-meta.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isUiMeta(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const raw = value;
+  if (raw.target !== "inline" && raw.target !== "preview") {
+    return false;
+  }
+  if (!isPositiveNumber(raw.height)) {
+    return false;
+  }
+  if (!isNonEmptyString(raw.resourceHTML) && !isNonEmptyString(raw.resourceUri) && !isNonEmptyString(raw.resourceURI)) {
+    return false;
+  }
+  if (raw.title != null && !isNonEmptyString(raw.title)) {
+    return false;
+  }
+  return true;
+}
+
+// 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 getAuthedUrl(path) {
+  return getClient().buildAuthedUrl(path);
+}
+async function apiFetchText(path, init) {
+  return getClient().textFromInit(path, init);
+}
+async function apiFetchResponse(path, init) {
+  return getClient().responseFromInit(path, init);
+}
+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 deleteSession = (...args) => r2().deleteSession(...args);
+var listDir = (...args) => r2().listDir(...args);
+var uploadFiles = (...args) => r2().uploadFiles(...args);
+var deleteFile = (...args) => r2().deleteFile(...args);
+var renameFile = (...args) => r2().renameFile(...args);
+var copyFile = (...args) => r2().copyFile(...args);
+var getDownloadDirUrl = (...args) => r2().getDownloadDirUrl(...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/workspace/FileTree.tsx
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  ChevronRight,
+  Copy,
+  Download,
+  Link2,
+  Loader2,
+  Pencil,
+  Trash2
+} from "lucide-react";
+import { useEffect, useEffectEvent, useRef, useState as useState2 } from "react";
+
+// src/react/lib/session-file-preview.ts
+var IMAGE_EXTS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "svg", "webp", "ico", "bmp"]);
+var DOCX_EXTS = /* @__PURE__ */ new Set(["docx", "doc"]);
+var EXCEL_EXTS = /* @__PURE__ */ new Set(["xlsx", "xls", "xlsm", "xlsb"]);
+var PPT_EXTS = /* @__PURE__ */ new Set(["pptx", "ppt"]);
+var CSV_EXTS = /* @__PURE__ */ new Set(["csv"]);
+var MARKDOWN_EXTS = /* @__PURE__ */ new Set(["md", "markdown"]);
+var HTML_EXTS = /* @__PURE__ */ new Set(["html", "htm"]);
+function getExt(fileName) {
+  return fileName.split(".").pop()?.toLowerCase() ?? "";
+}
+function getDisplayFileName(filePath, fileName) {
+  return fileName?.trim() || filePath.split("/").pop() || filePath;
+}
+function getSessionFilePath(sessionId, filePath) {
+  return `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}`;
+}
+function getSessionFileDownloadUrl(sessionId, filePath) {
+  return getAuthedUrl(getSessionFilePath(sessionId, filePath));
+}
+function isTextualContentType(contentType) {
+  return contentType.startsWith("text/") || contentType.includes("json") || contentType.includes("xml") || contentType.includes("yaml") || contentType.includes("javascript");
+}
+function buildSessionBinaryPreviewTarget(sessionId, filePath, fileName) {
+  const resolvedFileName = getDisplayFileName(filePath, fileName);
+  const ext = getExt(resolvedFileName);
+  const filePathUrl = getSessionFilePath(sessionId, filePath);
+  const downloadUrl = getSessionFileDownloadUrl(sessionId, filePath);
+  if (IMAGE_EXTS.has(ext)) {
+    return { type: "image", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (ext === "pdf") {
+    return { type: "pdf", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (DOCX_EXTS.has(ext)) {
+    return { type: "docx", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (EXCEL_EXTS.has(ext)) {
+    return { type: "excel", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (PPT_EXTS.has(ext)) {
+    return {
+      type: "ppt",
+      content: filePathUrl,
+      sourceUrl: downloadUrl,
+      title: resolvedFileName,
+      key: filePath
+    };
+  }
+  return null;
+}
+async function resolveSessionFilePreviewTarget(sessionId, filePath, fileName) {
+  const resolvedFileName = getDisplayFileName(filePath, fileName);
+  const binaryTarget = buildSessionBinaryPreviewTarget(sessionId, filePath, resolvedFileName);
+  if (binaryTarget) {
+    return binaryTarget;
+  }
+  const downloadUrl = getSessionFileDownloadUrl(sessionId, filePath);
+  const res = await apiFetchResponse(getSessionFilePath(sessionId, filePath));
+  const contentType = (res.headers.get("content-type") ?? "").toLowerCase();
+  if (contentType.startsWith("video/")) {
+    void res.body?.cancel();
+    return { type: "video", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (contentType.startsWith("audio/")) {
+    void res.body?.cancel();
+    return { type: "audio", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  if (!isTextualContentType(contentType)) {
+    void res.body?.cancel();
+    return { type: "download", content: downloadUrl, title: resolvedFileName, key: filePath };
+  }
+  const content = await res.text();
+  const ext = getExt(resolvedFileName);
+  const type3 = MARKDOWN_EXTS.has(ext) ? "markdown" : CSV_EXTS.has(ext) ? "csv" : HTML_EXTS.has(ext) ? "html" : "file";
+  return {
+    type: type3,
+    content,
+    title: resolvedFileName,
+    key: filePath
+  };
+}
+
+// src/react/lib/open-session-file.ts
+async function openSessionFileInPreview(sessionId, filePath, fileName, pushArtifact, shouldOpen = () => true) {
+  try {
+    const target = await resolveSessionFilePreviewTarget(sessionId, filePath, fileName);
+    if (!shouldOpen()) {
+      return;
+    }
+    pushArtifact(target);
+  } catch {
+  }
+}
+
+// src/react/components/ui/collapsible.tsx
+import { Collapsible as CollapsiblePrimitive } from "radix-ui";
+import { jsx } from "react/jsx-runtime";
+function Collapsible({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(CollapsiblePrimitive.Root, { "data-slot": "collapsible", ...props });
+}
+function CollapsibleTrigger({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    CollapsiblePrimitive.CollapsibleTrigger,
+    {
+      "data-slot": "collapsible-trigger",
+      ...props
+    }
+  );
+}
+function CollapsibleContent({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    CollapsiblePrimitive.CollapsibleContent,
+    {
+      "data-slot": "collapsible-content",
+      ...props
+    }
+  );
+}
+
+// src/react/components/ai-elements/file-tree.tsx
+import {
+  ChevronRightIcon,
+  FileIcon,
+  FolderIcon,
+  FolderOpenIcon
+} from "lucide-react";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState
+} from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var noop = () => {
+};
+var FileTreeContext = createContext({
+  // oxlint-disable-next-line eslint-plugin-unicorn(no-new-builtin)
+  expandedPaths: /* @__PURE__ */ new Set(),
+  togglePath: noop
+});
+var FileTree = ({
+  expanded: controlledExpanded,
+  defaultExpanded = /* @__PURE__ */ new Set(),
+  selectedPath,
+  onSelect,
+  onExpandedChange,
+  className,
+  children,
+  ...props
+}) => {
+  const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+  const expandedPaths = controlledExpanded ?? internalExpanded;
+  const togglePath = useCallback(
+    (path) => {
+      const newExpanded = new Set(expandedPaths);
+      if (newExpanded.has(path)) {
+        newExpanded.delete(path);
+      } else {
+        newExpanded.add(path);
+      }
+      setInternalExpanded(newExpanded);
+      onExpandedChange?.(newExpanded);
+    },
+    [expandedPaths, onExpandedChange]
+  );
+  const contextValue = useMemo(
+    () => ({ expandedPaths, onSelect, selectedPath, togglePath }),
+    [expandedPaths, onSelect, selectedPath, togglePath]
+  );
+  return /* @__PURE__ */ jsx2(FileTreeContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: cn(
+        "rounded-lg border bg-background font-mono text-sm",
+        className
+      ),
+      role: "tree",
+      ...props,
+      children: /* @__PURE__ */ jsx2("div", { className: "p-2", children })
+    }
+  ) });
+};
+var FileTreeIcon = ({
+  className,
+  children,
+  ...props
+}) => /* @__PURE__ */ jsx2("span", { className: cn("shrink-0", className), ...props, children });
+var FileTreeName = ({
+  className,
+  children,
+  ...props
+}) => /* @__PURE__ */ jsx2("span", { className: cn("truncate", className), ...props, children });
+var FileTreeFolderContext = createContext({
+  isExpanded: false,
+  name: "",
+  path: ""
+});
+var FileTreeFileContext = createContext({
+  name: "",
+  path: ""
+});
+var stopPropagation = (e) => e.stopPropagation();
+var FileTreeActions = ({
+  className,
+  children,
+  ...props
+}) => /* @__PURE__ */ jsx2(
+  "div",
+  {
+    className: cn("ml-auto flex items-center gap-1", className),
+    onClick: stopPropagation,
+    onKeyDown: stopPropagation,
+    ...props,
+    children
+  }
+);
+
+// src/react/components/workspace/FileTree.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ROOT_PATH = ".";
+var TREE_ROW_CLASS = "group flex w-full items-center gap-1 rounded px-2 py-1 text-left transition-colors hover:bg-muted/50";
+var FILE_ICON_GROUPS = {
+  csv: "office",
+  doc: "office",
+  docx: "office",
+  ppt: "office",
+  pptx: "office",
+  rtf: "office",
+  tsv: "office",
+  xls: "office",
+  xlsx: "office",
+  odg: "open-document",
+  odp: "open-document",
+  ods: "open-document",
+  odt: "open-document",
+  epub: "document",
+  key: "document",
+  log: "document",
+  markdown: "document",
+  md: "document",
+  numbers: "document",
+  pages: "document",
+  pdf: "document",
+  tex: "document",
+  txt: "document",
+  ai: "image",
+  avif: "image",
+  bmp: "image",
+  gif: "image",
+  heic: "image",
+  heif: "image",
+  ico: "image",
+  jpeg: "image",
+  jpg: "image",
+  png: "image",
+  psd: "image",
+  svg: "image",
+  tif: "image",
+  tiff: "image",
+  webp: "image",
+  avi: "video",
+  flv: "video",
+  m4v: "video",
+  mkv: "video",
+  mov: "video",
+  mp4: "video",
+  webm: "video",
+  wmv: "video",
+  aac: "audio",
+  aiff: "audio",
+  flac: "audio",
+  m4a: "audio",
+  mid: "audio",
+  mp3: "audio",
+  ogg: "audio",
+  wav: "audio",
+  "7z": "archive",
+  bz2: "archive",
+  dmg: "archive",
+  gz: "archive",
+  iso: "archive",
+  pkg: "archive",
+  rar: "archive",
+  tar: "archive",
+  tgz: "archive",
+  xz: "archive",
+  zip: "archive",
+  c: "code",
+  cpp: "code",
+  cs: "code",
+  css: "code",
+  go: "code",
+  h: "code",
+  hpp: "code",
+  html: "code",
+  java: "code",
+  js: "code",
+  json: "code",
+  jsx: "code",
+  kt: "code",
+  lock: "code",
+  php: "code",
+  py: "code",
+  rb: "code",
+  rs: "code",
+  scss: "code",
+  sh: "code",
+  sql: "code",
+  svelte: "code",
+  swift: "code",
+  toml: "code",
+  ts: "code",
+  tsx: "code",
+  vue: "code",
+  xml: "code",
+  yaml: "code",
+  yml: "code",
+  zsh: "code",
+  db: "data",
+  jsonl: "data",
+  ndjson: "data",
+  parquet: "data",
+  plist: "data",
+  sqlite: "data",
+  otf: "font",
+  ttf: "font",
+  woff: "font",
+  woff2: "font",
+  blend: "design",
+  fig: "design",
+  sketch: "design",
+  xd: "design",
+  conf: "config",
+  env: "config",
+  ini: "config"
+};
+function FileTree2({
+  sessionId,
+  checkActiveSession = true,
+  enableEditor = false,
+  onExpandedDirsChange,
+  rootPath = ROOT_PATH,
+  readOnly = false,
+  onShareFile,
+  allowDelete = false,
+  onOpenFile
+}) {
+  const pushArtifact = useUiStore((state) => state.pushArtifact);
+  const [expandedDirs, setExpandedDirs] = useState2(/* @__PURE__ */ new Set([rootPath]));
+  const [selectedPath, setSelectedPath] = useState2();
+  const [openingFilePath, setOpeningFilePath] = useState2(null);
+  const isStreaming = useChatStore((s) => sessionId ? s.isStreaming[sessionId] ?? false : false);
+  const queryClient = useQueryClient();
+  const prevStreamingRef = useRef(isStreaming);
+  const applyExpandedDirs = useEffectEvent((dirs) => {
+    setExpandedDirs(dirs);
+    onExpandedDirsChange?.(dirs);
+  });
+  useEffect(() => {
+    if (prevStreamingRef.current && !isStreaming && sessionId) {
+      queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    }
+    prevStreamingRef.current = isStreaming;
+  }, [isStreaming, sessionId, queryClient]);
+  const onExpandedDirsChangeStable = useEffectEvent((dirs) => {
+    onExpandedDirsChange?.(dirs);
+  });
+  useEffect(() => {
+    onExpandedDirsChangeStable(expandedDirs);
+  }, []);
+  const handleExpandedChange = (dirs) => {
+    applyExpandedDirs(dirs);
+  };
+  const toggleExpandedDir = (path) => {
+    const next = new Set(expandedDirs);
+    if (next.has(path)) {
+      next.delete(path);
+    } else {
+      next.add(path);
+    }
+    handleExpandedChange(next);
+  };
+  const handleTreePathChange = useEffectEvent((previousPath, nextPath) => {
+    setSelectedPath((current) => {
+      if (!current) {
+        return current;
+      }
+      if (current === previousPath || current.startsWith(`${previousPath}/`)) {
+        if (!nextPath) {
+          return void 0;
+        }
+        return current === previousPath ? nextPath : `${nextPath}${current.slice(previousPath.length)}`;
+      }
+      return current;
+    });
+    const nextExpanded = /* @__PURE__ */ new Set();
+    for (const path of expandedDirs) {
+      if (path === previousPath || path.startsWith(`${previousPath}/`)) {
+        if (nextPath) {
+          nextExpanded.add(
+            path === previousPath ? nextPath : `${nextPath}${path.slice(previousPath.length)}`
+          );
+        }
+        continue;
+      }
+      nextExpanded.add(path);
+    }
+    handleExpandedChange(nextExpanded);
+  });
+  const {
+    data: rootEntries,
+    isLoading: rootLoading,
+    error: rootError
+  } = useQuery({
+    queryKey: ["file-tree", sessionId, rootPath],
+    queryFn: () => listDir(sessionId, rootPath),
+    enabled: !!sessionId,
+    refetchInterval: isStreaming ? 6e4 : false
+  });
+  const handleOpenFile = useEffectEvent(async (path, name) => {
+    if (!sessionId) return;
+    const currentSessionId = sessionId;
+    setOpeningFilePath(path);
+    setSelectedPath(path);
+    try {
+      if (onOpenFile) {
+        await onOpenFile(path, name);
+      } else if (enableEditor) {
+        const content = await apiFetchText(
+          `/api/sessions/${encodeURIComponent(sessionId)}/files/${encodeURIComponent(path)}`
+        );
+        void content;
+        alert("enableEditor \u9700\u5728\u5BBF\u4E3B\u5E94\u7528\u4E2D\u63D0\u4F9B onOpenFile");
+      } else {
+        await openSessionFileInPreview(sessionId, path, name, pushArtifact, () => {
+          return checkActiveSession ? useSessionStore.getState().activeSessionId === currentSessionId : true;
+        });
+      }
+    } finally {
+      setOpeningFilePath((current) => current === path ? null : current);
+    }
+  });
+  const handleSelect = (path) => {
+    setSelectedPath(path);
+  };
+  if (!sessionId) {
+    return /* @__PURE__ */ jsx3(EmptyState, { title: "\u6682\u65E0\u6D3B\u8DC3\u4F1A\u8BDD", description: "\u9009\u62E9\u6216\u521B\u5EFA\u4F1A\u8BDD\u540E\u67E5\u770B\u5DE5\u4F5C\u533A\u6587\u4EF6" });
+  }
+  if (rootLoading) {
+    return /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 px-3 py-4 text-sm text-[hsl(var(--muted-foreground))]", children: [
+      /* @__PURE__ */ jsx3(Loader2, { size: 14, className: "animate-spin" }),
+      /* @__PURE__ */ jsx3("span", { children: "\u52A0\u8F7D\u4E2D..." })
+    ] });
+  }
+  if (rootError) {
+    return /* @__PURE__ */ jsx3(
+      EmptyState,
+      {
+        title: "\u6587\u4EF6\u6811\u52A0\u8F7D\u5931\u8D25",
+        description: rootError instanceof Error ? rootError.message : "\u52A0\u8F7D\u5931\u8D25"
+      }
+    );
+  }
+  if (!rootEntries || rootEntries.length === 0) {
+    return /* @__PURE__ */ jsx3(EmptyState, { title: "\u5F53\u524D\u5DE5\u4F5C\u533A\u4E3A\u7A7A", description: "\u4F1A\u8BDD\u4EA7\u751F\u6587\u4EF6\u540E\u4F1A\u663E\u793A\u5728\u8FD9\u91CC" });
+  }
+  return /* @__PURE__ */ jsx3(
+    FileTree,
+    {
+      expanded: expandedDirs,
+      onExpandedChange: handleExpandedChange,
+      selectedPath,
+      onSelect: handleSelect,
+      className: "border-none bg-transparent",
+      children: rootEntries.map(
+        (entry) => entry.is_dir ? /* @__PURE__ */ jsx3(
+          FolderNode,
+          {
+            entry,
+            expandedDirs,
+            isStreaming,
+            onOpenFile: handleOpenFile,
+            onSelectPath: handleSelect,
+            onToggleDir: toggleExpandedDir,
+            onTreePathChange: handleTreePathChange,
+            openingFilePath,
+            selectedPath,
+            sessionId,
+            readOnly,
+            onShareFile,
+            allowDelete
+          },
+          entry.path
+        ) : /* @__PURE__ */ jsx3(
+          FileNode,
+          {
+            entry,
+            onOpenFile: handleOpenFile,
+            onSelectPath: handleSelect,
+            onTreePathChange: handleTreePathChange,
+            openingFilePath,
+            selectedPath,
+            sessionId,
+            readOnly,
+            onShareFile,
+            allowDelete
+          },
+          entry.path
+        )
+      )
+    }
+  );
+}
+function FolderNode({
+  entry,
+  expandedDirs,
+  isStreaming,
+  openingFilePath,
+  onOpenFile,
+  onSelectPath,
+  onToggleDir,
+  onTreePathChange,
+  selectedPath,
+  sessionId,
+  readOnly,
+  onShareFile,
+  allowDelete
+}) {
+  const queryClient = useQueryClient();
+  const isExpanded = expandedDirs.has(entry.path);
+  const isSelected = selectedPath === entry.path;
+  const renameInputRef = useRef(null);
+  const [isRenaming, setIsRenaming] = useState2(false);
+  const [renamingValue, setRenamingValue] = useState2(entry.name);
+  const [activeAction, setActiveAction] = useState2(null);
+  const downloadUrl = getDownloadDirUrl(sessionId, entry.path);
+  useEffect(() => {
+    if (!isRenaming) setRenamingValue(entry.name);
+  }, [entry.name, isRenaming]);
+  useEffect(() => {
+    if (!isRenaming) return;
+    renameInputRef.current?.focus();
+    renameInputRef.current?.select();
+  }, [isRenaming]);
+  const finishRename = useEffectEvent(async () => {
+    const nextName = renamingValue.trim();
+    if (!nextName || nextName === entry.name) {
+      setIsRenaming(false);
+      setRenamingValue(entry.name);
+      return;
+    }
+    setActiveAction("rename");
+    try {
+      const result = await renameFile(sessionId, entry.path, nextName);
+      onTreePathChange(entry.path, result.path);
+      setIsRenaming(false);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u91CD\u547D\u540D\u5931\u8D25"));
+      renameInputRef.current?.focus();
+      renameInputRef.current?.select();
+    } finally {
+      setActiveAction(null);
+    }
+  });
+  const cancelRename = () => {
+    setIsRenaming(false);
+    setRenamingValue(entry.name);
+  };
+  const handleCopy = async () => {
+    setActiveAction("copy");
+    try {
+      await copyFile(sessionId, entry.path);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u590D\u5236\u76EE\u5F55\u5931\u8D25"));
+    } finally {
+      setActiveAction(null);
+    }
+  };
+  const handleDelete = async () => {
+    if (!window.confirm(`\u786E\u8BA4\u5220\u9664\u76EE\u5F55"${entry.name}"\u5417\uFF1F`)) {
+      return;
+    }
+    setActiveAction("delete");
+    try {
+      await deleteFile(sessionId, entry.path);
+      onTreePathChange(entry.path);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u5220\u9664\u76EE\u5F55\u5931\u8D25"));
+    } finally {
+      setActiveAction(null);
+    }
+  };
+  return /* @__PURE__ */ jsx3(Collapsible, { open: isExpanded, onOpenChange: () => onToggleDir(entry.path), children: /* @__PURE__ */ jsxs2("div", { children: [
+    /* @__PURE__ */ jsxs2("div", { className: cn(TREE_ROW_CLASS, isSelected && "bg-muted"), children: [
+      /* @__PURE__ */ jsx3(CollapsibleTrigger, { asChild: true, children: /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: "flex shrink-0 cursor-pointer items-center rounded border-none bg-transparent p-0",
+          title: isExpanded ? "\u6536\u8D77\u76EE\u5F55" : "\u5C55\u5F00\u76EE\u5F55",
+          children: /* @__PURE__ */ jsx3(
+            ChevronRight,
+            {
+              className: cn(
+                "size-4 shrink-0 text-[hsl(var(--muted-foreground))] transition-transform",
+                isExpanded && "rotate-90"
+              )
+            }
+          )
+        }
+      ) }),
+      isRenaming ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        /* @__PURE__ */ jsx3(FileTreeIcon, { children: getFolderIcon() }),
+        /* @__PURE__ */ jsx3(
+          "input",
+          {
+            ref: renameInputRef,
+            value: renamingValue,
+            className: "h-6 min-w-0 flex-1 rounded border border-[hsl(var(--border))] bg-background px-2 text-xs outline-none ring-offset-background focus-visible:ring-1 focus-visible:ring-[hsl(var(--ring))]",
+            disabled: activeAction === "rename",
+            onBlur: () => void finishRename(),
+            onChange: (event) => setRenamingValue(event.target.value),
+            onClick: (event) => event.stopPropagation(),
+            onKeyDown: (event) => {
+              event.stopPropagation();
+              if (event.key === "Enter") {
+                event.preventDefault();
+                void finishRename();
+              } else if (event.key === "Escape") {
+                event.preventDefault();
+                cancelRename();
+              }
+            }
+          }
+        )
+      ] }) : /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          className: "flex min-w-0 flex-1 cursor-pointer items-center gap-1 border-none bg-transparent p-0 text-left",
+          onClick: () => {
+            onToggleDir(entry.path);
+            onSelectPath(entry.path);
+          },
+          children: [
+            /* @__PURE__ */ jsx3(FileTreeIcon, { children: getFolderIcon() }),
+            /* @__PURE__ */ jsx3(FileTreeName, { className: "min-w-0 flex-1", children: entry.name })
+          ]
+        }
+      ),
+      !readOnly ? /* @__PURE__ */ jsxs2(FileTreeActions, { className: "ml-auto hidden shrink-0 group-hover:flex", children: [
+        /* @__PURE__ */ jsx3(
+          TreeActionButton,
+          {
+            onClick: () => {
+              const anchor = document.createElement("a");
+              anchor.href = downloadUrl;
+              anchor.download = `${entry.name}.zip`;
+              anchor.click();
+            },
+            title: "\u4E0B\u8F7D\u76EE\u5F55",
+            children: /* @__PURE__ */ jsx3(Download, { size: 12 })
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TreeActionButton,
+          {
+            disabled: activeAction !== null,
+            onClick: () => {
+              onSelectPath(entry.path);
+              setRenamingValue(entry.name);
+              setIsRenaming(true);
+            },
+            title: "\u91CD\u547D\u540D",
+            children: activeAction === "rename" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Pencil, { size: 12 })
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TreeActionButton,
+          {
+            disabled: activeAction !== null,
+            onClick: () => void handleCopy(),
+            title: "\u590D\u5236\u76EE\u5F55",
+            children: activeAction === "copy" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Copy, { size: 12 })
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TreeActionButton,
+          {
+            disabled: activeAction !== null || !onShareFile,
+            onClick: async () => {
+              if (!onShareFile) return;
+              setActiveAction("share");
+              try {
+                await onShareFile(entry.path, entry.name);
+                await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+              } catch (error) {
+                alert(getErrorMessage(error, "\u5171\u4EAB\u5931\u8D25"));
+              } finally {
+                setActiveAction(null);
+              }
+            },
+            title: "\u5171\u4EAB\u5230 .share",
+            children: activeAction === "share" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Link2, { size: 12 })
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TreeActionButton,
+          {
+            disabled: activeAction !== null,
+            onClick: () => void handleDelete(),
+            title: "\u5220\u9664\u76EE\u5F55",
+            children: activeAction === "delete" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Trash2, { size: 12 })
+          }
+        )
+      ] }) : allowDelete ? /* @__PURE__ */ jsx3(FileTreeActions, { className: "ml-auto hidden shrink-0 group-hover:flex", children: /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          disabled: activeAction !== null,
+          onClick: () => void handleDelete(),
+          title: "\u5220\u9664\u76EE\u5F55",
+          children: activeAction === "delete" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Trash2, { size: 12 })
+        }
+      ) }) : null
+    ] }),
+    /* @__PURE__ */ jsx3(CollapsibleContent, { children: /* @__PURE__ */ jsx3("div", { className: "ml-4 border-l pl-2", children: /* @__PURE__ */ jsx3(
+      LazyDirChildren,
+      {
+        dirPath: entry.path,
+        expandedDirs,
+        isStreaming,
+        onOpenFile,
+        onSelectPath,
+        onToggleDir,
+        onTreePathChange,
+        openingFilePath,
+        selectedPath,
+        sessionId,
+        readOnly,
+        onShareFile,
+        allowDelete
+      }
+    ) }) })
+  ] }) });
+}
+function FileNode({
+  entry,
+  onOpenFile,
+  onSelectPath,
+  onTreePathChange,
+  openingFilePath,
+  selectedPath,
+  sessionId,
+  readOnly,
+  onShareFile,
+  allowDelete
+}) {
+  const downloadUrl = getAuthedUrl(`/api/sessions/${sessionId}/files/${encodeURIComponent(entry.path)}`);
+  const isOpening = openingFilePath === entry.path;
+  const isSelected = selectedPath === entry.path;
+  const queryClient = useQueryClient();
+  const renameInputRef = useRef(null);
+  const [isRenaming, setIsRenaming] = useState2(false);
+  const [renamingValue, setRenamingValue] = useState2(entry.name);
+  const [activeAction, setActiveAction] = useState2(null);
+  useEffect(() => {
+    if (!isRenaming) {
+      setRenamingValue(entry.name);
+    }
+  }, [entry.name, isRenaming]);
+  useEffect(() => {
+    if (!isRenaming) {
+      return;
+    }
+    renameInputRef.current?.focus();
+    renameInputRef.current?.select();
+  }, [isRenaming]);
+  const finishRename = useEffectEvent(async () => {
+    const nextName = renamingValue.trim();
+    if (!nextName || nextName === entry.name) {
+      setIsRenaming(false);
+      setRenamingValue(entry.name);
+      return;
+    }
+    setActiveAction("rename");
+    try {
+      const result = await renameFile(sessionId, entry.path, nextName);
+      onTreePathChange(entry.path, result.path);
+      setIsRenaming(false);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u91CD\u547D\u540D\u5931\u8D25"));
+      renameInputRef.current?.focus();
+      renameInputRef.current?.select();
+    } finally {
+      setActiveAction(null);
+    }
+  });
+  const cancelRename = () => {
+    setIsRenaming(false);
+    setRenamingValue(entry.name);
+  };
+  const handleCopy = async () => {
+    setActiveAction("copy");
+    try {
+      await copyFile(sessionId, entry.path);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u590D\u5236\u6587\u4EF6\u5931\u8D25"));
+    } finally {
+      setActiveAction(null);
+    }
+  };
+  const handleDelete = async () => {
+    if (!window.confirm(`\u786E\u8BA4\u5220\u9664"${entry.name}"\u5417\uFF1F`)) {
+      return;
+    }
+    setActiveAction("delete");
+    try {
+      await deleteFile(sessionId, entry.path);
+      onTreePathChange(entry.path);
+      await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+    } catch (error) {
+      alert(getErrorMessage(error, "\u5220\u9664\u6587\u4EF6\u5931\u8D25"));
+    } finally {
+      setActiveAction(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: cn(TREE_ROW_CLASS, isSelected && "bg-muted"), children: [
+    /* @__PURE__ */ jsx3("span", { className: "size-4 shrink-0" }),
+    /* @__PURE__ */ jsx3(FileTreeIcon, { children: getFileIcon(entry.name) }),
+    isRenaming ? /* @__PURE__ */ jsx3(
+      "input",
+      {
+        ref: renameInputRef,
+        value: renamingValue,
+        className: "h-6 min-w-0 flex-1 rounded border border-[hsl(var(--border))] bg-background px-2 text-xs outline-none ring-offset-background focus-visible:ring-1 focus-visible:ring-[hsl(var(--ring))]",
+        disabled: activeAction === "rename",
+        onBlur: () => void finishRename(),
+        onChange: (event) => setRenamingValue(event.target.value),
+        onClick: (event) => event.stopPropagation(),
+        onKeyDown: (event) => {
+          event.stopPropagation();
+          if (event.key === "Enter") {
+            event.preventDefault();
+            void finishRename();
+          } else if (event.key === "Escape") {
+            event.preventDefault();
+            cancelRename();
+          }
+        }
+      }
+    ) : /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        type: "button",
+        className: "flex min-w-0 flex-1 cursor-pointer items-center border-none bg-transparent p-0 text-left",
+        onClick: () => {
+          onSelectPath(entry.path);
+          void onOpenFile(entry.path, entry.name);
+        },
+        children: [
+          /* @__PURE__ */ jsx3(FileTreeName, { className: "min-w-0 flex-1", children: entry.name }),
+          /* @__PURE__ */ jsx3(FileTagList, { tags: entry.tags })
+        ]
+      }
+    ),
+    isOpening ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "ml-auto shrink-0 animate-spin text-[hsl(var(--muted-foreground))]" }) : !readOnly ? /* @__PURE__ */ jsxs2(FileTreeActions, { className: "ml-auto hidden shrink-0 group-hover:flex", children: [
+      /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          onClick: () => {
+            const anchor = document.createElement("a");
+            anchor.href = downloadUrl;
+            anchor.download = entry.name;
+            anchor.click();
+          },
+          title: "\u4E0B\u8F7D\u6587\u4EF6",
+          children: /* @__PURE__ */ jsx3(Download, { size: 12 })
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          disabled: activeAction !== null,
+          onClick: () => {
+            onSelectPath(entry.path);
+            setRenamingValue(entry.name);
+            setIsRenaming(true);
+          },
+          title: "\u91CD\u547D\u540D",
+          children: activeAction === "rename" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Pencil, { size: 12 })
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          disabled: activeAction !== null,
+          onClick: () => void handleCopy(),
+          title: "\u590D\u5236\u6587\u4EF6",
+          children: activeAction === "copy" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Copy, { size: 12 })
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          disabled: activeAction !== null || !onShareFile,
+          onClick: async () => {
+            if (!onShareFile) return;
+            setActiveAction("share");
+            try {
+              await onShareFile(entry.path, entry.name);
+              await queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+            } catch (error) {
+              alert(getErrorMessage(error, "\u5171\u4EAB\u5931\u8D25"));
+            } finally {
+              setActiveAction(null);
+            }
+          },
+          title: "\u5171\u4EAB\u5230 .share",
+          children: activeAction === "share" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Link2, { size: 12 })
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        TreeActionButton,
+        {
+          disabled: activeAction !== null,
+          onClick: () => void handleDelete(),
+          title: "\u5220\u9664\u6587\u4EF6",
+          children: activeAction === "delete" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Trash2, { size: 12 })
+        }
+      )
+    ] }) : allowDelete ? /* @__PURE__ */ jsx3(FileTreeActions, { className: "ml-auto hidden shrink-0 group-hover:flex", children: /* @__PURE__ */ jsx3(
+      TreeActionButton,
+      {
+        disabled: activeAction !== null,
+        onClick: () => void handleDelete(),
+        title: "\u5220\u9664\u6587\u4EF6",
+        children: activeAction === "delete" ? /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx3(Trash2, { size: 12 })
+      }
+    ) }) : null
+  ] });
+}
+function LazyDirChildren({
+  dirPath,
+  expandedDirs,
+  isStreaming,
+  onOpenFile,
+  onSelectPath,
+  onToggleDir,
+  onTreePathChange,
+  openingFilePath,
+  selectedPath,
+  sessionId,
+  readOnly,
+  onShareFile,
+  allowDelete
+}) {
+  const {
+    data: entries,
+    isLoading,
+    error
+  } = useQuery({
+    queryKey: ["file-tree", sessionId, dirPath],
+    queryFn: () => listDir(sessionId, dirPath),
+    refetchInterval: isStreaming ? 6e4 : false
+  });
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 px-2 py-1 text-xs text-[hsl(var(--muted-foreground))]", children: [
+      /* @__PURE__ */ jsx3(Loader2, { size: 12, className: "animate-spin" }),
+      /* @__PURE__ */ jsx3("span", { children: "\u52A0\u8F7D\u4E2D..." })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3("div", { className: "px-2 py-1 text-xs text-[hsl(var(--muted-foreground))]", children: error instanceof Error ? error.message : "\u52A0\u8F7D\u5931\u8D25" });
+  }
+  if (!entries || entries.length === 0) {
+    return /* @__PURE__ */ jsx3("div", { className: "px-2 py-1 text-xs text-[hsl(var(--muted-foreground))]", children: "\u7A7A\u76EE\u5F55" });
+  }
+  return /* @__PURE__ */ jsx3(Fragment2, { children: entries.map(
+    (child) => child.is_dir ? /* @__PURE__ */ jsx3(
+      FolderNode,
+      {
+        entry: child,
+        expandedDirs,
+        isStreaming,
+        onOpenFile,
+        onSelectPath,
+        onToggleDir,
+        onTreePathChange,
+        openingFilePath,
+        selectedPath,
+        sessionId,
+        readOnly,
+        onShareFile,
+        allowDelete
+      },
+      child.path
+    ) : /* @__PURE__ */ jsx3(
+      FileNode,
+      {
+        entry: child,
+        onOpenFile,
+        onSelectPath,
+        onTreePathChange,
+        openingFilePath,
+        selectedPath,
+        sessionId,
+        readOnly,
+        onShareFile,
+        allowDelete
+      },
+      child.path
+    )
+  ) });
+}
+function FileTagList({ tags }) {
+  if (!tags || tags.length === 0) return null;
+  return /* @__PURE__ */ jsx3("span", { className: "ml-2 flex min-w-0 shrink-0 items-center gap-1", children: tags.map((tag) => /* @__PURE__ */ jsx3(
+    "span",
+    {
+      className: "max-w-20 truncate rounded border border-[hsl(var(--border))] bg-[hsl(var(--muted))] px-1.5 py-0.5 text-[10px] leading-none text-[hsl(var(--muted-foreground))]",
+      title: tag,
+      children: tag
+    },
+    tag
+  )) });
+}
+function TreeActionButton({
+  children,
+  disabled = false,
+  onClick,
+  title
+}) {
+  return /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      disabled,
+      onClick,
+      title,
+      className: "flex items-center rounded p-1 text-[hsl(var(--muted-foreground))] transition-colors hover:bg-[hsl(var(--muted-foreground))/10] hover:text-[hsl(var(--foreground))] disabled:cursor-not-allowed disabled:opacity-50",
+      children
+    }
+  );
+}
+function EmptyState({ title, description }) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex h-full min-h-[12rem] flex-col items-center justify-center gap-3 px-6 text-center", children: [
+    /* @__PURE__ */ jsx3("div", { className: "flex h-10 w-10 items-center justify-center text-[hsl(var(--muted-foreground))]", children: getFolderIcon() }),
+    /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+      /* @__PURE__ */ jsx3("div", { className: "text-sm font-medium text-[hsl(var(--foreground))]", children: title }),
+      /* @__PURE__ */ jsx3("div", { className: "text-sm text-[hsl(var(--muted-foreground))]", children: description })
+    ] })
+  ] });
+}
+function getFileIcon(fileName) {
+  const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+  const group = FILE_ICON_GROUPS[ext];
+  const src = group ? `/file-icons/${group}/${ext}.png` : "/file-icons/generic-file.png";
+  return /* @__PURE__ */ jsx3(FileTypeIcon, { src, alt: `${ext || "file"} \u6587\u4EF6` });
+}
+function getFolderIcon() {
+  return /* @__PURE__ */ jsx3(FileTypeIcon, { src: "/file-icons/folder.png", alt: "\u6587\u4EF6\u5939" });
+}
+function FileTypeIcon({ src, alt }) {
+  return /* @__PURE__ */ jsx3(
+    "img",
+    {
+      src,
+      alt,
+      className: "size-4 shrink-0 object-contain",
+      draggable: false,
+      loading: "lazy"
+    }
+  );
+}
+function getErrorMessage(error, fallback) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return fallback;
+}
+
+// src/react/components/workspace/WorkspaceFilesPanel.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var EMPTY_MESSAGES = [];
+function WorkspaceFilesPanel({
+  sessionId,
+  enableEditor = false,
+  className,
+  treeContainerClassName,
+  title = "\u5DE5\u4F5C\u533A",
+  rootPath = ".",
+  readOnly = false,
+  onShareFile,
+  onSync,
+  allowDelete = false,
+  topSlot,
+  onOpenFile
+}) {
+  const [expandedDirs, setExpandedDirs] = useState3(/* @__PURE__ */ new Set());
+  const [isUploading, setIsUploading] = useState3(false);
+  const [activeTab, setActiveTab] = useState3("files");
+  const [isSyncing, setIsSyncing] = useState3(false);
+  const queryClient = useQueryClient2();
+  const fileInputRef = useRef2(null);
+  const folderInputRef = useRef2(null);
+  const messages = useChatStore(
+    (state) => sessionId ? state.messages[sessionId] ?? EMPTY_MESSAGES : EMPTY_MESSAGES
+  );
+  const pushArtifact = useUiStore((state) => state.pushArtifact);
+  const inlineResources = useMemo2(() => {
+    if (!sessionId) return [];
+    return messages.flatMap(
+      (message, messageIndex) => (message.blocks ?? []).flatMap((block, blockIndex) => {
+        if (block.type !== "tool_ui" || !isUiMeta(block.content) || block.content.target !== "inline") {
+          return [];
+        }
+        const ui = block.content;
+        const type3 = ui.resourceHTML ? "resource-html" : "resource-uri";
+        const content = ui.resourceHTML ?? ui.resourceUri ?? ui.resourceURI ?? "";
+        if (!content) return [];
+        const title2 = ui.title ?? (typeof block.display_name === "string" && block.display_name.trim().length > 0 ? block.display_name : "\u53EF\u89C6\u5316\u4EA7\u7269");
+        const key = `${message.entry_id ?? message.timestamp ?? messageIndex}-${block.tool_call_id ?? "ui"}-${blockIndex}`;
+        return [
+          {
+            key,
+            title: title2,
+            target: {
+              type: type3,
+              content,
+              title: title2,
+              key,
+              bridgeSessionId: sessionId
+            }
+          }
+        ];
+      })
+    );
+  }, [messages, sessionId]);
+  useEffect2(() => {
+    if (activeTab === "resources" && inlineResources.length === 0) {
+      setActiveTab("files");
+    }
+  }, [activeTab, inlineResources.length]);
+  const uploadTargetDir = () => {
+    const candidates = Array.from(expandedDirs).filter((path) => path !== ".").filter((path) => {
+      const parts = path.split("/").filter(Boolean);
+      for (let index = 1; index < parts.length; index += 1) {
+        const ancestor = parts.slice(0, index).join("/");
+        if (!expandedDirs.has(ancestor)) return false;
+      }
+      return true;
+    });
+    if (candidates.length === 0) {
+      return ".";
+    }
+    return candidates.reduce((deepestPath, currentPath) => {
+      const deepestDepth = deepestPath.split("/").filter(Boolean).length;
+      const currentDepth = currentPath.split("/").filter(Boolean).length;
+      return currentDepth > deepestDepth ? currentPath : deepestPath;
+    }, candidates[0] ?? ".");
+  };
+  const handleUploadChange = async (event) => {
+    const files = event.target.files;
+    if (!sessionId || !files || files.length === 0) {
+      event.target.value = "";
+      return;
+    }
+    setIsUploading(true);
+    try {
+      const targetDir = uploadTargetDir();
+      const result = await uploadFiles(sessionId, targetDir, files);
+      await queryClient.invalidateQueries({
+        queryKey: ["file-tree", sessionId],
+        refetchType: "all"
+      });
+      await queryClient.refetchQueries({
+        queryKey: ["file-tree", sessionId],
+        type: "active"
+      });
+      if (targetDir !== ".") {
+        setExpandedDirs((prev) => {
+          const next = new Set(prev);
+          next.add(targetDir);
+          return next;
+        });
+      }
+      if (result.failed.length > 0) {
+        alert(`\u90E8\u5206\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25: ${result.failed.join(", ")}`);
+      }
+    } catch (error) {
+      console.error("Upload files failed", error);
+      alert("\u4E0A\u4F20\u6587\u4EF6\u5931\u8D25");
+    } finally {
+      setIsUploading(false);
+      event.target.value = "";
+    }
+  };
+  const handleUploadClick = () => {
+    fileInputRef.current?.click();
+  };
+  const handleFolderUploadClick = () => {
+    folderInputRef.current?.click();
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: cn("flex flex-col", className), children: [
+    topSlot ? /* @__PURE__ */ jsx4("div", { className: "mb-3", children: topSlot }) : null,
+    /* @__PURE__ */ jsxs3("div", { className: "mb-2 flex shrink-0 items-center justify-between gap-2", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "flex min-w-0 items-center gap-1 rounded-lg bg-[hsl(var(--muted))]/60 p-0.5 text-[11px] font-medium", children: [
+        /* @__PURE__ */ jsxs3(
+          "button",
+          {
+            type: "button",
+            onClick: () => setActiveTab("files"),
+            className: cn(
+              "inline-flex items-center gap-1.5 rounded-md px-2 py-1 transition-colors",
+              activeTab === "files" ? "bg-[hsl(var(--background))] text-[hsl(var(--foreground))] shadow-sm" : "text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))]"
+            ),
+            children: [
+              /* @__PURE__ */ jsx4(FolderTree, { size: 12 }),
+              title
+            ]
+          }
+        ),
+        inlineResources.length > 0 ? /* @__PURE__ */ jsxs3(
+          "button",
+          {
+            type: "button",
+            onClick: () => setActiveTab("resources"),
+            className: cn(
+              "inline-flex items-center gap-1.5 rounded-md px-2 py-1 transition-colors",
+              activeTab === "resources" ? "bg-[hsl(var(--background))] text-[hsl(var(--foreground))] shadow-sm" : "text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))]"
+            ),
+            children: [
+              /* @__PURE__ */ jsx4(PanelRightOpen, { size: 12 }),
+              "\u53EF\u89C6\u5316\u4EA7\u7269",
+              /* @__PURE__ */ jsx4("span", { className: "font-mono text-[10px] text-[hsl(var(--muted-foreground))]", children: inlineResources.length })
+            ]
+          }
+        ) : null
+      ] }),
+      onSync ? /* @__PURE__ */ jsx4("div", { className: "flex items-center gap-1", children: /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          disabled: !sessionId || isSyncing,
+          onClick: async () => {
+            setIsSyncing(true);
+            try {
+              await onSync();
+              await queryClient.invalidateQueries({
+                queryKey: ["file-tree", sessionId],
+                refetchType: "all"
+              });
+            } finally {
+              setIsSyncing(false);
+            }
+          },
+          className: "rounded p-1 text-[hsl(var(--muted-foreground))] transition-colors hover:bg-[hsl(var(--muted-foreground))/10] hover:text-[hsl(var(--foreground))] disabled:cursor-not-allowed disabled:opacity-50",
+          title: "\u540C\u6B65\u5171\u4EAB\u533A",
+          children: isSyncing ? /* @__PURE__ */ jsx4(Loader22, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx4(RefreshCw, { size: 12 })
+        }
+      ) }) : null,
+      !readOnly && activeTab === "files" ? /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-1", children: [
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            disabled: !sessionId || isUploading,
+            onClick: handleUploadClick,
+            className: "rounded p-1 text-[hsl(var(--muted-foreground))] transition-colors hover:bg-[hsl(var(--muted-foreground))/10] hover:text-[hsl(var(--foreground))] disabled:cursor-not-allowed disabled:opacity-50",
+            title: "\u4E0A\u4F20\u6587\u4EF6",
+            children: isUploading ? /* @__PURE__ */ jsx4(Loader22, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx4(Upload, { size: 12 })
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            disabled: !sessionId || isUploading,
+            onClick: handleFolderUploadClick,
+            className: "rounded p-1 text-[hsl(var(--muted-foreground))] transition-colors hover:bg-[hsl(var(--muted-foreground))/10] hover:text-[hsl(var(--foreground))] disabled:cursor-not-allowed disabled:opacity-50",
+            title: "\u4E0A\u4F20\u6587\u4EF6\u5939",
+            children: isUploading ? /* @__PURE__ */ jsx4(Loader22, { size: 12, className: "animate-spin" }) : /* @__PURE__ */ jsx4(FolderUp, { size: 12 })
+          }
+        )
+      ] }) : null
+    ] }),
+    activeTab === "resources" && inlineResources.length > 0 ? /* @__PURE__ */ jsx4("div", { className: cn("min-h-0 overflow-auto", treeContainerClassName), children: /* @__PURE__ */ jsx4("div", { className: "flex flex-col gap-1.5", children: inlineResources.map((item, index) => /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        type: "button",
+        onClick: () => pushArtifact(item.target),
+        className: "group flex min-w-0 items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm transition-colors hover:bg-[hsl(var(--muted))]",
+        title: item.title,
+        children: [
+          /* @__PURE__ */ jsx4(FileText, { size: 14, className: "shrink-0 text-[hsl(var(--primary))]" }),
+          /* @__PURE__ */ jsx4("span", { className: "min-w-0 flex-1 truncate text-[hsl(var(--foreground))]", children: item.title }),
+          /* @__PURE__ */ jsx4("span", { className: "shrink-0 font-mono text-[10px] text-[hsl(var(--muted-foreground))]", children: index + 1 })
+        ]
+      },
+      item.key
+    )) }) }) : /* @__PURE__ */ jsx4("div", { className: treeContainerClassName, children: /* @__PURE__ */ jsx4(
+      FileTree2,
+      {
+        sessionId,
+        enableEditor,
+        onExpandedDirsChange: setExpandedDirs,
+        rootPath,
+        readOnly,
+        onShareFile,
+        allowDelete,
+        onOpenFile
+      },
+      sessionId ?? "workspace-empty"
+    ) }),
+    /* @__PURE__ */ jsx4(
+      "input",
+      {
+        ref: fileInputRef,
+        type: "file",
+        multiple: true,
+        className: "hidden",
+        onChange: handleUploadChange
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      "input",
+      {
+        ref: folderInputRef,
+        type: "file",
+        multiple: true,
+        className: "hidden",
+        onChange: handleUploadChange,
+        ...{ webkitdirectory: "" }
+      }
+    )
+  ] });
+}
+export {
+  FileTree2 as FileTree,
+  WorkspaceFilesPanel
+};
+//# sourceMappingURL=index.js.map