ltcai 4.0.1 → 4.2.0

package/frontend/src/App.tsx

@@ -0,0 +1,184 @@
+import * as React from "react";
+import { useQuery } from "@tanstack/react-query";
+import { Command, Menu, Moon, Search, Sun, X } from "lucide-react";
+import { latticeApi } from "@/api/client";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useAppStore } from "@/store/appStore";
+import { commandRoutes, go, parseHash, primaryRoutes, PrimaryRoute } from "@/routes";
+import { BrainPage } from "@/pages/Brain";
+import { AskPage } from "@/pages/Ask";
+import { CapturePage } from "@/pages/Capture";
+import { ActPage } from "@/pages/Act";
+import { LibraryPage } from "@/pages/Library";
+import { SystemPage } from "@/pages/System";
+import { cn } from "@/lib/utils";
+
+function useRoute() {
+  const [route, setRoute] = React.useState(parseHash);
+  React.useEffect(() => {
+    const onHash = () => setRoute(parseHash());
+    window.addEventListener("hashchange", onHash);
+    return () => window.removeEventListener("hashchange", onHash);
+  }, []);
+  return route;
+}
+
+function Page({ primary, tab }: { primary: PrimaryRoute; tab?: string }) {
+  if (primary === "ask") return <AskPage />;
+  if (primary === "capture") return <CapturePage initialTab={tab} />;
+  if (primary === "act") return <ActPage initialTab={tab} />;
+  if (primary === "library") return <LibraryPage initialTab={tab} />;
+  if (primary === "system") return <SystemPage initialTab={tab} />;
+  return <BrainPage initialTab={tab} />;
+}
+
+function CommandPalette({ open, onClose }: { open: boolean; onClose: () => void }) {
+  const [query, setQuery] = React.useState("");
+  const matches = commandRoutes.filter((route) => route.label.toLowerCase().includes(query.toLowerCase()) || route.key.includes(query.toLowerCase()));
+  React.useEffect(() => {
+    if (!open) return;
+    const onKey = (event: KeyboardEvent) => {
+      if (event.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [open, onClose]);
+  if (!open) return null;
+  return (
+    <div className="fixed inset-0 z-50 bg-background/80 p-4 backdrop-blur-sm" role="dialog" aria-modal="true">
+      <div className="mx-auto mt-16 max-w-xl rounded-lg border border-border bg-card shadow-xl">
+        <div className="flex items-center gap-2 border-b border-border p-3">
+          <Search className="h-4 w-4 text-muted-foreground" />
+          <Input value={query} onChange={(e) => setQuery(e.target.value)} autoFocus placeholder="Jump to a capability" />
+          <Button variant="ghost" size="icon" onClick={onClose}><X className="h-4 w-4" /></Button>
+        </div>
+        <div className="max-h-96 overflow-auto p-2">
+          {matches.map((route) => {
+            const Icon = route.icon;
+            return (
+              <button
+                key={route.key}
+                onClick={() => {
+                  go(route.key);
+                  onClose();
+                }}
+                className="flex w-full items-center gap-3 rounded-md px-3 py-2 text-left text-sm hover:bg-muted"
+              >
+                <Icon className="h-4 w-4 text-primary" />
+                {route.label}
+              </button>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default function App() {
+  const route = useRoute();
+  const { theme, setTheme, mode, setMode } = useAppStore();
+  const [drawer, setDrawer] = React.useState(false);
+  const [palette, setPalette] = React.useState(false);
+  const health = useQuery({ queryKey: ["health"], queryFn: latticeApi.health });
+  const workspace = useQuery({ queryKey: ["workspaceOs"], queryFn: latticeApi.workspaceOs });
+
+  React.useEffect(() => {
+    document.documentElement.dataset.theme = theme;
+  }, [theme]);
+  React.useEffect(() => {
+    const onKey = (event: KeyboardEvent) => {
+      if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "k") {
+        event.preventDefault();
+        setPalette(true);
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+
+  const rail = (
+    <aside className="flex h-full w-64 shrink-0 flex-col border-r border-border bg-card">
+      <div className="flex h-16 items-center gap-3 border-b border-border px-4">
+        <div className="grid h-9 w-9 place-items-center rounded-md bg-primary text-primary-foreground font-bold">LA</div>
+        <div>
+          <div className="font-semibold">Lattice AI</div>
+          <div className="text-xs text-muted-foreground">Digital Brain Desktop</div>
+        </div>
+      </div>
+      <nav className="flex-1 space-y-1 overflow-auto p-3">
+        {primaryRoutes.map((item) => {
+          const Icon = item.icon;
+          const active = route.primary === item.id;
+          return (
+            <button
+              key={item.id}
+              onClick={() => {
+                go(item.id);
+                setDrawer(false);
+              }}
+              className={cn(
+                "flex min-h-14 w-full items-center gap-3 rounded-md px-3 py-2 text-left transition",
+                active ? "bg-primary/14 text-foreground" : "text-muted-foreground hover:bg-muted hover:text-foreground",
+              )}
+            >
+              <Icon className="h-5 w-5" />
+              <span>
+                <span className="block text-sm font-medium">{item.label}</span>
+                <span className="block text-xs">{item.description}</span>
+              </span>
+            </button>
+          );
+        })}
+      </nav>
+      <div className="border-t border-border p-3 text-xs text-muted-foreground">
+        <div>Server: {health.data?.ok ? "online" : "unavailable"}</div>
+        <div>Workspace: {String((workspace.data?.data as Record<string, unknown>)?.active_workspace || "local")}</div>
+      </div>
+    </aside>
+  );
+
+  return (
+    <div className="min-h-screen bg-background text-foreground">
+      <CommandPalette open={palette} onClose={() => setPalette(false)} />
+      <div className="hidden lg:fixed lg:inset-y-0 lg:left-0 lg:block">{rail}</div>
+      {drawer ? (
+        <div className="fixed inset-0 z-40 lg:hidden">
+          <button className="absolute inset-0 bg-background/70" aria-label="Close navigation" onClick={() => setDrawer(false)} />
+          <div className="relative h-full">{rail}</div>
+        </div>
+      ) : null}
+      <div className="lg:pl-64">
+        <header className="sticky top-0 z-30 flex h-16 items-center justify-between gap-3 border-b border-border bg-background/95 px-4 backdrop-blur">
+          <div className="flex min-w-0 items-center gap-2">
+            <Button variant="ghost" size="icon" className="lg:hidden" onClick={() => setDrawer(true)}><Menu className="h-5 w-5" /></Button>
+            <div className="min-w-0">
+              <div className="truncate text-sm text-muted-foreground">v4.1.0 Release Candidate</div>
+              <div className="truncate font-medium">{primaryRoutes.find((item) => item.id === route.primary)?.label}</div>
+            </div>
+          </div>
+          <div className="flex items-center gap-2">
+            <Button variant="outline" onClick={() => setPalette(true)}><Command className="h-4 w-4" /> Search</Button>
+            <select
+              value={mode}
+              onChange={(e) => setMode(e.target.value as "basic" | "advanced" | "admin")}
+              className="h-9 rounded-md border border-border bg-background px-2 text-sm"
+              aria-label="Workspace mode"
+            >
+              <option value="basic">Basic</option>
+              <option value="advanced">Advanced</option>
+              <option value="admin">Admin</option>
+            </select>
+            <Button variant="outline" size="icon" onClick={() => setTheme(theme === "dark" ? "light" : "dark")} aria-label="Toggle theme">
+              {theme === "dark" ? <Sun className="h-4 w-4" /> : <Moon className="h-4 w-4" />}
+            </Button>
+          </div>
+        </header>
+        <main className="p-4 lg:p-6">
+          <Page primary={route.primary} tab={route.tab} />
+        </main>
+      </div>
+    </div>
+  );
+}

package/frontend/src/api/client.ts

@@ -0,0 +1,320 @@
+import createClient from "openapi-fetch";
+import type { paths } from "./openapi";
+import { useAppStore } from "@/store/appStore";
+
+export type ApiResult<T = unknown> = {
+  ok: boolean;
+  status: number;
+  data: T;
+  source: "live" | "unavailable";
+  error?: string;
+};
+
+type HttpMethod = "GET" | "POST" | "PATCH" | "DELETE";
+type Query = Record<string, string | number | boolean | null | undefined>;
+
+const TIMEOUT_MS = 10_000;
+const clients = new Map<string, ReturnType<typeof createClient<paths>>>();
+let desktopBase: Promise<string | null> | null = null;
+
+declare global {
+  interface Window {
+    __TAURI_INTERNALS__?: unknown;
+  }
+}
+
+function sameOriginBase() {
+  return "";
+}
+
+async function tauriBackendOrigin(): Promise<string | null> {
+  if (!window.__TAURI_INTERNALS__) return null;
+  if (!desktopBase) {
+    desktopBase = import("@tauri-apps/api/core")
+      .then(({ invoke }) => invoke<string>("backend_origin"))
+      .then((origin) => origin || null)
+      .catch(() => null);
+  }
+  return desktopBase;
+}
+
+async function apiBase() {
+  const stateBase = useAppStore.getState().apiBase;
+  if (stateBase) return stateBase;
+  const desktop = await tauriBackendOrigin();
+  if (desktop) {
+    useAppStore.getState().setApiBase(desktop);
+    return desktop;
+  }
+  return sameOriginBase();
+}
+
+function clientFor(baseUrl: string) {
+  if (!clients.has(baseUrl)) {
+    clients.set(baseUrl, createClient<paths>({ baseUrl, credentials: "same-origin" }));
+  }
+  return clients.get(baseUrl)!;
+}
+
+function emptyFor<T>(shape: T): T {
+  if (Array.isArray(shape)) return [] as T;
+  if (shape && typeof shape === "object") return { ...(shape as Record<string, unknown>) } as T;
+  return shape;
+}
+
+function workspaceHeaders(): Record<string, string> {
+  const workspaceId = useAppStore.getState().workspaceId;
+  return workspaceId ? { "X-Workspace-Id": workspaceId } : {};
+}
+
+async function apiJson<T>(
+  method: HttpMethod,
+  path: string,
+  opts: { body?: unknown; query?: Query; headers?: Record<string, string>; shape: T },
+): Promise<ApiResult<T>> {
+  const base = await apiBase();
+  const client = clientFor(base);
+  const ctrl = new AbortController();
+  const timer = window.setTimeout(() => ctrl.abort(), TIMEOUT_MS);
+  try {
+    const request = {
+      body: opts.body,
+      params: { query: opts.query || {} },
+      headers: { ...workspaceHeaders(), ...(opts.headers || {}) },
+      signal: ctrl.signal,
+    } as never;
+    const call =
+      method === "GET" ? client.GET :
+      method === "POST" ? client.POST :
+      method === "PATCH" ? client.PATCH :
+      client.DELETE;
+    const result = await (call as unknown as (p: never, r: never) => Promise<{ data?: unknown; error?: unknown; response: Response }>)(path as never, request);
+    const { data, error, response } = result;
+    if (response.ok && data !== undefined) {
+      return { ok: true, status: response.status, data: data as T, source: "live" };
+    }
+    return {
+      ok: false,
+      status: response.status,
+      data: emptyFor(opts.shape),
+      source: "unavailable",
+      error: error ? JSON.stringify(error) : response.statusText,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      data: emptyFor(opts.shape),
+      source: "unavailable",
+      error: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    window.clearTimeout(timer);
+  }
+}
+
+function get<T>(path: string, shape: T, query?: Query) {
+  return apiJson<T>("GET", path, { query, shape });
+}
+
+function post<T>(path: string, body: unknown, shape: T) {
+  return apiJson<T>("POST", path, { body, shape });
+}
+
+function patch<T>(path: string, body: unknown, shape: T) {
+  return apiJson<T>("PATCH", path, { body, shape });
+}
+
+function del<T>(path: string, shape: T) {
+  return apiJson<T>("DELETE", path, { shape });
+}
+
+async function uploadDocument(file: File): Promise<ApiResult<Record<string, unknown> | null>> {
+  const base = await apiBase();
+  const form = new FormData();
+  form.append("file", file);
+  try {
+    const res = await fetch(`${base}/upload/document`, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { Accept: "application/json", ...workspaceHeaders() } satisfies HeadersInit,
+      body: form,
+    });
+    const data = await res.json().catch(() => null);
+    return { ok: res.ok, status: res.status, data, source: res.ok ? "live" : "unavailable" };
+  } catch (err) {
+    return { ok: false, status: 0, data: null, source: "unavailable", error: String(err) };
+  }
+}
+
+export type ChatEventHandlers = {
+  onChunk?: (delta: string, fullText: string) => void;
+  onTrace?: (trace: unknown) => void;
+  signal?: AbortSignal;
+};
+
+async function streamChat(body: Record<string, unknown>, handlers: ChatEventHandlers = {}) {
+  const base = await apiBase();
+  const res = await fetch(`${base}/chat`, {
+    method: "POST",
+    credentials: "same-origin",
+    signal: handlers.signal,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      ...workspaceHeaders(),
+    } satisfies HeadersInit,
+    body: JSON.stringify({ stream: true, max_tokens: 2048, temperature: 0.2, ...body }),
+  });
+  if (!res.ok || !res.body || !(res.headers.get("content-type") || "").includes("text/event-stream")) {
+    const payload = await res.json().catch(() => null);
+    return { source: "live", text: "", trace: null, error: payload?.error || payload?.detail || res.statusText };
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let text = "";
+  let trace: unknown = null;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parts = buffer.split("\n\n");
+    buffer = parts.pop() || "";
+    for (const part of parts) {
+      const line = part.split("\n").find((item) => item.startsWith("data:"));
+      if (!line) continue;
+      const raw = line.slice(5).trim();
+      if (raw === "[DONE]") return { source: "live", text, trace };
+      const data = JSON.parse(raw);
+      const delta = data.chunk || data.text || "";
+      if (delta) {
+        text += delta;
+        handlers.onChunk?.(delta, text);
+      }
+      if (data.trace) {
+        trace = data.trace;
+        handlers.onTrace?.(trace);
+      }
+    }
+  }
+  return { source: "live", text, trace };
+}
+
+export const latticeApi = {
+  raw: get,
+  health: () => get("/health", {}),
+  workspaceOs: () => get("/workspace/os", { counts: {}, models: {}, workspace_registry: { workspaces: [] } }),
+  indexStatus: () => get("/api/index/status", {}),
+  rebuildIndex: () => post("/api/index/rebuild", { full: false, include_nodes: true, include_chunks: true }, {}),
+  graph: () => get("/knowledge-graph/graph", { nodes: [], edges: [] }),
+  graphStats: () => get("/knowledge-graph/stats", { nodes: {}, edges: {}, total_nodes: 0, total_edges: 0 }),
+  graphPortability: () => get("/api/knowledge-graph/portability", {}),
+  brainStorage: () => get("/api/brain/storage", {}),
+  dockerPostgres: (body: { consent: boolean; dry_run?: boolean; port?: number }) => post("/api/brain/storage/postgres/docker", body, {}),
+  migratePostgres: (body: { dsn: string; schema_name?: string; dry_run?: boolean }) => post("/api/brain/storage/migrate-postgres", body, {}),
+  graphProvenance: (limit = 50) => get("/api/knowledge-graph/provenance", { items: [] }, { limit }),
+  graphCoverage: () => get("/knowledge-graph/provenance/coverage", {}),
+  graphExport: () => post("/api/knowledge-graph/export", {}, {}),
+  graphBackup: () => post("/api/knowledge-graph/backup", {}, {}),
+  graphImport: (artifact: unknown, dry_run = true) => post("/api/knowledge-graph/import", { artifact, mode: "merge", dry_run }, {}),
+  hybridSearch: async (query: string, weights?: unknown) => {
+    const res = await post<Record<string, unknown>>("/api/search/hybrid", { query, ...(weights ? { weights } : {}) }, { matches: [] });
+    const data = res.data as Record<string, unknown>;
+    if (res.ok && !Array.isArray(data.matches) && Array.isArray(data.results)) {
+      return { ...res, data: { ...data, matches: data.results } };
+    }
+    return res;
+  },
+  browserReadUrl: (url: string) => post("/api/browser/read-url", { url }, {}),
+  memoryManager: () => get("/api/memory/manager", { sources: [], tiers: [], usage: {} }),
+  memoryRecall: (query: string, limit = 20) => post("/api/memory/recall", { query, limit }, { matches: [] }),
+  memoryCompact: () => post("/api/memory/compact", {}, {}),
+  memoryRebuild: () => post("/api/memory/rebuild", { target: "vector" }, {}),
+  chatHistory: () => get("/history/conversations", []),
+  conversation: (id: string) => get(`/history/conversations/${encodeURIComponent(id)}`, { messages: [] }),
+  deleteConversation: (id: string) => del(`/history/conversations/${encodeURIComponent(id)}`, {}),
+  streamChat,
+  uploadDocument,
+  documents: (limit = 200) => get("/knowledge-graph/documents", { documents: [] }, { limit }),
+  localSources: () => get("/knowledge-graph/local/sources", { sources: [], watch: { available: false, active: {} } }),
+  localAgent: () => get("/api/local-agent/status", { agent: { online: false }, sources: [] }),
+  connectFolder: (path: string) => post("/knowledge-graph/local/index", { path, approved: true, watch_enabled: true, consent: { approved: true, source: "desktop-spa" } }, {}),
+  localWatchStop: (source_id: string) => post("/knowledge-graph/local/watch/stop", { source_id }, {}),
+  models: () => get("/models", { catalog: [], loaded: [], recommended: [] }),
+  loadModel: (model_id: string, engine?: string) => post("/models/load", { model_id, engine: engine || null }, {}),
+  unloadModel: (model_id: string) => del(`/models/unload/${encodeURIComponent(model_id)}`, {}),
+  embeddingsStatus: () => get("/api/embeddings/status", {}),
+  agentRuntime: () => get("/agents/api/runtime/status", { runtime: {}, agents: [], runs: [] }),
+  runAgent: (goal: string, roles: string[]) => post("/agents/api/run", { goal, roles }, {}),
+  agentRun: (id: string) => get(`/agents/api/runs/${encodeURIComponent(id)}`, {}),
+  stopAgentRun: (id: string) => post(`/agents/api/runs/${encodeURIComponent(id)}/stop`, {}, {}),
+  agentRegistry: () => get("/agents/api/registry", { agents: [] }),
+  agentCapabilities: () => get("/agents/api/registry/capabilities", { capabilities: {} }),
+  registerAgent: (body: unknown) => post("/agents/api/registry", body, {}),
+  updateAgent: (id: string, body: unknown) => patch(`/agents/api/registry/${encodeURIComponent(id)}`, body, {}),
+  removeAgent: (id: string) => del(`/agents/api/registry/${encodeURIComponent(id)}`, {}),
+  workflowDefinitions: () => get("/workflows/api/definitions", { workflows: [] }),
+  workflowRuns: () => get("/workflows/api/runs", { runs: [] }),
+  workflowTriggers: () => get("/workflows/api/triggers", { armed: [] }),
+  runWorkflow: (id: string) => post(`/workflows/api/definitions/${encodeURIComponent(id)}/run`, {}, {}),
+  updateWorkflow: (id: string, body: unknown) => patch(`/workflows/api/definitions/${encodeURIComponent(id)}`, body, {}),
+  stopWorkflowRun: (id: string) => post(`/workflows/api/runs/${encodeURIComponent(id)}/stop`, {}, {}),
+  resumeWorkflowRun: (id: string, approved: boolean) => post(`/workflows/api/runs/${encodeURIComponent(id)}/resume`, { approved }, {}),
+  hooks: () => get("/api/hooks", { hooks: [] }),
+  hookRuns: () => get("/api/hooks/runs", { runs: [] }, { limit: 50 }),
+  hookRun: (body: unknown) => post("/api/hooks/run", body, {}),
+  permissionsPending: () => get("/permissions/pending", { pending: {}, count: 0 }),
+  approvePermission: (token: string) => post(`/permissions/approve/${encodeURIComponent(token)}`, {}, {}),
+  denyPermission: (token: string) => post(`/permissions/deny/${encodeURIComponent(token)}`, {}, {}),
+  skills: () => get("/workspace/skills", { skills: [] }),
+  skillToggle: (skill: string, enabled: boolean) => post(enabled ? "/workspace/skills/disable" : "/workspace/skills/enable", { skill }, {}),
+  skillsMarketplace: () => get("/skills/marketplace", { skills: [] }),
+  skillInstall: (skill: string, plugin?: string) => post("/workspace/skills/install", { skill, plugin: plugin || "" }, {}),
+  mcpTools: () => get("/mcp/tools", { tools: [], installed_mcps: [] }),
+  mcpRecommend: (query: string) => post("/mcp/recommend", { query, limit: 6 }, {}),
+  templates: () => get("/marketplace/templates", { templates: [], kinds: [] }),
+  installTemplate: (data: unknown) => post("/marketplace/templates/install", { data }, {}),
+  pluginsRegistry: () => get("/plugins/registry", { plugins: [] }),
+  pluginsDirectory: () => get("/plugins/directory", { plugins: [] }),
+  profile: () => get("/account/profile", {}),
+  login: (email: string, password: string) => post("/login", { email, password }, {}),
+  register: (body: unknown) => post("/register", body, {}),
+  logout: () => post("/logout", {}, {}),
+  updateProfile: (body: unknown) => patch("/account/profile", body, {}),
+  changePassword: (current_password: string, new_password: string) => post("/account/change-password", { current_password, new_password }, {}),
+  ssoConfig: () => get("/auth/sso/config", { enabled: false, providers: [] }),
+  workspaceRegistry: () => get("/workspace/registry", { workspaces: [] }),
+  createOrg: (name: string) => post("/workspace/orgs", { name }, {}),
+  activateWorkspace: (workspace_id: string) => post("/workspace/activate", { workspace_id }, {}),
+  archiveWorkspace: (workspace_id: string) => post(`/workspace/orgs/${encodeURIComponent(workspace_id)}/archive`, {}, {}),
+  addWorkspaceMember: (workspace_id: string, user_id: string, role: string) => post(`/workspace/orgs/${encodeURIComponent(workspace_id)}/members`, { user_id, role }, {}),
+  removeWorkspaceMember: (workspace_id: string, user_id: string) => del(`/workspace/orgs/${encodeURIComponent(workspace_id)}/members/${encodeURIComponent(user_id)}`, {}),
+  invitations: () => get("/invitations", { invitations: [] }),
+  createInvitation: (body: unknown) => post("/invitations", body, {}),
+  acceptInvitation: (token: string) => post(`/invitations/${encodeURIComponent(token)}/accept`, {}, {}),
+  snapshots: () => get("/workspace/snapshots", { snapshots: [] }),
+  createSnapshot: (name: string) => post("/workspace/snapshots", { name }, {}),
+  compareSnapshots: (before_id: string, after_id: string) => post("/workspace/snapshots/compare", { before_id, after_id }, {}),
+  restoreSnapshot: (id: string) => post(`/workspace/snapshots/${encodeURIComponent(id)}/restore`, {}, {}),
+  exportSnapshot: (id: string) => post(`/workspace/snapshots/${encodeURIComponent(id)}/export`, {}, {}),
+  timeMachine: () => get("/workspace/time-machine", { events: [] }, { limit: 100 }),
+  realtimeFeed: () => get("/realtime/feed", { events: [] }, { limit: 80 }),
+  presence: () => get("/realtime/presence", { presence: [] }),
+  networkIdentity: () => get("/network/identity", {}),
+  networkPeers: () => get("/network/peers", { peers: [] }),
+  pairPeer: (body: unknown) => post("/network/peers", body, {}),
+  unpairPeer: (id: string) => del(`/network/peers/${encodeURIComponent(id)}`, {}),
+  pushPeer: (id: string, workspace_id?: string | null) => post(`/network/push/${encodeURIComponent(id)}`, { workspace_id }, {}),
+  sysinfo: () => get("/local/sysinfo", {}),
+  computerMemory: () => get("/workspace/computer-memory", {}),
+  setComputerMemory: (enabled: boolean) => post("/workspace/computer-memory", { enabled, consent: { approved: enabled } }, {}),
+  adminSummary: () => get("/admin/summary", {}),
+  adminUsers: () => get("/admin/users", []),
+  adminAudit: () => get("/admin/audit", { recent_events: [] }),
+  adminRoles: () => get("/admin/roles", { roles: [] }),
+  adminPolicies: () => get("/admin/policies", { policies: [] }),
+  adminSecurity: () => get("/admin/security/overview", {}),
+  vpcStatus: () => get("/vpc/status", {}),
+  toolPermissions: () => get("/tools/permissions", { permissions: [] }),
+};