@truefoundry/trueforge-ui 0.3.0-rc.0 → 0.3.0-rc.10

package/dist/chunk-2GIZY3JJ.js

@@ -0,0 +1,1062 @@
+// src/server/ServerContext.tsx
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var ServerContext = createContext(null);
+var ServerCapabilitiesContext = createContext(null);
+function ServerProvider({ server, children }) {
+  const [capabilities, setCapabilities] = useState(null);
+  const [capabilitiesSettled, setCapabilitiesSettled] = useState(false);
+  const cancelActiveRequestRef = useRef(null);
+  const refreshCapabilities = useCallback(() => {
+    cancelActiveRequestRef.current?.();
+    let cancelled = false;
+    cancelActiveRequestRef.current = () => {
+      cancelled = true;
+    };
+    void server.getCapabilities().then((response) => {
+      if (!cancelled) setCapabilities(response.data);
+    }).catch(() => {
+    }).finally(() => {
+      if (!cancelled) setCapabilitiesSettled(true);
+    });
+  }, [server]);
+  useEffect(() => {
+    setCapabilities(null);
+    setCapabilitiesSettled(false);
+    refreshCapabilities();
+    return () => {
+      cancelActiveRequestRef.current?.();
+    };
+  }, [refreshCapabilities]);
+  const capabilitiesValue = useMemo(
+    () => ({ capabilities, settled: capabilitiesSettled, refresh: refreshCapabilities }),
+    [capabilities, capabilitiesSettled, refreshCapabilities]
+  );
+  return /* @__PURE__ */ jsx(ServerContext.Provider, { value: server, children: /* @__PURE__ */ jsx(ServerCapabilitiesContext.Provider, { value: capabilitiesValue, children }) });
+}
+function useServer() {
+  const server = useContext(ServerContext);
+  if (server == null) {
+    throw new Error("useServer must be used within a ServerProvider.");
+  }
+  return server;
+}
+function useOptionalServer() {
+  return useContext(ServerContext);
+}
+function useServerCapabilities() {
+  return useContext(ServerCapabilitiesContext)?.capabilities ?? null;
+}
+function useServerCapabilitiesSettled() {
+  return useContext(ServerCapabilitiesContext)?.settled ?? false;
+}
+function useOptionalRefreshServerCapabilities() {
+  return useContext(ServerCapabilitiesContext)?.refresh ?? null;
+}
+function useCatalogServer() {
+  const server = useServer();
+  if (server.catalog == null) {
+    throw new Error("useCatalogServer requires AgentUIServer.catalog. Pass catalog to createTrueFoundryServer.");
+  }
+  return server.catalog;
+}
+function useOptionalCatalogServer() {
+  return useOptionalServer()?.catalog ?? null;
+}
+function useAgentSessionsServer() {
+  const sessions = useServer().sessions;
+  if (sessions == null) {
+    throw new Error("useAgentSessionsServer requires AgentUIServer.sessions.");
+  }
+  return sessions;
+}
+function useOptionalAgentSessionsServer() {
+  return useOptionalServer()?.sessions ?? null;
+}
+function useAgentMetricsServer() {
+  const metrics = useServer().metrics;
+  if (metrics == null) {
+    throw new Error("useAgentMetricsServer requires AgentUIServer.metrics.");
+  }
+  return metrics;
+}
+function useOptionalAgentMetricsServer() {
+  return useOptionalServer()?.metrics ?? null;
+}
+function useScheduleServer() {
+  const server = useServer();
+  if (server.schedules == null) {
+    throw new Error("useScheduleServer requires AgentUIServer.schedules. Pass schedules to createTrueFoundryServer.");
+  }
+  return server.schedules;
+}
+function useOptionalScheduleServer() {
+  return useOptionalServer()?.schedules ?? null;
+}
+function useOptionalPermissionsServer() {
+  return useOptionalServer()?.permissions ?? null;
+}
+
+// src/utils/sessionShareUrl.ts
+var SESSION_ID_QUERY = "sessionId";
+var AGENT_ID_QUERY = "agentId";
+var AGENT_TAB_QUERY = "tab";
+var SESSIONS_VIEW_QUERY = "view";
+var SESSIONS_VIEW_VALUE = "sessions";
+var SESSION_START_TIME_QUERY = "s_sts";
+var SESSION_END_TIME_QUERY = "s_ets";
+var SESSION_TIME_WINDOW_QUERY = "s_tw";
+var SESSION_TIME_BUFFER_MS = 5 * 60 * 1e3;
+var SESSION_CUSTOM_RANGE_MAX_DAYS = 70;
+var DEFAULT_SESSION_TIME_WINDOW_MS = 30 * 24 * 60 * 60 * 1e3;
+var DEFAULT_METRICS_TIME_WINDOW_MS = 24 * 60 * 60 * 1e3;
+function parseLibraryAgentTab(value) {
+  if (value === "overview" || value === "sessions" || value === "schedules" || value === "code" || value === "metrics") {
+    return value;
+  }
+  return null;
+}
+function nonEmpty(value) {
+  return value != null && value.length > 0 ? value : null;
+}
+function parseMs(value) {
+  if (value == null || value.length === 0) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function defaultSessionTimeRange(now = Date.now()) {
+  return {
+    startTs: now - DEFAULT_SESSION_TIME_WINDOW_MS,
+    endTs: now,
+    timeWindowMs: DEFAULT_SESSION_TIME_WINDOW_MS
+  };
+}
+function defaultMetricsTimeRange(now = Date.now()) {
+  return {
+    startTs: now - DEFAULT_METRICS_TIME_WINDOW_MS,
+    endTs: now,
+    timeWindowMs: DEFAULT_METRICS_TIME_WINDOW_MS
+  };
+}
+function sessionTimeRangeFromCreatedAt(createdAt) {
+  const createdAtMs = new Date(createdAt).getTime();
+  if (Number.isNaN(createdAtMs)) return null;
+  return {
+    startTs: createdAtMs - SESSION_TIME_BUFFER_MS,
+    endTs: createdAtMs + SESSION_TIME_BUFFER_MS
+  };
+}
+function resolveSessionTimeRange(range, now = Date.now()) {
+  if (range.timeWindowMs != null) {
+    return { startTs: now - range.timeWindowMs, endTs: now };
+  }
+  return { startTs: range.startTs, endTs: range.endTs };
+}
+function readSessionShareSearch(search) {
+  const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+  const startTs = parseMs(params.get(SESSION_START_TIME_QUERY));
+  const endTs = parseMs(params.get(SESSION_END_TIME_QUERY));
+  const timeWindowMs = parseMs(params.get(SESSION_TIME_WINDOW_QUERY));
+  const view = params.get(SESSIONS_VIEW_QUERY);
+  const now = Date.now();
+  return {
+    sessionId: nonEmpty(params.get(SESSION_ID_QUERY)),
+    agentId: nonEmpty(params.get(AGENT_ID_QUERY)),
+    tab: parseLibraryAgentTab(params.get(AGENT_TAB_QUERY)),
+    view: view === SESSIONS_VIEW_VALUE ? SESSIONS_VIEW_VALUE : null,
+    timeRange: startTs != null && endTs != null ? { startTs, endTs } : timeWindowMs != null ? { startTs: now - timeWindowMs, endTs: now, timeWindowMs } : null
+  };
+}
+function libraryAgentTabFromSearch(share, agentId) {
+  if (share.tab != null) return share.tab;
+  return share.sessionId != null && share.agentId === agentId ? "sessions" : "overview";
+}
+function writeSessionShareSearch(params, next) {
+  if (next.sessionId === null) params.delete(SESSION_ID_QUERY);
+  else if (next.sessionId != null) params.set(SESSION_ID_QUERY, next.sessionId);
+  if (next.agentId === null) params.delete(AGENT_ID_QUERY);
+  else if (next.agentId != null) params.set(AGENT_ID_QUERY, next.agentId);
+  if (next.tab === null) params.delete(AGENT_TAB_QUERY);
+  else if (next.tab != null) params.set(AGENT_TAB_QUERY, next.tab);
+  if (next.view === null) params.delete(SESSIONS_VIEW_QUERY);
+  else if (next.view != null) params.set(SESSIONS_VIEW_QUERY, next.view);
+  if (next.timeRange === null) {
+    params.delete(SESSION_START_TIME_QUERY);
+    params.delete(SESSION_END_TIME_QUERY);
+    params.delete(SESSION_TIME_WINDOW_QUERY);
+  } else if (next.timeRange != null) {
+    if (next.timeRange.timeWindowMs != null) {
+      params.set(SESSION_TIME_WINDOW_QUERY, String(next.timeRange.timeWindowMs));
+      params.delete(SESSION_START_TIME_QUERY);
+      params.delete(SESSION_END_TIME_QUERY);
+    } else {
+      params.set(SESSION_START_TIME_QUERY, String(next.timeRange.startTs));
+      params.set(SESSION_END_TIME_QUERY, String(next.timeRange.endTs));
+      params.delete(SESSION_TIME_WINDOW_QUERY);
+    }
+  }
+}
+function buildAgentSessionShareUrl({
+  sessionId,
+  agentId,
+  createdAt,
+  view,
+  href = typeof window === "undefined" ? "" : window.location.href
+}) {
+  const url = new URL(href);
+  writeSessionShareSearch(url.searchParams, {
+    sessionId,
+    agentId: agentId == null || agentId.length === 0 ? null : agentId,
+    ...view === void 0 ? {} : { view },
+    timeRange: createdAt == null ? void 0 : sessionTimeRangeFromCreatedAt(createdAt)
+  });
+  return url.toString();
+}
+var SESSION_SHARE_CHANGE_EVENT = "trueforge-session-share";
+function replaceSessionShareSearch(next) {
+  const url = new URL(window.location.href);
+  writeSessionShareSearch(url.searchParams, next);
+  window.history.replaceState(window.history.state, "", url);
+  window.dispatchEvent(new Event(SESSION_SHARE_CHANGE_EVENT));
+  return url.search;
+}
+
+// src/server/serverChrome.ts
+function isSettingsChromeEnabled({
+  catalog,
+  capabilities
+}) {
+  return catalog != null && capabilities?.settings?.enabled === true;
+}
+function isSessionsChromeEnabled({ sessions }) {
+  return sessions != null;
+}
+function isSchedulesChromeEnabled({ schedules }) {
+  return schedules != null;
+}
+function isMetricsChromeEnabled({ metrics }) {
+  return metrics != null;
+}
+function toEffectiveRoutes({
+  routes,
+  catalog,
+  capabilities,
+  sessions,
+  schedules
+}) {
+  const sessionsEnabled = isSessionsChromeEnabled({ sessions });
+  return {
+    ...routes,
+    settings: isSettingsChromeEnabled({ catalog, capabilities }) ? routes.settings : null,
+    sessionsBrowser: sessionsEnabled ? routes.sessionsBrowser : null,
+    libraryAgent: sessionsEnabled ? routes.libraryAgent : null,
+    schedules: isSchedulesChromeEnabled({ schedules }) ? routes.schedules : null
+  };
+}
+
+// src/server/ShellModeContext.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/server/draftSpecPreferences.ts
+var DRAFT_SPEC_PREFERENCES_STORAGE_KEY = "tfy-aui-draft-spec-preferences";
+var CHAT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY = "tfy-aui-chat-draft-spec-preferences";
+var AGENT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY = "tfy-aui-agent-draft-spec-preferences";
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isMountList(value) {
+  return Array.isArray(value) && value.every(isObject);
+}
+function isAgentSpec(value) {
+  if (!isObject(value)) return false;
+  const model = Reflect.get(value, "model");
+  if (!isObject(model) || typeof Reflect.get(model, "name") !== "string") return false;
+  const params = Reflect.get(model, "params");
+  if (params !== void 0 && !isObject(params)) return false;
+  const skills = Reflect.get(value, "skills");
+  if (skills !== void 0 && !isMountList(skills)) return false;
+  const mcpServers = Reflect.get(value, "mcpServers");
+  if (mcpServers !== void 0 && !isMountList(mcpServers)) return false;
+  const config = Reflect.get(value, "config");
+  return config === void 0 || isObject(config);
+}
+function isStoredDraftSpecPreferences(value) {
+  return isObject(value) && Reflect.get(value, "version") === 1 && isAgentSpec(Reflect.get(value, "spec"));
+}
+function storageKeyForKind(kind) {
+  return kind === "chat" ? CHAT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY : AGENT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY;
+}
+function selectChatDraftSpecPreferences(spec) {
+  return {
+    model: spec.model,
+    ...spec.skills !== void 0 ? { skills: spec.skills } : {},
+    ...spec.mcpServers !== void 0 ? { mcpServers: spec.mcpServers } : {}
+  };
+}
+function selectAgentDraftSpecPreferences(spec) {
+  return {
+    ...selectChatDraftSpecPreferences(spec),
+    ...spec.config !== void 0 ? { config: spec.config } : {}
+  };
+}
+function selectDraftSpecPreferences(spec, kind) {
+  return kind === "chat" ? selectChatDraftSpecPreferences(spec) : selectAgentDraftSpecPreferences(spec);
+}
+function readSandboxEnabled(spec) {
+  if (spec.config === void 0) return void 0;
+  const sandbox = Reflect.get(spec.config, "sandbox");
+  if (!isObject(sandbox)) return void 0;
+  const enabled = Reflect.get(sandbox, "enabled");
+  return typeof enabled === "boolean" ? enabled : void 0;
+}
+function withCapabilitiesSandbox(spec, sandboxEnabled) {
+  if (sandboxEnabled !== false || readSandboxEnabled(spec) === false) return spec;
+  const config = {
+    ...spec.config,
+    sandbox: { ...spec.config?.sandbox, enabled: false }
+  };
+  return {
+    ...spec,
+    config
+  };
+}
+function readStoredSpec(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = JSON.parse(window.localStorage.getItem(key) ?? "null");
+    return isStoredDraftSpecPreferences(stored) ? stored.spec : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoredSpec(key, spec) {
+  if (typeof window === "undefined") return false;
+  try {
+    const stored = { version: 1, spec };
+    window.localStorage.setItem(key, JSON.stringify(stored));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function migrateLegacyDraftPreferences() {
+  if (typeof window === "undefined") return;
+  const legacy = readStoredSpec(DRAFT_SPEC_PREFERENCES_STORAGE_KEY);
+  if (legacy == null) return;
+  const chatReady = readStoredSpec(CHAT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY) != null || writeStoredSpec(CHAT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY, selectChatDraftSpecPreferences(legacy));
+  const agentReady = readStoredSpec(AGENT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY) != null || writeStoredSpec(AGENT_DRAFT_SPEC_PREFERENCES_STORAGE_KEY, selectAgentDraftSpecPreferences(legacy));
+  if (!chatReady || !agentReady) return;
+  try {
+    window.localStorage.removeItem(DRAFT_SPEC_PREFERENCES_STORAGE_KEY);
+  } catch {
+  }
+}
+function readDraftSpecPreferences(kind) {
+  migrateLegacyDraftPreferences();
+  const stored = readStoredSpec(storageKeyForKind(kind));
+  return stored == null ? null : selectDraftSpecPreferences(stored, kind);
+}
+function writeDraftSpecPreferences(kind, spec) {
+  writeStoredSpec(storageKeyForKind(kind), selectDraftSpecPreferences(spec, kind));
+}
+
+// src/server/ShellModeContext.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var DEFAULT_AGENT_CONFIG = {
+  mode: "AgentLibraryWithComposer"
+};
+var ShellModeContext = createContext2(null);
+var FALLBACK_MUTABLE_SPEC = {
+  model: { name: "openai-main/gpt-4.1" }
+};
+function mutableSeedFromConfig(config) {
+  if (config.mode === "AgentComposer" || config.mode === "AgentLibraryWithComposer") {
+    return config.defaultAgentSpec ?? FALLBACK_MUTABLE_SPEC;
+  }
+  return FALLBACK_MUTABLE_SPEC;
+}
+function initialMode(config, mutableSeed) {
+  switch (config.mode) {
+    case "SingleAgent":
+      return {
+        status: "active",
+        isMutable: false,
+        isCreateAgent: false,
+        agentId: config.name,
+        agentName: config.name,
+        locked: true
+      };
+    case "AgentLibrary":
+      return { status: "idle" };
+    case "AgentComposer":
+    case "AgentLibraryWithComposer":
+      return {
+        status: "active",
+        isMutable: true,
+        isCreateAgent: false,
+        agentSpec: mutableSeed,
+        locked: false
+      };
+  }
+}
+function resolveMutableIsCreateAgent(req) {
+  if (req.isCreateAgent !== void 0) return req.isCreateAgent;
+  return req.agentId != null || req.agentName != null;
+}
+function libraryAgentId(agent) {
+  return agent.agentId ?? agent.name;
+}
+function ShellModeProvider({
+  agentConfig = DEFAULT_AGENT_CONFIG,
+  initialSettingsOpen = false,
+  children
+}) {
+  const capabilities = useServerCapabilities();
+  const catalog = useOptionalCatalogServer();
+  const refreshCapabilities = useOptionalRefreshServerCapabilities();
+  const sessionsServer = useOptionalAgentSessionsServer();
+  const scheduleServer = useOptionalScheduleServer();
+  const chatSeedRef = useRef2(
+    readDraftSpecPreferences("chat") ?? selectDraftSpecPreferences(mutableSeedFromConfig(agentConfig), "chat")
+  );
+  const agentSeedRef = useRef2(
+    readDraftSpecPreferences("agent") ?? selectDraftSpecPreferences(mutableSeedFromConfig(agentConfig), "agent")
+  );
+  const isLibraryEnabled = agentConfig.mode === "AgentLibrary" || agentConfig.mode === "AgentLibraryWithComposer";
+  const isComposerEnabled = agentConfig.mode === "AgentComposer" || agentConfig.mode === "AgentLibraryWithComposer";
+  const isNewChatEnabled = agentConfig.mode !== "AgentLibrary";
+  const locked = agentConfig.mode === "SingleAgent";
+  const [mode, setMode] = useState2(() => initialMode(agentConfig, chatSeedRef.current));
+  const [mutableEpoch, setMutableEpoch] = useState2(0);
+  const [clearEpoch, setClearEpoch] = useState2(0);
+  const [agentsListEpoch, setAgentsListEpoch] = useState2(0);
+  const [settingsOpenState, setSettingsOpenState] = useState2(initialSettingsOpen);
+  const [settingsSection, setSettingsSection] = useState2("models");
+  const [agentConfigOpenState, setAgentConfigOpenState] = useState2(false);
+  const [libraryOpenState, setLibraryOpenState] = useState2(false);
+  const [sessionsOpenState, setSessionsOpenState] = useState2(false);
+  const [libraryAgentId2, setLibraryAgentId] = useState2(null);
+  const [schedulesOpenState, setSchedulesOpenState] = useState2(false);
+  const [historyAgentFilter, setHistoryAgentFilter] = useState2(null);
+  const [pendingSessionId, setPendingSessionId] = useState2(void 0);
+  const [pendingSessionEpoch, setPendingSessionEpoch] = useState2(0);
+  const settingsEnabled = isSettingsChromeEnabled({ catalog, capabilities });
+  const settingsOpen = settingsEnabled && settingsOpenState;
+  const sessionsEnabled = isSessionsChromeEnabled({ sessions: sessionsServer });
+  const schedulesEnabled = isSchedulesChromeEnabled({ schedules: scheduleServer });
+  const schedulesOpen = schedulesEnabled && schedulesOpenState;
+  const libraryOpen = isLibraryEnabled && libraryOpenState;
+  const sessionsOpen = sessionsEnabled && sessionsOpenState;
+  const setSessionsOpen = useCallback2(
+    (open) => {
+      if (open) {
+        setSettingsOpenState(false);
+        setAgentConfigOpenState(false);
+        setLibraryOpenState(false);
+        setLibraryAgentId(null);
+        setSchedulesOpenState(false);
+      } else {
+        replaceSessionShareSearch({ view: null });
+      }
+      setSessionsOpenState(sessionsEnabled && open);
+    },
+    [sessionsEnabled]
+  );
+  const setLibraryOpen = useCallback2(
+    (open) => {
+      if (!isLibraryEnabled) return;
+      if (open) {
+        setSettingsOpenState(false);
+        setAgentConfigOpenState(false);
+        setSessionsOpen(false);
+        setSchedulesOpenState(false);
+      }
+      setLibraryAgentId(null);
+      setLibraryOpenState(open);
+    },
+    [isLibraryEnabled, setSessionsOpen]
+  );
+  const openLibraryAgent = useCallback2(
+    (agentId) => {
+      if (!isLibraryEnabled || !sessionsEnabled) return;
+      setSettingsOpenState(false);
+      setAgentConfigOpenState(false);
+      setSessionsOpen(false);
+      setSchedulesOpenState(false);
+      setLibraryOpenState(true);
+      setLibraryAgentId(agentId);
+    },
+    [isLibraryEnabled, sessionsEnabled, setSessionsOpen]
+  );
+  const closeLibraryAgent = useCallback2(() => {
+    setLibraryAgentId(null);
+  }, []);
+  const setSettingsOpen = useCallback2(
+    (open, section) => {
+      if (section !== void 0) {
+        setSettingsSection(section);
+      }
+      if (open) {
+        setAgentConfigOpenState(false);
+        setLibraryOpenState(false);
+        setLibraryAgentId(null);
+        setSessionsOpen(false);
+        setSchedulesOpenState(false);
+      }
+      setSettingsOpenState(settingsEnabled && open);
+    },
+    [setSessionsOpen, settingsEnabled]
+  );
+  const setAgentConfigOpen = useCallback2(
+    (open) => {
+      if (open) {
+        setSettingsOpenState(false);
+        setLibraryOpenState(false);
+        setLibraryAgentId(null);
+        setSessionsOpen(false);
+        setSchedulesOpenState(false);
+      }
+      setAgentConfigOpenState(open);
+    },
+    [setSessionsOpen]
+  );
+  const setSchedulesOpen = useCallback2(
+    (open) => {
+      if (open) {
+        setSettingsOpenState(false);
+        setAgentConfigOpenState(false);
+        setLibraryOpenState(false);
+        setLibraryAgentId(null);
+        setSessionsOpen(false);
+      }
+      setSchedulesOpenState(schedulesEnabled && open);
+    },
+    [schedulesEnabled, setSessionsOpen]
+  );
+  useEffect2(() => {
+    if (catalog == null || capabilities?.settings?.enabled === false) {
+      setSettingsOpenState(false);
+    }
+  }, [capabilities?.settings?.enabled, catalog]);
+  useEffect2(() => {
+    if (!sessionsEnabled) {
+      setSessionsOpenState(false);
+      setLibraryAgentId(null);
+    }
+  }, [sessionsEnabled]);
+  useEffect2(() => {
+    if (!schedulesEnabled) {
+      setSchedulesOpenState(false);
+    }
+  }, [schedulesEnabled]);
+  const invalidateAgentsList = useCallback2(() => {
+    setAgentsListEpoch((n) => n + 1);
+  }, []);
+  const lockedAgentName = agentConfig.mode === "SingleAgent" ? agentConfig.name : "";
+  const effectiveMode = useMemo2(() => {
+    if (!locked) return mode;
+    return {
+      status: "active",
+      isMutable: false,
+      isCreateAgent: false,
+      agentId: lockedAgentName,
+      agentName: lockedAgentName,
+      locked: true
+    };
+  }, [locked, lockedAgentName, mode]);
+  const agentConfigOpen = effectiveMode.status === "active" && effectiveMode.isMutable && effectiveMode.isCreateAgent && agentConfigOpenState;
+  useEffect2(() => {
+    if (effectiveMode.status !== "active" || !effectiveMode.isMutable || !effectiveMode.isCreateAgent) {
+      setAgentConfigOpenState(false);
+    }
+  }, [effectiveMode]);
+  const listSessionsAgentId = useMemo2(() => {
+    if (locked) return lockedAgentName;
+    if (!isLibraryEnabled) return void 0;
+    return historyAgentFilter?.agentId;
+  }, [locked, lockedAgentName, isLibraryEnabled, historyAgentFilter]);
+  const bumpEpoch = useCallback2((isMutable) => {
+    if (isMutable) setMutableEpoch((n) => n + 1);
+    else setClearEpoch((n) => n + 1);
+  }, []);
+  const selectLibraryAgent = useCallback2(
+    (req) => {
+      if (req.isMutable) {
+        if (!isComposerEnabled) return;
+        setSettingsOpen(false);
+        setLibraryOpenState(false);
+        setLibraryAgentId(null);
+        setSessionsOpen(false);
+        setSchedulesOpen(false);
+        setPendingSessionId(void 0);
+        const isCreateAgent = resolveMutableIsCreateAgent(req);
+        const kind = isCreateAgent ? "agent" : "chat";
+        setMode({
+          status: "active",
+          isMutable: true,
+          isCreateAgent,
+          agentId: req.agentId,
+          agentName: req.agentName,
+          description: req.description,
+          agentSpec: req.agentSpec ?? (kind === "agent" ? agentSeedRef.current : chatSeedRef.current),
+          locked: false
+        });
+        setAgentConfigOpenState(isCreateAgent);
+        bumpEpoch(true);
+        return;
+      }
+      if (!isLibraryEnabled) return;
+      const agentName = req.agentName ?? req.agentId;
+      if (agentName == null) return;
+      setSettingsOpen(false);
+      setLibraryOpenState(false);
+      setLibraryAgentId(null);
+      setSessionsOpen(false);
+      setSchedulesOpen(false);
+      setPendingSessionId(void 0);
+      setAgentConfigOpenState(false);
+      setMode({
+        status: "active",
+        isMutable: false,
+        isCreateAgent: false,
+        agentId: req.agentId ?? agentName,
+        agentName,
+        locked: false
+      });
+      if (req.agentId != null) {
+        setHistoryAgentFilter({
+          agentId: req.agentId,
+          agentName,
+          intent: "try-agent"
+        });
+      } else {
+        setHistoryAgentFilter(null);
+      }
+      bumpEpoch(false);
+    },
+    [isComposerEnabled, isLibraryEnabled, bumpEpoch, setSettingsOpen, setSessionsOpen, setSchedulesOpen]
+  );
+  const bindMutableAgent = useCallback2(
+    (req) => {
+      if (!isComposerEnabled) return;
+      setMode((prev) => {
+        if (prev.status !== "active" || !prev.isMutable) return prev;
+        return {
+          status: "active",
+          isMutable: true,
+          isCreateAgent: true,
+          agentId: req.agentId,
+          agentName: req.agentName,
+          description: req.description,
+          agentSpec: req.agentSpec,
+          locked: false
+        };
+      });
+    },
+    [isComposerEnabled]
+  );
+  const selectAgent = useCallback2(
+    (name) => {
+      selectLibraryAgent({ isMutable: false, agentId: name, agentName: name });
+    },
+    [selectLibraryAgent]
+  );
+  const openDraft = useCallback2(() => {
+    if (!isComposerEnabled) return;
+    refreshCapabilities?.();
+    setHistoryAgentFilter(null);
+    selectLibraryAgent({ isMutable: true, isCreateAgent: false, agentSpec: chatSeedRef.current });
+  }, [isComposerEnabled, refreshCapabilities, selectLibraryAgent]);
+  const isActiveAgentBuilder = effectiveMode.status === "active" && effectiveMode.isMutable && effectiveMode.isCreateAgent;
+  const openAgentBuilder = useCallback2(() => {
+    if (!isComposerEnabled) return;
+    refreshCapabilities?.();
+    if (isActiveAgentBuilder) {
+      setSettingsOpen(false);
+      setLibraryOpenState(false);
+      setLibraryAgentId(null);
+      setSessionsOpen(false);
+      setSchedulesOpen(false);
+      setAgentConfigOpenState(true);
+      return;
+    }
+    selectLibraryAgent({ isMutable: true, isCreateAgent: true, agentSpec: agentSeedRef.current });
+  }, [
+    isActiveAgentBuilder,
+    isComposerEnabled,
+    refreshCapabilities,
+    selectLibraryAgent,
+    setSchedulesOpen,
+    setSessionsOpen,
+    setSettingsOpen
+  ]);
+  const sandboxEnabled = capabilities?.sandbox.enabled;
+  const rememberDraftSpec = useCallback2(
+    (agentSpec, kind = "chat") => {
+      const selected = selectDraftSpecPreferences(agentSpec, kind);
+      const preferences = kind === "agent" ? withCapabilitiesSandbox(selected, sandboxEnabled) : selected;
+      if (kind === "chat") {
+        chatSeedRef.current = preferences;
+      } else {
+        agentSeedRef.current = withCapabilitiesSandbox(agentSpec, sandboxEnabled);
+      }
+      writeDraftSpecPreferences(kind, preferences);
+    },
+    [sandboxEnabled]
+  );
+  const openHistorySession = useCallback2(
+    ({
+      sessionId,
+      agentName,
+      isMutable: isMutableOpt,
+      isCreateAgent: isCreateAgentOpt
+    }) => {
+      const isMutable = isMutableOpt ?? agentName == null;
+      if (isMutable) {
+        if (!isComposerEnabled) return;
+      } else if (locked) {
+        if (agentName == null || lockedAgentName !== agentName) return;
+      } else if (!isLibraryEnabled) {
+        return;
+      }
+      setSettingsOpen(false);
+      setLibraryOpenState(false);
+      setLibraryAgentId(null);
+      setSessionsOpen(false);
+      setSchedulesOpen(false);
+      setPendingSessionId(sessionId);
+      setPendingSessionEpoch((n) => n + 1);
+      if (isMutable) {
+        const isCreateAgent = isCreateAgentOpt === true;
+        setMode({
+          status: "active",
+          isMutable: true,
+          isCreateAgent,
+          agentSpec: isCreateAgent ? agentSeedRef.current : chatSeedRef.current,
+          locked: false
+        });
+        setAgentConfigOpenState(isCreateAgent);
+        return;
+      }
+      setAgentConfigOpenState(false);
+      setMode({
+        status: "active",
+        isMutable: false,
+        isCreateAgent: false,
+        locked: false,
+        ...agentName != null ? { agentId: agentName, agentName } : {}
+      });
+    },
+    [isLibraryEnabled, isComposerEnabled, locked, lockedAgentName, setSettingsOpen, setSessionsOpen, setSchedulesOpen]
+  );
+  const clearChat = useCallback2(() => {
+    if (effectiveMode.status === "idle") return;
+    setPendingSessionId(void 0);
+    if (effectiveMode.isMutable) {
+      const kind = effectiveMode.isCreateAgent ? "agent" : "chat";
+      setMode({
+        status: "active",
+        isMutable: true,
+        isCreateAgent: effectiveMode.isCreateAgent,
+        agentId: effectiveMode.agentId,
+        agentName: effectiveMode.agentName,
+        agentSpec: effectiveMode.agentSpec ?? (kind === "agent" ? agentSeedRef.current : chatSeedRef.current),
+        locked: false
+      });
+      setAgentConfigOpenState(effectiveMode.isCreateAgent);
+      bumpEpoch(true);
+      return;
+    }
+    bumpEpoch(false);
+  }, [effectiveMode, bumpEpoch]);
+  const openLibraryHome = useCallback2(() => {
+    if (!isLibraryEnabled || isComposerEnabled) return;
+    setPendingSessionId(void 0);
+    setSettingsOpen(false);
+    setLibraryOpenState(false);
+    setLibraryAgentId(null);
+    setSchedulesOpen(false);
+    setMode({ status: "idle" });
+    bumpEpoch(false);
+  }, [isLibraryEnabled, isComposerEnabled, setSettingsOpen, setSchedulesOpen, bumpEpoch]);
+  const runtimeKey = useMemo2(() => {
+    if (effectiveMode.status === "idle") return "idle";
+    return `chat:${mutableEpoch}:${clearEpoch}`;
+  }, [effectiveMode.status, mutableEpoch, clearEpoch]);
+  const value = useMemo2(
+    () => ({
+      mode: effectiveMode,
+      agentConfigMode: agentConfig.mode,
+      isLibraryEnabled,
+      isComposerEnabled,
+      isNewChatEnabled,
+      settingsOpen,
+      settingsSection,
+      setSettingsOpen,
+      agentConfigOpen,
+      setAgentConfigOpen,
+      libraryOpen,
+      libraryAgentId: libraryAgentId2,
+      setLibraryAgentId,
+      setLibraryOpen,
+      sessionsOpen,
+      setSessionsOpen,
+      openLibraryAgent,
+      closeLibraryAgent,
+      schedulesOpen,
+      setSchedulesOpen,
+      selectLibraryAgent,
+      bindMutableAgent,
+      selectAgent,
+      openDraft,
+      openAgentBuilder,
+      rememberDraftSpec,
+      openHistorySession,
+      clearChat,
+      openLibraryHome,
+      runtimeKey,
+      historyAgentFilter,
+      setHistoryAgentFilter,
+      listSessionsAgentId,
+      pendingSessionId,
+      pendingSessionEpoch,
+      agentsListEpoch,
+      invalidateAgentsList
+    }),
+    [
+      effectiveMode,
+      agentConfig.mode,
+      isLibraryEnabled,
+      isComposerEnabled,
+      isNewChatEnabled,
+      settingsOpen,
+      settingsSection,
+      setSettingsOpen,
+      agentConfigOpen,
+      setAgentConfigOpen,
+      libraryOpen,
+      libraryAgentId2,
+      setLibraryOpen,
+      sessionsOpen,
+      setSessionsOpen,
+      openLibraryAgent,
+      closeLibraryAgent,
+      schedulesOpen,
+      setSchedulesOpen,
+      selectLibraryAgent,
+      bindMutableAgent,
+      selectAgent,
+      openDraft,
+      openAgentBuilder,
+      rememberDraftSpec,
+      openHistorySession,
+      clearChat,
+      openLibraryHome,
+      runtimeKey,
+      historyAgentFilter,
+      listSessionsAgentId,
+      pendingSessionId,
+      pendingSessionEpoch,
+      agentsListEpoch,
+      invalidateAgentsList
+    ]
+  );
+  return /* @__PURE__ */ jsx2(ShellModeContext.Provider, { value, children });
+}
+function useShellMode() {
+  const ctx = useContext2(ShellModeContext);
+  if (ctx == null) {
+    throw new Error("useShellMode must be used within a ShellModeProvider.");
+  }
+  return ctx;
+}
+function useOptionalShellMode() {
+  return useContext2(ShellModeContext);
+}
+function shellIsMutable(mode) {
+  return mode.status === "active" && mode.isMutable;
+}
+function shellIsCreateAgent(mode) {
+  return mode.status === "active" && mode.isMutable && mode.isCreateAgent;
+}
+
+// src/utils/getErrorMessage.ts
+function isRecord(value) {
+  return value != null && typeof value === "object";
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+var LITERAL_ESCAPE_PATTERN = /\\(?:[nrtbfv0'"\\]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2})/;
+var REAL_CONTROL_PATTERN = /[\n\t\b\f\v]/;
+function decodeLiteralEscapes(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (char !== "\\" || i + 1 >= text.length) {
+      out += char;
+      continue;
+    }
+    const next = text[i + 1];
+    switch (next) {
+      case "n":
+        out += "\n";
+        i += 1;
+        break;
+      case "t":
+        out += "	";
+        i += 1;
+        break;
+      case "r":
+        out += "\r";
+        i += 1;
+        break;
+      case "b":
+        out += "\b";
+        i += 1;
+        break;
+      case "f":
+        out += "\f";
+        i += 1;
+        break;
+      case "v":
+        out += "\v";
+        i += 1;
+        break;
+      case "0":
+        out += "\0";
+        i += 1;
+        break;
+      case "\\":
+        out += "\\";
+        i += 1;
+        break;
+      case '"':
+        out += '"';
+        i += 1;
+        break;
+      case "'":
+        out += "'";
+        i += 1;
+        break;
+      case "u": {
+        const hex = text.slice(i + 2, i + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+          out += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 5;
+        } else {
+          out += char;
+        }
+        break;
+      }
+      case "x": {
+        const hex = text.slice(i + 2, i + 4);
+        if (/^[0-9a-fA-F]{2}$/.test(hex)) {
+          out += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 3;
+        } else {
+          out += char;
+        }
+        break;
+      }
+      default:
+        out += char;
+        break;
+    }
+  }
+  return out;
+}
+function decodeErrorMessageEscapes(text) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (REAL_CONTROL_PATTERN.test(normalized) || !LITERAL_ESCAPE_PATTERN.test(normalized)) {
+    return normalized;
+  }
+  return decodeLiteralEscapes(normalized).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function messageFromErrorShaped(value) {
+  if (!isRecord(value)) return void 0;
+  const direct = readNonEmptyString(value.message);
+  if (direct != null) return direct;
+  if (isRecord(value.error)) {
+    return readNonEmptyString(value.error.message);
+  }
+  return void 0;
+}
+function stringifyError(error) {
+  if (typeof error === "string") return error;
+  if (isRecord(error)) {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return Object.prototype.toString.call(error);
+    }
+  }
+  return String(error);
+}
+function getErrorMessage(error, fallback) {
+  if (typeof error === "string") {
+    const trimmed = error.trim();
+    if (trimmed !== "") return decodeErrorMessageEscapes(error);
+    return fallback != null ? decodeErrorMessageEscapes(fallback) : decodeErrorMessageEscapes(error);
+  }
+  if (isRecord(error) && "body" in error) {
+    const fromBody = messageFromErrorShaped(error.body);
+    if (fromBody != null) return decodeErrorMessageEscapes(fromBody);
+    if (error.body != null) {
+      if (typeof error.body === "string") {
+        const trimmed = error.body.trim();
+        if (trimmed !== "") return decodeErrorMessageEscapes(error.body);
+      } else {
+        return stringifyError(error.body);
+      }
+    }
+  }
+  const fromShape = messageFromErrorShaped(error);
+  if (fromShape != null) return decodeErrorMessageEscapes(fromShape);
+  if (fallback != null) return decodeErrorMessageEscapes(fallback);
+  return stringifyError(error);
+}
+
+export {
+  ServerProvider,
+  useServer,
+  useOptionalServer,
+  useServerCapabilities,
+  useServerCapabilitiesSettled,
+  useOptionalRefreshServerCapabilities,
+  useCatalogServer,
+  useOptionalCatalogServer,
+  useAgentSessionsServer,
+  useOptionalAgentSessionsServer,
+  useAgentMetricsServer,
+  useOptionalAgentMetricsServer,
+  useScheduleServer,
+  useOptionalScheduleServer,
+  useOptionalPermissionsServer,
+  SESSION_CUSTOM_RANGE_MAX_DAYS,
+  defaultSessionTimeRange,
+  defaultMetricsTimeRange,
+  sessionTimeRangeFromCreatedAt,
+  resolveSessionTimeRange,
+  readSessionShareSearch,
+  libraryAgentTabFromSearch,
+  writeSessionShareSearch,
+  buildAgentSessionShareUrl,
+  SESSION_SHARE_CHANGE_EVENT,
+  replaceSessionShareSearch,
+  withCapabilitiesSandbox,
+  isSettingsChromeEnabled,
+  isSessionsChromeEnabled,
+  isSchedulesChromeEnabled,
+  isMetricsChromeEnabled,
+  toEffectiveRoutes,
+  DEFAULT_AGENT_CONFIG,
+  libraryAgentId,
+  ShellModeProvider,
+  useShellMode,
+  useOptionalShellMode,
+  shellIsMutable,
+  shellIsCreateAgent,
+  getErrorMessage
+};
+//# sourceMappingURL=chunk-2GIZY3JJ.js.map