@blade-hq/agent-react 2612.0.0-beta.77 → 2612.0.0-beta.78

package/dist/chunk-F4MWGSKX.js

@@ -0,0 +1,1308 @@
+import {
+  useBladeClient,
+  useSessionHandle,
+  useSessionState
+} from "./chunk-NRYLAO3X.js";
+import {
+  SessionPluginConfigForm
+} from "./chunk-SK43YNRX.js";
+import {
+  LoaderCircle,
+  Puzzle
+} from "./chunk-KHJEIHMJ.js";
+
+// src/chat/runtime/input-history-storage.ts
+var generation = 0;
+function getInputHistoryGeneration() {
+  return generation;
+}
+
+// src/chat/runtime/input-cache-reset.ts
+var resetters = /* @__PURE__ */ new WeakMap();
+function onInputCachesReset(client, reset) {
+  let set = resetters.get(client);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    resetters.set(client, set);
+  }
+  set.add(reset);
+  return () => {
+    set.delete(reset);
+  };
+}
+
+// src/rich-input/lib/plugin-suggestions.ts
+var accountPreparation = /* @__PURE__ */ new WeakMap();
+var registeredClients = /* @__PURE__ */ new WeakSet();
+function pluginRefsForSend(refs, turns = []) {
+  const latest = [...turns].reverse().find((turn) => turn.role === "user");
+  return refs.length || latest?.refs?.length ? refs : void 0;
+}
+function prepareAccount(client) {
+  if (!registeredClients.has(client)) {
+    registeredClients.add(client);
+    onInputCachesReset(client, () => accountPreparation.delete(client));
+  }
+  const current = accountPreparation.get(client);
+  if (current && current.token === client.token) return current.ready;
+  const ready = client.plugins.catalog().catch((error) => {
+    accountPreparation.delete(client);
+    throw error;
+  });
+  accountPreparation.set(client, { token: client.token, ready });
+  return ready;
+}
+async function getPluginSuggestionItems(client, session, query, pendingPlugins = []) {
+  if (!session && pendingPlugins.length === 0) return [];
+  const path = session ? `/api/sessions/${encodeURIComponent(session)}/plugin-tools/mentions` : "/api/plugin-mentions/mentions";
+  try {
+    if (!session) await prepareAccount(client);
+    const data = await client.json("POST", path, { arguments: { query, cursor: "" }, ...!session ? { plugin_selection: pendingPlugins } : {} });
+    return [...data.items.map((item) => ({ ...item, kind: "plugin", name: item.label })), ...data.errors.map((message) => ({ kind: "pluginError", message }))];
+  } catch {
+    return [{ kind: "pluginError", message: "\u63D2\u4EF6\u6761\u76EE\u6682\u65F6\u65E0\u6CD5\u52A0\u8F7D\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165 @ \u91CD\u8BD5" }];
+  }
+}
+
+// src/chat/runtime/input-services.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+function parseModelReasoningLevels(value) {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return Object.fromEntries(
+      Object.entries(parsed).filter(
+        (entry) => Boolean(entry[0]) && typeof entry[1] === "string" && Boolean(entry[1])
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+var RichInputServicesContext = createContext({});
+function RichInputServicesProvider({ value, children }) {
+  return /* @__PURE__ */ jsx(RichInputServicesContext.Provider, { value, children });
+}
+function useRichInputServices() {
+  return useContext(RichInputServicesContext);
+}
+
+// src/rich-input/lib/client-query.ts
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+var EMPTY = { data: void 0, error: null, isLoading: false, isFetching: false };
+var caches = /* @__PURE__ */ new WeakMap();
+function entryFor(client, key) {
+  let cache = caches.get(client);
+  if (!cache) {
+    const created = /* @__PURE__ */ new Map();
+    cache = created;
+    caches.set(client, created);
+    onInputCachesReset(client, () => {
+      for (const [key2, entry2] of created) {
+        entry2.request = null;
+        entry2.fetchedAt = 0;
+        update(entry2, EMPTY);
+        const load = loadersFor(client).get(key2);
+        if (load && entry2.listeners.size > 0) void fetchClientQuery(client, key2, load, { force: true }).catch(() => {
+        });
+      }
+    });
+  }
+  let entry = cache.get(key);
+  if (!entry) {
+    entry = { snapshot: EMPTY, fetchedAt: 0, request: null, listeners: /* @__PURE__ */ new Set() };
+    cache.set(key, entry);
+  }
+  return entry;
+}
+function update(entry, patch) {
+  entry.snapshot = { ...entry.snapshot, ...patch };
+  for (const listener of [...entry.listeners]) listener();
+}
+function fetchClientQuery(client, key, load, { staleMs = 3e4, force = false } = {}) {
+  const entry = entryFor(client, key);
+  if (entry.request) return entry.request;
+  if (!force && entry.snapshot.data !== void 0 && Date.now() - entry.fetchedAt < staleMs) {
+    return Promise.resolve(entry.snapshot.data);
+  }
+  const request = Promise.resolve().then(() => load(client));
+  entry.request = request;
+  update(entry, { isFetching: true, isLoading: entry.snapshot.data === void 0 });
+  request.then(
+    (data) => {
+      if (entry.request !== request) return;
+      entry.request = null;
+      entry.fetchedAt = Date.now();
+      update(entry, { data, error: null, isFetching: false, isLoading: false });
+    },
+    (error) => {
+      if (entry.request !== request) return;
+      entry.request = null;
+      update(entry, { error, isFetching: false, isLoading: false });
+    }
+  );
+  return request;
+}
+function setClientQueryData(client, key, updater) {
+  const entry = entryFor(client, key);
+  if (entry.snapshot.data === void 0) return;
+  update(entry, { data: updater(entry.snapshot.data) });
+}
+function useClientQuery(key, load, { staleMs = 3e4 } = {}) {
+  const client = useBladeClient();
+  const subscribe = useCallback(
+    (listener) => {
+      if (!key) return () => {
+      };
+      const entry = entryFor(client, key);
+      entry.listeners.add(listener);
+      return () => {
+        entry.listeners.delete(listener);
+      };
+    },
+    [client, key]
+  );
+  const snapshot = useSyncExternalStore(
+    subscribe,
+    () => key ? entryFor(client, key).snapshot : EMPTY,
+    () => key ? entryFor(client, key).snapshot : EMPTY
+  );
+  if (key) loadersFor(client).set(key, load);
+  useEffect(() => {
+    if (!key) return;
+    const registered = loadersFor(client).get(key);
+    if (registered) void fetchClientQuery(client, key, registered, { staleMs }).catch(() => {
+    });
+  }, [client, key, staleMs]);
+  const refetch = useCallback(async () => {
+    if (!key) return void 0;
+    const registered = loadersFor(client).get(key);
+    if (!registered) return void 0;
+    return fetchClientQuery(client, key, registered, { force: true }).catch(() => void 0);
+  }, [client, key]);
+  return { ...snapshot, refetch };
+}
+var loaderRegistry = /* @__PURE__ */ new WeakMap();
+function loadersFor(client) {
+  let loaders = loaderRegistry.get(client);
+  if (!loaders) {
+    loaders = /* @__PURE__ */ new Map();
+    loaderRegistry.set(client, loaders);
+  }
+  return loaders;
+}
+function refreshClientQuery(client, key) {
+  const entry = caches.get(client)?.get(key);
+  if (!entry) return;
+  entry.fetchedAt = 0;
+  const load = loadersFor(client).get(key);
+  if (load && entry.listeners.size > 0) void fetchClientQuery(client, key, load, { force: true }).catch(() => {
+  });
+}
+
+// src/rich-input/lib/session-data.ts
+import { useEffect as useEffect2, useRef } from "react";
+var sessionPath = (sessionId, rest) => `/api/sessions/${encodeURIComponent(sessionId)}/${rest}`;
+function useRefreshWhenRunEnds(sessionId, keys) {
+  const client = useBladeClient();
+  const streaming = useSessionState(sessionId, (state) => state.isStreaming);
+  const wasStreaming = useRef(streaming);
+  useEffect2(() => {
+    if (wasStreaming.current && !streaming) {
+      for (const key of keys) refreshClientQuery(client, key);
+    }
+    wasStreaming.current = streaming;
+  });
+}
+function useClientSessionSkills(sessionId) {
+  const key = sessionId ? `session-skills:${sessionId}` : null;
+  const query = useClientQuery(
+    key,
+    (client) => client.json("GET", sessionPath(sessionId ?? "", "skills"))
+  );
+  useRefreshWhenRunEnds(sessionId, key ? [key] : []);
+  return { data: query.data, loading: query.isLoading, error: query.error };
+}
+function useClientSkillStats(sessionId) {
+  const key = sessionId ? `skill-stats:${sessionId}` : null;
+  const query = useClientQuery(key, (client) => client.json("GET", sessionPath(sessionId ?? "", "skill-stats")), {
+    staleMs: 3e5
+  });
+  useRefreshWhenRunEnds(sessionId, key ? [key] : []);
+  return { data: query.data, loading: query.isLoading, error: query.error };
+}
+function useClientContextStats(sessionId) {
+  const key = sessionId ? `context-stats:${sessionId}` : null;
+  const query = useClientQuery(
+    key,
+    (client) => client.json("GET", sessionPath(sessionId ?? "", "context-stats"))
+  );
+  useRefreshWhenRunEnds(sessionId, key ? [key] : []);
+  return { data: query.data, loading: query.isLoading, error: query.error };
+}
+function useClientBackgroundTasks(sessionId) {
+  const client = useBladeClient();
+  const key = sessionId ? `background-tasks:${sessionId}` : null;
+  const query = useClientQuery(key, (c) => c.sessions.listBackgroundTasks(sessionId ?? ""));
+  const session = useSessionHandle(sessionId);
+  useEffect2(() => {
+    if (!session || !key) return;
+    return session.on("backgroundTask", () => refreshClientQuery(client, key));
+  }, [client, key, session]);
+  return { data: query.data, loading: query.isLoading, error: query.error };
+}
+function refreshClientSessionSkills(client, sessionId) {
+  refreshClientQuery(client, `session-skills:${sessionId}`);
+  refreshClientQuery(client, `skill-stats:${sessionId}`);
+}
+function useClientSessionModel(sessionId) {
+  const key = sessionId ? `session-detail:${sessionId}` : null;
+  const query = useClientQuery(key, (client) => client.sessions.getSession(sessionId ?? ""));
+  useRefreshWhenRunEnds(sessionId, key ? [key] : []);
+  return query.data?.model ?? null;
+}
+
+// src/rich-input/model/model-data.ts
+var EMPTY_MODELS = [];
+var EMPTY_IDS = [];
+var CATALOG_KEY = "model-catalog";
+function useClientModelCatalog() {
+  const { data, isLoading, isFetching, refetch } = useClientQuery(
+    CATALOG_KEY,
+    (client) => client.json("GET", "/api/config/models"),
+    { staleMs: 0 }
+  );
+  return {
+    models: data?.models ?? EMPTY_MODELS,
+    defaultModel: data?.default ?? "",
+    thinkingAvailable: data?.thinkingAvailable ?? false,
+    unavailableProviderIds: data?.unavailableProviderIds ?? EMPTY_IDS,
+    unavailableModelIds: data?.unavailableModelIds ?? EMPTY_IDS,
+    isLoading,
+    isFetching,
+    refresh: async () => {
+      await refetch();
+    }
+  };
+}
+var PREFERRED_MODEL_KEY = "preferred_model";
+var MODEL_REASONING_LEVELS_KEY = "llm.model_thinking_preferences";
+var PREFERENCES_KEY = "model-preferences";
+function loadPreferences(client) {
+  const query = new URLSearchParams();
+  query.append("key", PREFERRED_MODEL_KEY);
+  query.append("key", MODEL_REASONING_LEVELS_KEY);
+  return client.json("GET", `/api/user/preferences?${query.toString()}`).then((response) => response.values ?? {});
+}
+async function writePreference(client, key, value) {
+  const previous = await fetchClientQuery(client, PREFERENCES_KEY, loadPreferences, { staleMs: 6e4 }).catch(
+    () => ({})
+  );
+  setClientQueryData(client, PREFERENCES_KEY, (current) => ({ ...current, [key]: value }));
+  try {
+    await client.json("PUT", `/api/user/preferences/${encodeURIComponent(key)}`, { value });
+  } catch {
+    setClientQueryData(client, PREFERENCES_KEY, (current) => ({ ...current, [key]: previous[key] ?? null }));
+  }
+}
+var EMPTY_LEVELS = {};
+function useClientModelPreferences() {
+  const client = useBladeClient();
+  const { data } = useClientQuery(PREFERENCES_KEY, loadPreferences, { staleMs: 6e4 });
+  const rawLevels = data?.[MODEL_REASONING_LEVELS_KEY] ?? null;
+  const reasoningLevels = rawLevels ? parseModelReasoningLevels(rawLevels) : EMPTY_LEVELS;
+  return {
+    preferredModel: data?.[PREFERRED_MODEL_KEY] ?? null,
+    setPreferredModel: (modelId) => void writePreference(client, PREFERRED_MODEL_KEY, modelId),
+    reasoningLevels,
+    setReasoningLevel: (modelId, level) => {
+      if (!modelId) return;
+      void writePreference(
+        client,
+        MODEL_REASONING_LEVELS_KEY,
+        JSON.stringify({ ...reasoningLevels, [modelId]: level })
+      );
+    }
+  };
+}
+
+// src/rich-input/services.tsx
+import { useMemo, useRef as useRef2 } from "react";
+function useModelCatalog() {
+  const use = useRichInputServices().useModelCatalog ?? useClientModelCatalog;
+  return use();
+}
+function useModelPreferences() {
+  const use = useRichInputServices().useModelPreferences ?? useClientModelPreferences;
+  return use();
+}
+function useSessionConnection(sessionId) {
+  const connection = useSessionState(sessionId, (state) => state.connection);
+  const status = sessionId ? connection : "connected";
+  const everConnected = useRef2(false);
+  if (status === "connected") everConnected.current = true;
+  return { status, reconnectAttempt: 0, hasEverConnected: everConnected.current };
+}
+function useComposerConnectionInfo(sessionId) {
+  const use = useRichInputServices().useConnection ?? useSessionConnection;
+  return use(sessionId);
+}
+function useComposerConnection(sessionId) {
+  return useComposerConnectionInfo(sessionId).status;
+}
+function useSessionSkills(sessionId) {
+  const use = useRichInputServices().useSessionSkills ?? useClientSessionSkills;
+  return use(sessionId);
+}
+function useSkillStats(sessionId) {
+  const use = useRichInputServices().useSkillStats ?? useClientSkillStats;
+  return use(sessionId);
+}
+function useContextStats(sessionId) {
+  const use = useRichInputServices().useContextStats ?? useClientContextStats;
+  return use(sessionId);
+}
+function useBackgroundTaskList(sessionId) {
+  const use = useRichInputServices().useBackgroundTasks ?? useClientBackgroundTasks;
+  return use(sessionId);
+}
+function useClientSessionDataInvalidation() {
+  const client = useBladeClient();
+  return useMemo(
+    () => ({
+      filesUploaded: (_sessionId) => {
+      },
+      pluginsChanged: (sessionId) => refreshClientSessionSkills(client, sessionId)
+    }),
+    [client]
+  );
+}
+function useSessionDataInvalidation() {
+  const use = useRichInputServices().useSessionDataInvalidation ?? useClientSessionDataInvalidation;
+  return use();
+}
+
+// src/components/SessionPluginIcon.tsx
+import { useEffect as useEffect3, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function sessionPluginLabel(plugin) {
+  const display = typeof plugin.display_name === "string" ? plugin.display_name.trim() : "";
+  return display || plugin.name;
+}
+var clientCaches = /* @__PURE__ */ new WeakMap();
+var BLOB_CACHE_LIMIT = 64;
+function iconBlob(client, sessionId, name, token) {
+  let blobCache = clientCaches.get(client);
+  if (!blobCache) {
+    blobCache = /* @__PURE__ */ new Map();
+    clientCaches.set(client, blobCache);
+  }
+  const key = sessionId ? `${sessionId}:${name}:${token}` : `account:${name}:${token}`;
+  const cached = blobCache.get(key);
+  if (cached) return cached;
+  const pending = (sessionId ? client.sessions.fetchSessionPluginIcon(sessionId, name) : client.plugins.fetchIcon(name)).catch(() => {
+    blobCache?.delete(key);
+    return null;
+  });
+  if (blobCache.size >= BLOB_CACHE_LIMIT) blobCache.clear();
+  blobCache.set(key, pending);
+  return pending;
+}
+function SessionPluginIcon({ client, sessionId, plugin, size = 20, shape = "rounded", className }) {
+  const [url, setUrl] = useState(null);
+  const token = plugin.icon;
+  const inlineIcon = token && /^data:image\/(?:png|jpeg|gif|webp);base64,/.test(token) ? token : null;
+  useEffect3(() => {
+    setUrl(null);
+    if (!token || inlineIcon) return;
+    let alive = true;
+    let objectUrl = null;
+    void iconBlob(client, sessionId, plugin.name, token).then((blob) => {
+      if (!alive || !blob) return;
+      objectUrl = URL.createObjectURL(blob);
+      setUrl(objectUrl);
+    });
+    return () => {
+      alive = false;
+      if (objectUrl) URL.revokeObjectURL(objectUrl);
+    };
+  }, [client, sessionId, plugin.name, token, inlineIcon]);
+  const frame = `flex shrink-0 items-center justify-center overflow-hidden ${shape === "circle" ? "rounded-full" : "rounded"} ${className ?? ""}`;
+  const frameStyle = { width: size, height: size };
+  const source = url === "" ? null : inlineIcon ?? url;
+  if (!source) {
+    return /* @__PURE__ */ jsx2("span", { className: `${frame} bg-[hsl(var(--muted))] text-[hsl(var(--muted-foreground))]`, style: frameStyle, "data-plugin-icon": "placeholder", children: /* @__PURE__ */ jsx2(Puzzle, { "aria-hidden": true, size: Math.round(size * 0.7) }) });
+  }
+  return /* @__PURE__ */ jsx2("span", { className: frame, style: frameStyle, "data-plugin-icon": "image", children: /* @__PURE__ */ jsx2("img", { src: source, alt: "", "aria-hidden": true, className: "h-full w-full object-cover", onError: () => setUrl("") }) });
+}
+
+// src/components/SessionPluginConfigDialog.tsx
+import { useEffect as useEffect4, useRef as useRef3, useState as useState2 } from "react";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+async function readFailure(error) {
+  const response = error?.response;
+  if (!response || typeof response.json !== "function") {
+    return { message: "\u914D\u7F6E\u672A\u4FDD\u5B58\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5" };
+  }
+  try {
+    const body = await response.json();
+    const detail = body?.detail;
+    if (typeof detail === "string") return { message: detail };
+    if (detail && typeof detail === "object") {
+      return {
+        message: detail.message ?? "\u914D\u7F6E\u672A\u4FDD\u5B58\uFF0C\u8BF7\u68C0\u67E5\u586B\u5199\u5185\u5BB9",
+        errors: Array.isArray(detail.errors) ? detail.errors : void 0,
+        code: detail.code
+      };
+    }
+  } catch {
+  }
+  return { message: "\u914D\u7F6E\u672A\u4FDD\u5B58\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5" };
+}
+function SessionPluginConfigDialog({
+  client,
+  sessionId,
+  plugin,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3(
+    ConfigDialogState,
+    {
+      client,
+      sessionId,
+      plugin,
+      ...props
+    },
+    `${sessionId}:${plugin.name}`
+  );
+}
+function ConfigDialogState({
+  client,
+  sessionId,
+  plugin,
+  onSaved,
+  onClose
+}) {
+  const [host, setHost] = useState2(null);
+  const [restarting, setRestarting] = useState2(false);
+  const [scope, setScope] = useState2("personal");
+  const [config, setConfig] = useState2(null);
+  const pendingRevision = scope === "global" && host?.state === "ready" && config?.revision != null && host.revision !== config.revision;
+  const waitingForHost = host?.state === "starting" || host?.state === "updating" || pendingRevision;
+  useEffect4(() => {
+    if (!waitingForHost) return;
+    const abort = new AbortController();
+    let timer;
+    const refresh = async () => {
+      try {
+        const next = await client.sessions.getSessionPluginConfig(sessionId, plugin.name, { signal: abort.signal }, scope);
+        if (!abort.signal.aborted) setHost(next.host ?? null);
+      } catch {
+      }
+      if (!abort.signal.aborted) timer = setTimeout(refresh, 2e3);
+    };
+    timer = setTimeout(refresh, 2e3);
+    return () => {
+      abort.abort();
+      clearTimeout(timer);
+    };
+  }, [client, sessionId, plugin.name, scope, waitingForHost]);
+  const [canConfigureGlobal, setCanConfigureGlobal] = useState2(false);
+  const [loading, setLoading] = useState2(true);
+  const [loadFailure, setLoadFailure] = useState2(null);
+  const [saving, setSaving] = useState2(false);
+  const [failure, setFailure] = useState2(null);
+  const [fieldErrors, setFieldErrors] = useState2([]);
+  const [formVersion, setFormVersion] = useState2(0);
+  const alive = useRef3(true);
+  const generation2 = useRef3(0);
+  const dialog = useRef3(null);
+  useEffect4(() => {
+    const element = dialog.current;
+    if (!element || element.open) return;
+    if (typeof element.showModal === "function") element.showModal();
+    else element.setAttribute("open", "");
+  }, []);
+  const load = async () => {
+    const current = ++generation2.current;
+    setLoading(true);
+    setLoadFailure(null);
+    try {
+      const { config: state, can_configure_global, host: hostState } = await client.sessions.getSessionPluginConfig(sessionId, plugin.name, void 0, scope);
+      if (!alive.current || generation2.current !== current) return;
+      setCanConfigureGlobal(can_configure_global ?? false);
+      setHost(hostState ?? null);
+      setConfig(state);
+      setFormVersion((value) => value + 1);
+    } catch (error) {
+      if (!alive.current || generation2.current !== current) return;
+      const detail = await readFailure(error);
+      if (!alive.current || generation2.current !== current) return;
+      setLoadFailure(detail.message ?? "\u914D\u7F6E\u6682\u4E0D\u53EF\u7528");
+    } finally {
+      if (alive.current && generation2.current === current) setLoading(false);
+    }
+  };
+  useEffect4(() => {
+    alive.current = true;
+    setConfig(null);
+    setFailure(null);
+    setFieldErrors([]);
+    void load();
+    return () => {
+      alive.current = false;
+      generation2.current++;
+    };
+  }, [client, sessionId, plugin.name, scope]);
+  const save = async (draft) => {
+    if (!config) return;
+    const current = generation2.current;
+    setSaving(true);
+    setFailure(null);
+    setFieldErrors([]);
+    try {
+      const { config: state } = await client.sessions.updateSessionPluginConfig(
+        sessionId,
+        plugin.name,
+        {
+          expected_revision: config.revision,
+          set: draft.set,
+          remove: draft.remove
+        },
+        void 0,
+        scope
+      );
+      if (!alive.current || generation2.current !== current) return;
+      setConfig(state);
+      setFormVersion((value) => value + 1);
+      if (scope === "personal") onSaved?.(state);
+    } catch (error) {
+      if (!alive.current || generation2.current !== current) return;
+      const detail = await readFailure(error);
+      if (!alive.current || generation2.current !== current) return;
+      setFailure(detail.message ?? "\u914D\u7F6E\u672A\u4FDD\u5B58\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+      setFieldErrors(detail.errors ?? []);
+      if (detail.code === "plugin_config_conflict") await load();
+    } finally {
+      if (alive.current) setSaving(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3("style", { children: ".blade-plugin-dialog::backdrop { background: rgb(0 0 0 / 40%); }" }),
+    /* @__PURE__ */ jsxs(
+      "dialog",
+      {
+        ref: dialog,
+        "aria-modal": "true",
+        "aria-label": `${sessionPluginLabel(plugin)} \u914D\u7F6E`,
+        onCancel: (event) => {
+          event.preventDefault();
+          onClose();
+        },
+        onKeyDown: (event) => {
+          if (event.key !== "Escape") return;
+          event.preventDefault();
+          event.stopPropagation();
+          onClose();
+        },
+        style: {
+          position: "fixed",
+          inset: 0,
+          margin: "auto",
+          boxSizing: "border-box",
+          width: "min(448px, calc(100% - 32px))"
+        },
+        className: "blade-plugin-dialog max-h-[80vh] overflow-y-auto rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--popover))] p-4 text-[hsl(var(--popover-foreground))] shadow-lg",
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "mb-3 flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx3(SessionPluginIcon, { client, sessionId, plugin }),
+            /* @__PURE__ */ jsx3(
+              "span",
+              {
+                className: "min-w-0 flex-1 truncate text-sm font-medium",
+                title: sessionPluginLabel(plugin),
+                children: sessionPluginLabel(plugin)
+              }
+            ),
+            /* @__PURE__ */ jsx3(
+              "button",
+              {
+                type: "button",
+                "aria-label": "\u5173\u95ED",
+                className: "shrink-0 text-xs underline",
+                onClick: onClose,
+                children: "\u5173\u95ED"
+              }
+            )
+          ] }),
+          canConfigureGlobal ? /* @__PURE__ */ jsxs("div", { className: "mb-3 flex gap-2 text-xs", children: [
+            /* @__PURE__ */ jsx3("button", { type: "button", disabled: saving, "aria-pressed": scope === "personal", onClick: () => setScope("personal"), children: "\u6211\u7684\u767B\u5F55" }),
+            /* @__PURE__ */ jsx3("button", { type: "button", disabled: saving, "aria-pressed": scope === "global", onClick: () => setScope("global"), children: "\u7EC4\u7EC7\u5171\u4EAB\u914D\u7F6E" })
+          ] }) : null,
+          host ? /* @__PURE__ */ jsxs("div", { className: "mb-3 space-y-1 text-xs", children: [
+            /* @__PURE__ */ jsxs("p", { children: [
+              "\u670D\u52A1\uFF1A",
+              pendingRevision ? "\u6B63\u5728\u66F4\u65B0" : host.reason,
+              " \xB7 \u5DF2\u6062\u590D ",
+              host.restarts,
+              " \u6B21"
+            ] }),
+            canConfigureGlobal ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsxs("p", { className: "break-all text-[hsl(var(--muted-foreground))]", children: [
+                "\u5305\u6458\u8981\uFF1A",
+                host.digest,
+                " \xB7 \u914D\u7F6E\uFF1A",
+                host.revision
+              ] }),
+              /* @__PURE__ */ jsx3("button", { type: "button", disabled: restarting || saving, onClick: () => {
+                setRestarting(true);
+                void client.sessions.restartSessionPluginHost(sessionId, plugin.name).then(() => load()).catch(() => setFailure("\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5")).finally(() => {
+                  if (alive.current) setRestarting(false);
+                });
+              }, children: restarting ? "\u6B63\u5728\u91CD\u542F\u2026" : "\u91CD\u542F\u670D\u52A1" }),
+              host.recent?.length ? /* @__PURE__ */ jsxs("details", { children: [
+                /* @__PURE__ */ jsx3("summary", { children: "\u6700\u8FD1\u6D3B\u52A8" }),
+                host.recent.map((line, index) => /* @__PURE__ */ jsx3("p", { children: line }, `${index}-${line}`))
+              ] }) : null
+            ] }) : null
+          ] }) : null,
+          scope === "personal" && config?.auth_status === "expired" ? /* @__PURE__ */ jsx3("p", { className: "mb-2 text-xs", children: "\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u586B\u5199" }) : null,
+          scope === "personal" && config?.global_ready === false ? /* @__PURE__ */ jsx3("p", { className: "mb-2 text-xs", children: "\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u586B\u5199\u5171\u4EAB\u914D\u7F6E" }) : null,
+          scope === "global" ? /* @__PURE__ */ jsx3("p", { className: "mb-2 text-xs", children: "\u5171\u4EAB\u5BC6\u94A5\u7528\u4E8E\u63D2\u4EF6\u670D\u52A1\u3002\u547D\u4EE4\u7C7B\u63D2\u4EF6\u7684\u6C99\u76D2\u4EE3\u7801\u53EF\u4EE5\u8BFB\u53D6\u5B83\uFF1B\u9700\u4FDD\u5BC6\u65F6\u8BF7\u4F7F\u7528\u6258\u7BA1\u670D\u52A1\u3002" }) : null,
+          loading ? /* @__PURE__ */ jsx3("p", { className: "text-xs text-[hsl(var(--muted-foreground))]", children: "\u6B63\u5728\u8BFB\u53D6\u914D\u7F6E\u2026" }) : null,
+          loadFailure ? /* @__PURE__ */ jsxs("div", { className: "space-y-2 text-xs", children: [
+            /* @__PURE__ */ jsx3("p", { children: loadFailure }),
+            /* @__PURE__ */ jsx3(
+              "button",
+              {
+                type: "button",
+                className: "rounded-full border border-[hsl(var(--border))] px-2.5 py-1",
+                onClick: () => void load(),
+                children: "\u91CD\u8BD5"
+              }
+            )
+          ] }) : null,
+          config && !loading ? /* @__PURE__ */ jsx3(
+            SessionPluginConfigForm,
+            {
+              config,
+              submitting: saving,
+              errors: fieldErrors,
+              failure,
+              onSubmit: (draft) => void save(draft),
+              onCancel: onClose
+            },
+            formVersion
+          ) : null
+        ]
+      }
+    )
+  ] });
+}
+
+// src/components/PluginConnectorList.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function PluginSwitch({
+  label,
+  checked,
+  pending,
+  disabled,
+  draft = false,
+  onToggle
+}) {
+  return /* @__PURE__ */ jsx4(
+    "button",
+    {
+      type: "button",
+      role: "switch",
+      "aria-checked": checked,
+      "aria-label": draft ? `${label} \u5F85\u9009` : `${label} \u542F\u7528`,
+      disabled,
+      onClick: () => onToggle(!checked),
+      className: `relative inline-flex h-[18px] w-8 shrink-0 cursor-pointer items-center rounded-full border transition-colors disabled:cursor-not-allowed disabled:opacity-50 ${checked ? "border-transparent bg-[hsl(213_94%_55%)]" : "border-[hsl(var(--border))] bg-[hsl(var(--muted))]"}`,
+      children: /* @__PURE__ */ jsx4(
+        "span",
+        {
+          "aria-hidden": "true",
+          className: `pointer-events-none flex h-3.5 w-3.5 items-center justify-center rounded-full bg-white shadow transition-transform ${checked ? "translate-x-[16px]" : "translate-x-[2px]"}`,
+          children: pending ? /* @__PURE__ */ jsx4(LoaderCircle, { size: 9, className: "animate-spin text-[hsl(var(--muted-foreground))]" }) : null
+        }
+      )
+    }
+  );
+}
+function PluginConnectorList({
+  client,
+  sessionId,
+  items,
+  inFlight,
+  busy,
+  mutationError,
+  onToggle,
+  onRetry,
+  onEditConfig,
+  configuring,
+  onConfigSaved,
+  onConfigClose,
+  disabledReason,
+  unavailableText,
+  emptyText,
+  draft = false
+}) {
+  const configuringItem = configuring ? items.find((item) => item.name === configuring.name) ?? null : null;
+  return /* @__PURE__ */ jsxs2("div", { className: "py-0.5", children: [
+    disabledReason ? /* @__PURE__ */ jsx4("div", { className: "px-3 py-1.5 text-[11px] text-[hsl(var(--muted-foreground))]", children: disabledReason }) : null,
+    items.length === 0 ? /* @__PURE__ */ jsx4("div", { className: "px-3 py-1.5 text-[11px] text-[hsl(var(--muted-foreground))]", children: unavailableText ?? emptyText }) : null,
+    items.map((item) => {
+      const label = sessionPluginLabel(item);
+      const actionable = !disabledReason && item.installed !== false || item.active;
+      const pending = Boolean(inFlight[item.name]);
+      const checked = item.active;
+      return /* @__PURE__ */ jsxs2("div", { className: "group px-3 py-1", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx4(
+            SessionPluginIcon,
+            {
+              client,
+              sessionId: item.iconSource === "account" ? null : sessionId,
+              plugin: item
+            }
+          ),
+          /* @__PURE__ */ jsx4("span", { className: "min-w-0 flex-1 truncate text-[11px]", title: label, children: label }),
+          item.auth_status === "expired" || item.auth_status === "login_required" || item.auth_status === "unavailable" ? /* @__PURE__ */ jsx4("button", { type: "button", disabled: !sessionId || busy, onClick: () => onEditConfig(item), className: "shrink-0 text-[10px] underline", children: item.auth_status === "expired" ? "\u767B\u5F55\u5DF2\u8FC7\u671F" : item.auth_status === "unavailable" ? "\u6682\u65F6\u4E0D\u53EF\u7528" : "\u672A\u767B\u5F55" }) : null,
+          !draft && item.config === "configured" ? /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              title: "\u66F4\u65B0\u8BE5\u63D2\u4EF6\u7684\u914D\u7F6E",
+              disabled: busy || !sessionId,
+              onClick: () => onEditConfig(item),
+              className: "shrink-0 text-[10px] text-[hsl(var(--muted-foreground))] underline opacity-0 [@media(hover:none)]:opacity-100 transition-opacity focus-visible:opacity-100 group-hover:opacity-100 disabled:cursor-not-allowed disabled:opacity-50",
+              children: "\u66F4\u65B0\u914D\u7F6E"
+            }
+          ) : null,
+          !draft && (item.config === "required" || item.config === "error") ? /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              title: "\u8BE5\u63D2\u4EF6\u9700\u8981\u586B\u5199\u914D\u7F6E",
+              disabled: busy || !sessionId,
+              onClick: () => onEditConfig(item),
+              className: "shrink-0 text-[10px] text-[hsl(var(--muted-foreground))] underline disabled:cursor-not-allowed disabled:opacity-50",
+              children: "\u586B\u5199\u914D\u7F6E"
+            }
+          ) : null,
+          /* @__PURE__ */ jsx4(
+            PluginSwitch,
+            {
+              label,
+              checked,
+              pending,
+              draft,
+              disabled: !actionable,
+              onToggle: (next) => onToggle(item, next)
+            }
+          )
+        ] }),
+        !draft && item.active && item.status !== "valid" && item.status !== "required" ? /* @__PURE__ */ jsxs2("div", { className: "mt-0.5 flex items-center gap-2 pl-7 text-[10px] text-[hsl(var(--muted-foreground))]", children: [
+          /* @__PURE__ */ jsx4("span", { children: item.reason || "\u63D2\u4EF6\u6682\u4E0D\u53EF\u7528" }),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              disabled: busy,
+              onClick: () => onRetry(item),
+              className: "underline disabled:cursor-not-allowed disabled:opacity-50",
+              children: "\u91CD\u8BD5"
+            }
+          )
+        ] }) : null
+      ] }, item.name);
+    }),
+    mutationError ? /* @__PURE__ */ jsx4("div", { className: "px-3 pt-1 text-[10px] text-[hsl(var(--destructive))]", children: "\u64CD\u4F5C\u672A\u5B8C\u6210\uFF0C\u8BF7\u91CD\u8BD5" }) : null,
+    configuring && configuringItem && sessionId ? /* @__PURE__ */ jsx4(
+      SessionPluginConfigDialog,
+      {
+        client,
+        sessionId,
+        plugin: configuringItem,
+        onSaved: onConfigSaved,
+        onClose: onConfigClose
+      }
+    ) : null
+  ] });
+}
+
+// src/components/plugin-connector.ts
+function catalogToConnectorItems(catalog) {
+  return catalog.map((entry) => ({
+    name: entry.name,
+    display_name: entry.display_name,
+    icon: entry.icon,
+    iconSource: "account",
+    installed: entry.installed,
+    connector: entry.connector,
+    auth_status: entry.auth_status,
+    active: false,
+    status: "not_prepared",
+    projected: false
+  }));
+}
+function mergeConnectorItems(sessionPlugins, catalog) {
+  const byName = new Map((catalog ?? []).map((entry) => [entry.name, entry]));
+  return sessionPlugins.map((plugin) => {
+    const entry = byName.get(plugin.name);
+    if (!entry) {
+      return {
+        name: plugin.name,
+        display_name: plugin.display_name ?? null,
+        icon: plugin.icon ?? null,
+        iconSource: "session",
+        installed: plugin.installed,
+        active: plugin.active,
+        status: plugin.status,
+        reason: plugin.reason,
+        config: plugin.config,
+        projected: plugin.projected
+      };
+    }
+    return {
+      name: plugin.name,
+      display_name: entry.display_name ?? plugin.display_name ?? null,
+      icon: entry.icon,
+      iconSource: "account",
+      installed: entry.installed,
+      connector: entry.connector,
+      auth_status: entry.auth_status,
+      active: plugin.active,
+      status: plugin.status,
+      reason: plugin.reason,
+      config: plugin.config,
+      projected: plugin.projected
+    };
+  });
+}
+function filterConnectorItems(items, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return items;
+  return items.filter(
+    (item) => `${item.display_name ?? ""} ${item.name}`.toLowerCase().includes(needle)
+  );
+}
+
+// src/components/use-session-plugin-activation.ts
+import { isLocalConnectorName } from "@blade-hq/agent-client/internal";
+import { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo2, useRef as useRef4, useState as useState3 } from "react";
+function useSessionPluginActivation({
+  client,
+  sessionId,
+  onChange
+}) {
+  const [plugins, setPlugins] = useState3([]);
+  const [catalog, setCatalog] = useState3(null);
+  const [loading, setLoading] = useState3(false);
+  const [listError, setListError] = useState3(false);
+  const [mutationError, setMutationError] = useState3(false);
+  const [inFlight, setInFlight] = useState3({});
+  const [configuring, setConfiguring] = useState3(null);
+  const alive = useRef4(true);
+  const generation2 = useRef4(0);
+  const mutationGenerations = useRef4(/* @__PURE__ */ new Map());
+  const desiredActivations = useRef4(/* @__PURE__ */ new Map());
+  const pendingMutations = useRef4(/* @__PURE__ */ new Map());
+  const submittedActivations = useRef4(/* @__PURE__ */ new Set());
+  const serverActive = useRef4(/* @__PURE__ */ new Set());
+  const lifetime = useRef4(0);
+  const request = useRef4(null);
+  const [desiredVersion, setDesiredVersion] = useState3(0);
+  const setDesired = useCallback2((name, value) => {
+    if (value === null) {
+      if (!desiredActivations.current.delete(name)) return;
+    } else {
+      if (desiredActivations.current.get(name) === value) return;
+      desiredActivations.current.set(name, value);
+    }
+    setDesiredVersion((version) => version + 1);
+  }, []);
+  const items = useMemo2(() => {
+    void desiredVersion;
+    const merged = mergeConnectorItems(plugins, catalog);
+    return merged.map((item) => {
+      if (configuring?.name === item.name && configuring.pendingActivation) {
+        return { ...item, active: false };
+      }
+      const desired = desiredActivations.current.get(item.name);
+      return desired === void 0 ? item : { ...item, active: desired };
+    });
+  }, [catalog, configuring, desiredVersion, plugins]);
+  const markInFlight = useCallback2((name, on) => {
+    setInFlight((current) => {
+      if (on) return current[name] ? current : { ...current, [name]: true };
+      if (!current[name]) return current;
+      const { [name]: removed, ...rest } = current;
+      void removed;
+      return rest;
+    });
+  }, []);
+  useEffect5(() => {
+    alive.current = true;
+    setPlugins([]);
+    setCatalog(null);
+    setLoading(false);
+    setListError(false);
+    setMutationError(false);
+    setInFlight({});
+    setConfiguring(null);
+    desiredActivations.current.clear();
+    mutationGenerations.current.clear();
+    pendingMutations.current.clear();
+    submittedActivations.current.clear();
+    return () => {
+      alive.current = false;
+      lifetime.current++;
+      generation2.current++;
+      request.current?.abort();
+    };
+  }, [client]);
+  const load = useCallback2(async () => {
+    if (!alive.current) return;
+    request.current?.abort();
+    const controller = new AbortController();
+    request.current = controller;
+    const current = ++generation2.current;
+    setLoading(true);
+    setListError(false);
+    try {
+      const result = await client.sessions.listSessionPlugins(sessionId, { signal: controller.signal });
+      const withConfig = await Promise.all(
+        result.plugins.map(async (item) => {
+          if (isLocalConnectorName(item.name) || item.config !== void 0 && item.config !== "unchecked") return item;
+          try {
+            const { config } = await client.sessions.getSessionPluginConfig(sessionId, item.name, {
+              signal: controller.signal
+            });
+            return { ...item, config: config.state };
+          } catch {
+            return item;
+          }
+        })
+      );
+      if (alive.current && current === generation2.current) {
+        serverActive.current = new Set(withConfig.filter((item) => item.active).map((item) => item.name));
+        setPlugins(withConfig.map((item) => {
+          const desired = desiredActivations.current.get(item.name);
+          return desired === void 0 ? item : { ...item, active: desired };
+        }));
+      }
+    } catch {
+      if (alive.current && current === generation2.current && !controller.signal.aborted) setListError(true);
+    } finally {
+      if (alive.current && current === generation2.current) setLoading(false);
+    }
+  }, [client, sessionId]);
+  const loadCatalog = useCallback2(async () => {
+    try {
+      const { plugins: entries } = await client.plugins.catalog();
+      if (alive.current) setCatalog(entries);
+    } catch {
+    }
+  }, [client]);
+  const reload = useCallback2(() => {
+    void load();
+    void loadCatalog();
+  }, [load, loadCatalog]);
+  const abandon = useCallback2((name) => {
+    setDesired(name, null);
+    pendingMutations.current.delete(name);
+    mutationGenerations.current.set(name, (mutationGenerations.current.get(name) ?? 0) + 1);
+    markInFlight(name, false);
+    void load();
+  }, [load, markInFlight, setDesired]);
+  const finish = useCallback2((name, mutation) => {
+    pendingMutations.current.delete(name);
+    setDesired(name, null);
+    if (mutation === mutationGenerations.current.get(name)) markInFlight(name, false);
+  }, [markInFlight, setDesired]);
+  const commitActivation = useCallback2(
+    async (name, active, mutation, startedAt) => {
+      submittedActivations.current.add(name);
+      try {
+        const { plugin } = await client.sessions.setSessionPluginActivation(sessionId, name, active);
+        if (!alive.current || startedAt !== lifetime.current) return;
+        if (mutation !== mutationGenerations.current.get(name)) {
+          const desired = desiredActivations.current.get(name);
+          if (desired !== void 0 && desired !== plugin.active) {
+            const next = (mutationGenerations.current.get(name) ?? 0) + 1;
+            mutationGenerations.current.set(name, next);
+            pendingMutations.current.set(name, next);
+            markInFlight(name, true);
+            await commitActivation(name, desired, next, startedAt);
+          }
+          return;
+        }
+        if (active) serverActive.current.add(name);
+        else serverActive.current.delete(name);
+        finish(name, mutation);
+        setPlugins((current) => current.map((item) => item.name === plugin.name ? { ...item, ...plugin } : item));
+        onChange?.(plugin);
+        if (plugin.active && plugin.status === "required") {
+          setConfiguring({ name: plugin.name, pendingActivation: true });
+        }
+        await load();
+      } catch {
+        if (alive.current && startedAt === lifetime.current && mutation === mutationGenerations.current.get(name)) {
+          pendingMutations.current.delete(name);
+          submittedActivations.current.delete(name);
+          setDesired(name, null);
+          markInFlight(name, false);
+          setMutationError(true);
+          void load();
+        }
+      }
+    },
+    [client, finish, load, markInFlight, onChange, sessionId, setDesired]
+  );
+  const enable = useCallback2(async (name) => {
+    if (!alive.current) return;
+    const startedAt = lifetime.current;
+    const mutation = (mutationGenerations.current.get(name) ?? 0) + 1;
+    mutationGenerations.current.set(name, mutation);
+    pendingMutations.current.set(name, mutation);
+    setDesired(name, true);
+    setMutationError(false);
+    markInFlight(name, true);
+    request.current?.abort();
+    generation2.current++;
+    setLoading(false);
+    let state;
+    try {
+      const result = await client.sessions.prepareSessionPluginConfig(sessionId, name);
+      if (!alive.current || startedAt !== lifetime.current || mutation !== mutationGenerations.current.get(name)) return;
+      state = result.config;
+    } catch {
+      if (!alive.current || startedAt !== lifetime.current || mutation !== mutationGenerations.current.get(name)) return;
+      abandon(name);
+      setMutationError(true);
+      return;
+    }
+    if (state.state === "required") {
+      pendingMutations.current.delete(name);
+      markInFlight(name, false);
+      setConfiguring({ name, pendingActivation: true });
+      return;
+    }
+    if (state.state !== "configured" && state.state !== "not_required") {
+      abandon(name);
+      setMutationError(true);
+      return;
+    }
+    setPlugins((current) => current.map((item) => item.name === name ? { ...item, config: state.state } : item));
+    await commitActivation(name, true, mutation, startedAt);
+  }, [abandon, client, commitActivation, markInFlight, sessionId, setDesired]);
+  const disable = useCallback2((name) => {
+    const startedAt = lifetime.current;
+    request.current?.abort();
+    generation2.current++;
+    setLoading(false);
+    if (!submittedActivations.current.has(name) && !serverActive.current.has(name)) {
+      abandon(name);
+      return;
+    }
+    const mutation = (mutationGenerations.current.get(name) ?? 0) + 1;
+    mutationGenerations.current.set(name, mutation);
+    pendingMutations.current.set(name, mutation);
+    setDesired(name, false);
+    setMutationError(false);
+    markInFlight(name, true);
+    void commitActivation(name, false, mutation, startedAt);
+  }, [abandon, commitActivation, markInFlight, setDesired]);
+  const toggle = useCallback2((item, next) => {
+    if (next) void enable(item.name);
+    else disable(item.name);
+  }, [disable, enable]);
+  const retry = useCallback2((item) => {
+    void enable(item.name);
+  }, [enable]);
+  const editConfig = useCallback2((item) => {
+    setConfiguring({ name: item.name, pendingActivation: false });
+  }, []);
+  const onConfigSaved = useCallback2((state) => {
+    const target = configuring;
+    if (!target) return;
+    setConfiguring(null);
+    void loadCatalog();
+    setPlugins((current) => current.map((item) => item.name === target.name ? { ...item, config: state.state } : item));
+    if (!target.pendingActivation || state.state !== "configured") {
+      void load();
+      return;
+    }
+    const startedAt = lifetime.current;
+    const mutation = (mutationGenerations.current.get(target.name) ?? 0) + 1;
+    mutationGenerations.current.set(target.name, mutation);
+    pendingMutations.current.set(target.name, mutation);
+    setDesired(target.name, true);
+    markInFlight(target.name, true);
+    void commitActivation(target.name, true, mutation, startedAt);
+  }, [commitActivation, configuring, load, loadCatalog, markInFlight, setDesired]);
+  const onConfigClose = useCallback2(() => {
+    const target = configuring;
+    if (!target) return;
+    setConfiguring(null);
+    if (target.pendingActivation) abandon(target.name);
+    else void load();
+  }, [abandon, configuring, load]);
+  return {
+    items,
+    loading,
+    listError,
+    mutationError,
+    inFlight,
+    busy: Object.keys(inFlight).length > 0,
+    configuring,
+    reload,
+    toggle,
+    retry,
+    editConfig,
+    onConfigSaved,
+    onConfigClose
+  };
+}
+
+// src/lib/message-shortcuts.ts
+function usesCommandKey() {
+  if (typeof navigator === "undefined") return false;
+  return /Mac|iPhone|iPad|iPod/i.test(navigator.platform || navigator.userAgent);
+}
+function queueShortcutLabel() {
+  return usesCommandKey() ? "\u2318 Enter" : "Ctrl Enter";
+}
+function isQueueShortcut(event) {
+  return usesCommandKey() ? event.metaKey : event.ctrlKey;
+}
+
+// src/chat/runtime/actions.ts
+function buildPendingAskUserAnswer(state, message) {
+  if (state.status !== "waiting_for_input") return void 0;
+  const text = extractMessageText(message);
+  if (!text) return void 0;
+  for (let turnIndex = state.turns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+    const turn = state.turns[turnIndex];
+    if (turn.loop_id === "root" || turn.role !== "assistant") continue;
+    for (let toolIndex = turn.tool_calls.length - 1; toolIndex >= 0; toolIndex -= 1) {
+      const toolCall = turn.tool_calls[toolIndex];
+      if (toolCall.status !== "awaiting_answer") continue;
+      if (!toolCall.tool_name.includes("AskUserQuestion")) continue;
+      return { tool_call_id: toolCall.id, selections: {}, custom: { "0": text } };
+    }
+  }
+  return void 0;
+}
+function extractMessageText(message) {
+  if (typeof message === "string") return message.trim();
+  return message.filter((part) => part.type === "text").map((part) => part.text.trim()).filter(Boolean).join("\n").trim();
+}
+function sendToSession(session, message, mode, askUserAnswer, extras = {}) {
+  return session.send(message, {
+    mode,
+    askUserAnswer: askUserAnswer ?? buildPendingAskUserAnswer(session.getState(), message),
+    model: extras.model,
+    thinkingOverride: extras.thinkingOverride,
+    reasoningLevel: extras.reasoningLevel,
+    refs: extras.refs,
+    contextAttachments: extras.contextAttachments,
+    topicAssetRefs: extras.topicAssetRefs,
+    whatif: extras.whatif,
+    replayDecision: extras.replayDecision,
+    queueWhenRunning: extras.queueWhenRunning
+  });
+}
+
+// src/chat/chat-theme.tsx
+var NEUTRAL = {
+  text: "text-[hsl(var(--muted-foreground))]",
+  border: "border-l-[hsl(var(--swf-border-strong))]",
+  surface: "bg-[hsl(var(--muted))]"
+};
+var TONE_CLASSES = {
+  running: NEUTRAL,
+  reasoning: NEUTRAL,
+  success: {
+    text: "text-[hsl(var(--swf-success))]",
+    border: "border-l-[hsl(var(--swf-success))]",
+    surface: "bg-[hsl(var(--swf-success-soft))]"
+  },
+  warning: {
+    text: "text-[hsl(var(--swf-warning))]",
+    border: "border-l-[hsl(var(--swf-warning))]",
+    surface: "bg-[hsl(var(--swf-warning-soft))]"
+  },
+  danger: {
+    text: "text-[hsl(var(--swf-danger))]",
+    border: "border-l-[hsl(var(--swf-danger))]",
+    surface: "bg-[hsl(var(--swf-danger-soft))]"
+  }
+};
+function chatTone(tone) {
+  return TONE_CLASSES[tone];
+}
+
+// src/lib/use-effect-event.ts
+import * as React from "react";
+function useEffectEventShim(callback) {
+  const ref = React.useRef(callback);
+  React.useLayoutEffect(() => {
+    ref.current = callback;
+  });
+  return React.useCallback(((...args) => ref.current(...args)), []);
+}
+var builtin = React.useEffectEvent;
+var useEffectEvent2 = builtin ?? useEffectEventShim;
+
+export {
+  getInputHistoryGeneration,
+  onInputCachesReset,
+  pluginRefsForSend,
+  getPluginSuggestionItems,
+  queueShortcutLabel,
+  isQueueShortcut,
+  sendToSession,
+  chatTone,
+  RichInputServicesProvider,
+  useRichInputServices,
+  fetchClientQuery,
+  setClientQueryData,
+  useClientQuery,
+  refreshClientQuery,
+  useRefreshWhenRunEnds,
+  useClientSessionSkills,
+  useClientSkillStats,
+  useClientContextStats,
+  useClientBackgroundTasks,
+  refreshClientSessionSkills,
+  useClientSessionModel,
+  useClientModelCatalog,
+  PREFERRED_MODEL_KEY,
+  MODEL_REASONING_LEVELS_KEY,
+  useClientModelPreferences,
+  useModelCatalog,
+  useModelPreferences,
+  useComposerConnectionInfo,
+  useComposerConnection,
+  useSessionSkills,
+  useSkillStats,
+  useContextStats,
+  useBackgroundTaskList,
+  useSessionDataInvalidation,
+  useEffectEvent2 as useEffectEvent,
+  sessionPluginLabel,
+  SessionPluginIcon,
+  SessionPluginConfigDialog,
+  PluginConnectorList,
+  catalogToConnectorItems,
+  mergeConnectorItems,
+  filterConnectorItems,
+  useSessionPluginActivation
+};
+//# sourceMappingURL=chunk-F4MWGSKX.js.map