@personaai/react 0.10.0 → 0.14.0

package/dist/index.js

@@ -2453,20 +2453,38 @@ function useFiles(autoFetch = true) {
 
 // src/hooks/useAgents.ts
 import { useCallback as useCallback7, useEffect as useEffect7, useState as useState7 } from "react";
-function useAgents(autoFetch = true) {
+function useAgents(options = true) {
+  const opts = typeof options === "boolean" ? { autoFetch: options } : options;
+  const { autoFetch = true, page, limit, search, category, scope } = opts;
   const { fetchWithAuth } = usePersonaContext();
   const [agents, setAgents] = useState7([]);
+  const [pagination, setPagination] = useState7({
+    total: 0,
+    page: page ?? 1,
+    limit: limit ?? 20,
+    pages: 0
+  });
   const [isLoading, setIsLoading] = useState7(false);
   const [error, setError] = useState7(null);
   const fetchAgents = useCallback7(async () => {
     setIsLoading(true);
     setError(null);
     try {
-      const res = await fetchWithAuth("/agents");
+      const query = new URLSearchParams();
+      if (page) query.set("page", String(page));
+      if (limit) query.set("limit", String(limit));
+      if (search) query.set("search", search);
+      if (category) query.set("category", category);
+      if (scope) query.set("scope", scope);
+      const queryStr = query.toString() ? `?${query.toString()}` : "";
+      const res = await fetchWithAuth(`/agents${queryStr}`);
       if (!res.ok) throw new Error(`Failed to list agents: ${res.statusText}`);
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.items || data?.agents || [];
+      const items = Array.isArray(data) ? data : data?.items ?? [];
       setAgents(items);
+      setPagination(
+        data?.pagination ?? { total: items.length, page: 1, limit: items.length, pages: 1 }
+      );
       return items;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
@@ -2475,83 +2493,929 @@ function useAgents(autoFetch = true) {
     } finally {
       setIsLoading(false);
     }
-  }, [fetchWithAuth]);
+  }, [fetchWithAuth, page, limit, search, category, scope]);
+  const getAgent = useCallback7(
+    async (agentId) => {
+      const res = await fetchWithAuth(`/agents/${agentId}`);
+      if (!res.ok) throw new Error(`Failed to fetch agent: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const createAgent = useCallback7(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/agents", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create agent (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setAgents((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const updateAgent = useCallback7(
+    async (agentId, input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/agents/${agentId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to update agent (${res.status}): ${errText}`);
+        }
+        const updated = await res.json();
+        setAgents((prev) => prev.map((a) => a._id === agentId ? updated : a));
+        return updated;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const deleteAgent = useCallback7(
+    async (agentId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/agents/${agentId}`, { method: "DELETE" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete agent (${res.status}): ${errText}`);
+        }
+        setAgents((prev) => prev.filter((a) => a._id !== agentId));
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteAgents = useCallback7(
+    async (ids) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/agents/bulk-delete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to bulk-delete agents (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        const deletedSet = new Set(result.deleted);
+        setAgents((prev) => prev.filter((a) => !deletedSet.has(a._id)));
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
   useEffect7(() => {
-    if (autoFetch) {
-      void fetchAgents();
-    }
+    if (autoFetch) void fetchAgents();
   }, [autoFetch, fetchAgents]);
   return {
-    agents,
+    agents,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchAgents,
+    getAgent,
+    createAgent,
+    updateAgent,
+    deleteAgent,
+    bulkDeleteAgents
+  };
+}
+
+// src/hooks/useConnection.ts
+import { useCallback as useCallback8, useEffect as useEffect8, useState as useState8 } from "react";
+function useConnection(autoCheck = true) {
+  const { fetchWithAuth } = usePersonaContext();
+  const [health, setHealth] = useState8(null);
+  const [isConnected, setIsConnected] = useState8(false);
+  const [isLoading, setIsLoading] = useState8(false);
+  const checkHealth = useCallback8(async () => {
+    setIsLoading(true);
+    try {
+      const res = await fetchWithAuth("/health");
+      if (res.ok) {
+        const data = await res.json();
+        setHealth(data);
+        setIsConnected(true);
+        return data;
+      }
+      setIsConnected(false);
+      return null;
+    } catch {
+      setIsConnected(false);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth]);
+  useEffect8(() => {
+    if (autoCheck) {
+      void checkHealth();
+    }
+  }, [autoCheck, checkHealth]);
+  return {
+    isConnected,
+    health,
+    isLoading,
+    checkHealth
+  };
+}
+
+// src/hooks/useMcpConnections.ts
+import { useCallback as useCallback9, useEffect as useEffect9, useState as useState9 } from "react";
+function useMcpConnections(options = {}) {
+  const { defaultAgentId, fetchWithAuth } = usePersonaContext();
+  const agentId = options.agentId ?? defaultAgentId;
+  const autoFetch = options.autoFetch ?? true;
+  const [connections, setConnections] = useState9([]);
+  const [isLoading, setIsLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const fetchConnections = useCallback9(async () => {
+    if (!agentId) return [];
+    setIsLoading(true);
+    setError(null);
+    try {
+      const returnTo = options.returnTo ?? (typeof window !== "undefined" ? window.location.href : void 0);
+      const query = returnTo ? `?returnTo=${encodeURIComponent(returnTo)}` : "";
+      const res = await fetchWithAuth(
+        `/agents/${agentId}/mcp-connections${query}`
+      );
+      if (!res.ok)
+        throw new Error(`Failed to load MCP connections: ${res.statusText}`);
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items || [];
+      setConnections(items);
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [agentId, fetchWithAuth, options.returnTo]);
+  const [isDisconnecting, setIsDisconnecting] = useState9(false);
+  const disconnect = useCallback9(
+    async (mcpId) => {
+      setIsDisconnecting(true);
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/mcps/${mcpId}/oauth/user/connection`, {
+          method: "DELETE"
+        });
+        if (!res.ok)
+          throw new Error(`Failed to disconnect MCP: ${res.statusText}`);
+        setConnections(
+          (prev) => prev.map(
+            (c) => c.mcpId === mcpId ? { ...c, connected: false, authorizeUrl: null } : c
+          )
+        );
+        void fetchConnections();
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      } finally {
+        setIsDisconnecting(false);
+      }
+    },
+    [fetchWithAuth, fetchConnections]
+  );
+  useEffect9(() => {
+    if (autoFetch) void fetchConnections();
+  }, [autoFetch, fetchConnections]);
+  return {
+    connections,
+    /** Convenience filter for the common "show a banner for what's missing" case. */
+    unconnected: connections.filter((c) => !c.connected),
+    isLoading,
+    error,
+    refetch: fetchConnections,
+    disconnect,
+    isDisconnecting
+  };
+}
+
+// src/hooks/useMcp.ts
+import { useCallback as useCallback10 } from "react";
+function useMcp(options = {}) {
+  const { fetchWithAuth } = usePersonaContext();
+  const defaultMcpId = options.mcpId;
+  const readResource = useCallback10(
+    async (uri, mcpId) => {
+      const id = mcpId ?? defaultMcpId;
+      if (!id) throw new Error("MCP server ID is required to read resource");
+      const res = await fetchWithAuth(
+        `/mcps/${id}/resource?uri=${encodeURIComponent(uri)}`
+      );
+      if (!res.ok) {
+        throw new Error(`Failed to read MCP resource: ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    [fetchWithAuth, defaultMcpId]
+  );
+  const callTool = useCallback10(
+    async (name, args, mcpId) => {
+      const id = mcpId ?? defaultMcpId;
+      if (!id) throw new Error("MCP server ID is required to call tool");
+      const res = await fetchWithAuth(`/mcps/${id}/call-tool`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name, arguments: args })
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to call MCP tool: ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    [fetchWithAuth, defaultMcpId]
+  );
+  return {
+    readResource,
+    callTool
+  };
+}
+
+// src/hooks/useSkills.ts
+import { useCallback as useCallback11, useEffect as useEffect10, useState as useState10 } from "react";
+function useSkills(options = {}) {
+  const { autoFetch = true, page, limit, search, scope } = options;
+  const { fetchWithAuth } = usePersonaContext();
+  const [skills, setSkills] = useState10([]);
+  const [pagination, setPagination] = useState10({
+    total: 0,
+    page: page ?? 1,
+    limit: limit ?? 20,
+    pages: 0
+  });
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const fetchSkills = useCallback11(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const query = new URLSearchParams();
+      if (page) query.set("page", String(page));
+      if (limit) query.set("limit", String(limit));
+      if (search) query.set("search", search);
+      if (scope) query.set("scope", scope);
+      const queryStr = query.toString() ? `?${query.toString()}` : "";
+      const res = await fetchWithAuth(`/skills${queryStr}`);
+      if (!res.ok) throw new Error(`Failed to list skills: ${res.statusText}`);
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items ?? [];
+      setSkills(items);
+      setPagination(
+        data?.pagination ?? { total: items.length, page: 1, limit: items.length, pages: 1 }
+      );
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, page, limit, search, scope]);
+  const getSkill = useCallback11(
+    async (skillId) => {
+      const res = await fetchWithAuth(`/skills/${skillId}`);
+      if (!res.ok) throw new Error(`Failed to fetch skill: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const createSkill = useCallback11(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/skills", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create skill (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setSkills((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const updateSkill = useCallback11(
+    async (skillId, input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/skills/${skillId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to update skill (${res.status}): ${errText}`);
+        }
+        const updated = await res.json();
+        setSkills((prev) => prev.map((s) => s._id === skillId ? updated : s));
+        return updated;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const deleteSkill = useCallback11(
+    async (skillId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/skills/${skillId}`, { method: "DELETE" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete skill (${res.status}): ${errText}`);
+        }
+        setSkills((prev) => prev.filter((s) => s._id !== skillId));
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteSkills = useCallback11(
+    async (ids) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/skills/bulk-delete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to bulk-delete skills (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        const deletedSet = new Set(result.deleted);
+        setSkills((prev) => prev.filter((s) => !deletedSet.has(s._id)));
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const getSkillUsage = useCallback11(
+    async (skillId) => {
+      const res = await fetchWithAuth(`/skills/${skillId}/usage`);
+      if (!res.ok) throw new Error(`Failed to fetch skill usage: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  useEffect10(() => {
+    if (autoFetch) void fetchSkills();
+  }, [autoFetch, fetchSkills]);
+  return {
+    skills,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchSkills,
+    getSkill,
+    createSkill,
+    updateSkill,
+    deleteSkill,
+    bulkDeleteSkills,
+    getSkillUsage
+  };
+}
+
+// src/hooks/useRcpSources.ts
+import { useCallback as useCallback12, useEffect as useEffect11, useState as useState11 } from "react";
+function useRcpSources(options = {}) {
+  const { autoFetch = true, page, limit, search } = options;
+  const { fetchWithAuth } = usePersonaContext();
+  const [rcpSources, setRcpSources] = useState11([]);
+  const [pagination, setPagination] = useState11({
+    total: 0,
+    page: page ?? 1,
+    limit: limit ?? 20,
+    pages: 0
+  });
+  const [isLoading, setIsLoading] = useState11(false);
+  const [error, setError] = useState11(null);
+  const fetchRcpSources = useCallback12(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const query = new URLSearchParams();
+      if (page) query.set("page", String(page));
+      if (limit) query.set("limit", String(limit));
+      if (search) query.set("search", search);
+      const queryStr = query.toString() ? `?${query.toString()}` : "";
+      const res = await fetchWithAuth(`/rcp-sources${queryStr}`);
+      if (!res.ok) throw new Error(`Failed to list RCP sources: ${res.statusText}`);
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items ?? [];
+      setRcpSources(items);
+      setPagination(
+        data?.pagination ?? { total: items.length, page: 1, limit: items.length, pages: 1 }
+      );
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, page, limit, search]);
+  const getRcpSource = useCallback12(
+    async (sourceId) => {
+      const res = await fetchWithAuth(`/rcp-sources/${sourceId}`);
+      if (!res.ok) throw new Error(`Failed to fetch RCP source: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const createRcpSource = useCallback12(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/rcp-sources", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create RCP source (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setRcpSources((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const updateRcpSource = useCallback12(
+    async (sourceId, input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/rcp-sources/${sourceId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to update RCP source (${res.status}): ${errText}`);
+        }
+        const updated = await res.json();
+        setRcpSources((prev) => prev.map((s) => s._id === sourceId ? updated : s));
+        return updated;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const deleteRcpSource = useCallback12(
+    async (sourceId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/rcp-sources/${sourceId}`, { method: "DELETE" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete RCP source (${res.status}): ${errText}`);
+        }
+        setRcpSources((prev) => prev.filter((s) => s._id !== sourceId));
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteRcpSources = useCallback12(
+    async (ids) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/rcp-sources/bulk-delete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to bulk-delete RCP sources (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        const deletedSet = new Set(result.deleted);
+        setRcpSources((prev) => prev.filter((s) => !deletedSet.has(s._id)));
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const getRcpSourceUsage = useCallback12(
+    async (sourceId) => {
+      const res = await fetchWithAuth(`/rcp-sources/${sourceId}/usage`);
+      if (!res.ok) throw new Error(`Failed to fetch RCP source usage: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const testRcpSourceConnection = useCallback12(
+    async (sourceId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/rcp-sources/${sourceId}/test`, { method: "POST" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to test RCP source connection (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        setRcpSources(
+          (prev) => prev.map(
+            (s) => s._id === sourceId ? { ...s, tools: result.tools, lastTestedAt: (/* @__PURE__ */ new Date()).toISOString() } : s
+          )
+        );
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  useEffect11(() => {
+    if (autoFetch) void fetchRcpSources();
+  }, [autoFetch, fetchRcpSources]);
+  return {
+    rcpSources,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchRcpSources,
+    getRcpSource,
+    createRcpSource,
+    updateRcpSource,
+    deleteRcpSource,
+    bulkDeleteRcpSources,
+    getRcpSourceUsage,
+    testRcpSourceConnection
+  };
+}
+
+// src/hooks/useKnowledgeBases.ts
+import { useCallback as useCallback13, useEffect as useEffect12, useState as useState12 } from "react";
+function useKnowledgeBases(options = {}) {
+  const { autoFetch = true, page, limit, search, scope } = options;
+  const { fetchWithAuth } = usePersonaContext();
+  const [knowledgeBases, setKnowledgeBases] = useState12([]);
+  const [pagination, setPagination] = useState12({
+    total: 0,
+    page: page ?? 1,
+    limit: limit ?? 20,
+    pages: 0
+  });
+  const [isLoading, setIsLoading] = useState12(false);
+  const [isUploading, setIsUploading] = useState12(false);
+  const [error, setError] = useState12(null);
+  const fetchKnowledgeBases = useCallback13(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const query = new URLSearchParams();
+      if (page) query.set("page", String(page));
+      if (limit) query.set("limit", String(limit));
+      if (search) query.set("search", search);
+      if (scope) query.set("scope", scope);
+      const queryStr = query.toString() ? `?${query.toString()}` : "";
+      const res = await fetchWithAuth(`/knowledge${queryStr}`);
+      if (!res.ok) throw new Error(`Failed to list knowledge bases: ${res.statusText}`);
+      const data = await res.json();
+      const items = Array.isArray(data) ? data : data?.items ?? [];
+      setKnowledgeBases(items);
+      setPagination(
+        data?.pagination ?? { total: items.length, page: 1, limit: items.length, pages: 1 }
+      );
+      return items;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchWithAuth, page, limit, search, scope]);
+  const getKnowledgeBase = useCallback13(
+    async (kbId) => {
+      const res = await fetchWithAuth(`/knowledge/${kbId}`);
+      if (!res.ok) throw new Error(`Failed to fetch knowledge base: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const createKnowledgeBase = useCallback13(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/knowledge", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create knowledge base (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setKnowledgeBases((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const updateKnowledgeBase = useCallback13(
+    async (kbId, input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/knowledge/${kbId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to update knowledge base (${res.status}): ${errText}`);
+        }
+        const updated = await res.json();
+        setKnowledgeBases((prev) => prev.map((kb) => kb._id === kbId ? updated : kb));
+        return updated;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const deleteKnowledgeBase = useCallback13(
+    async (kbId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/knowledge/${kbId}`, { method: "DELETE" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete knowledge base (${res.status}): ${errText}`);
+        }
+        setKnowledgeBases((prev) => prev.filter((kb) => kb._id !== kbId));
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteKnowledgeBases = useCallback13(
+    async (ids) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/knowledge/bulk-delete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to bulk-delete knowledge bases (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        const deletedSet = new Set(result.deleted);
+        setKnowledgeBases((prev) => prev.filter((kb) => !deletedSet.has(kb._id)));
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const getKnowledgeBaseUsage = useCallback13(
+    async (kbId) => {
+      const res = await fetchWithAuth(`/knowledge/${kbId}/usage`);
+      if (!res.ok) throw new Error(`Failed to fetch knowledge base usage: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const uploadDocuments = useCallback13(
+    async (kbId, files) => {
+      setIsUploading(true);
+      setError(null);
+      try {
+        const body = new FormData();
+        for (const file of files) {
+          if (file.content instanceof Blob) {
+            body.append("files", file.content, file.filename);
+          } else {
+            body.append("files", {
+              uri: file.content.uri,
+              name: file.content.name ?? file.filename,
+              type: file.content.type ?? file.contentType
+            });
+          }
+        }
+        const res = await fetchWithAuth(`/knowledge/${kbId}/documents`, {
+          method: "POST",
+          body
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to upload documents (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        setKnowledgeBases(
+          (prev) => prev.map(
+            (kb) => kb._id === kbId ? { ...kb, documentCount: result.documentCount, chunkCount: result.chunkCount } : kb
+          )
+        );
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      } finally {
+        setIsUploading(false);
+      }
+    },
+    [fetchWithAuth]
+  );
+  const listDocuments = useCallback13(
+    async (kbId) => {
+      const res = await fetchWithAuth(`/knowledge/${kbId}/documents`);
+      if (!res.ok) throw new Error(`Failed to list documents: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const deleteDocument = useCallback13(
+    async (kbId, sourceName) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(
+          `/knowledge/${kbId}/documents/${encodeURIComponent(sourceName)}`,
+          { method: "DELETE" }
+        );
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete document (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        setKnowledgeBases(
+          (prev) => prev.map(
+            (kb) => kb._id === kbId ? { ...kb, documentCount: result.remainingDocuments, chunkCount: result.remainingChunks } : kb
+          )
+        );
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const searchKnowledgeBase = useCallback13(
+    async (kbId, query, opts) => {
+      const res = await fetchWithAuth(`/knowledge/${kbId}/search`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query, topK: opts?.topK })
+      });
+      if (!res.ok) {
+        const errText = await res.text().catch(() => res.statusText);
+        throw new Error(`Failed to search knowledge base (${res.status}): ${errText}`);
+      }
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  useEffect12(() => {
+    if (autoFetch) void fetchKnowledgeBases();
+  }, [autoFetch, fetchKnowledgeBases]);
+  return {
+    knowledgeBases,
+    pagination,
     isLoading,
+    isUploading,
     error,
-    refetch: fetchAgents
+    refetch: fetchKnowledgeBases,
+    getKnowledgeBase,
+    createKnowledgeBase,
+    updateKnowledgeBase,
+    deleteKnowledgeBase,
+    bulkDeleteKnowledgeBases,
+    getKnowledgeBaseUsage,
+    uploadDocuments,
+    listDocuments,
+    deleteDocument,
+    search: searchKnowledgeBase
   };
 }
 
-// src/hooks/useConnection.ts
-import { useCallback as useCallback8, useEffect as useEffect8, useState as useState8 } from "react";
-function useConnection(autoCheck = true) {
+// src/hooks/useMcpAdmin.ts
+import { useCallback as useCallback14, useEffect as useEffect13, useState as useState13 } from "react";
+function useMcpAdmin(options = {}) {
+  const { autoFetch = true, page, limit, search } = options;
   const { fetchWithAuth } = usePersonaContext();
-  const [health, setHealth] = useState8(null);
-  const [isConnected, setIsConnected] = useState8(false);
-  const [isLoading, setIsLoading] = useState8(false);
-  const checkHealth = useCallback8(async () => {
-    setIsLoading(true);
-    try {
-      const res = await fetchWithAuth("/health");
-      if (res.ok) {
-        const data = await res.json();
-        setHealth(data);
-        setIsConnected(true);
-        return data;
-      }
-      setIsConnected(false);
-      return null;
-    } catch {
-      setIsConnected(false);
-      return null;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [fetchWithAuth]);
-  useEffect8(() => {
-    if (autoCheck) {
-      void checkHealth();
-    }
-  }, [autoCheck, checkHealth]);
-  return {
-    isConnected,
-    health,
-    isLoading,
-    checkHealth
-  };
-}
-
-// src/hooks/useMcpConnections.ts
-import { useCallback as useCallback9, useEffect as useEffect9, useState as useState9 } from "react";
-function useMcpConnections(options = {}) {
-  const { defaultAgentId, fetchWithAuth } = usePersonaContext();
-  const agentId = options.agentId ?? defaultAgentId;
-  const autoFetch = options.autoFetch ?? true;
-  const [connections, setConnections] = useState9([]);
-  const [isLoading, setIsLoading] = useState9(false);
-  const [error, setError] = useState9(null);
-  const fetchConnections = useCallback9(async () => {
-    if (!agentId) return [];
+  const [mcps, setMcps] = useState13([]);
+  const [pagination, setPagination] = useState13({
+    total: 0,
+    page: page ?? 1,
+    limit: limit ?? 20,
+    pages: 0
+  });
+  const [isLoading, setIsLoading] = useState13(false);
+  const [error, setError] = useState13(null);
+  const fetchMcps = useCallback14(async () => {
     setIsLoading(true);
     setError(null);
     try {
-      const returnTo = options.returnTo ?? (typeof window !== "undefined" ? window.location.href : void 0);
-      const query = returnTo ? `?returnTo=${encodeURIComponent(returnTo)}` : "";
-      const res = await fetchWithAuth(
-        `/agents/${agentId}/mcp-connections${query}`
-      );
-      if (!res.ok)
-        throw new Error(`Failed to load MCP connections: ${res.statusText}`);
+      const query = new URLSearchParams();
+      if (page) query.set("page", String(page));
+      if (limit) query.set("limit", String(limit));
+      if (search) query.set("search", search);
+      query.set("scope", "mine");
+      const res = await fetchWithAuth(`/mcps?${query.toString()}`);
+      if (!res.ok) throw new Error(`Failed to list MCPs: ${res.statusText}`);
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.items || [];
-      setConnections(items);
+      const items = Array.isArray(data) ? data : data?.items ?? [];
+      setMcps(items);
+      setPagination(
+        data?.pagination ?? { total: items.length, page: 1, limit: items.length, pages: 1 }
+      );
       return items;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
@@ -2560,83 +3424,172 @@ function useMcpConnections(options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [agentId, fetchWithAuth, options.returnTo]);
-  useEffect9(() => {
-    if (autoFetch) void fetchConnections();
-  }, [autoFetch, fetchConnections]);
-  return {
-    connections,
-    /** Convenience filter for the common "show a banner for what's missing" case. */
-    unconnected: connections.filter((c) => !c.connected),
-    isLoading,
-    error,
-    refetch: fetchConnections
-  };
-}
-
-// src/hooks/useMcp.ts
-import { useCallback as useCallback10 } from "react";
-function useMcp(options = {}) {
-  const { fetchWithAuth } = usePersonaContext();
-  const defaultMcpId = options.mcpId;
-  const readResource = useCallback10(
-    async (uri, mcpId) => {
-      const id = mcpId ?? defaultMcpId;
-      if (!id) throw new Error("MCP server ID is required to read resource");
-      const res = await fetchWithAuth(
-        `/mcps/${id}/resource?uri=${encodeURIComponent(uri)}`
-      );
-      if (!res.ok) {
-        throw new Error(`Failed to read MCP resource: ${res.statusText}`);
+  }, [fetchWithAuth, page, limit, search]);
+  const getMcp = useCallback14(
+    async (mcpId) => {
+      const res = await fetchWithAuth(`/mcps/${mcpId}`);
+      if (!res.ok) throw new Error(`Failed to fetch MCP: ${res.statusText}`);
+      return res.json();
+    },
+    [fetchWithAuth]
+  );
+  const createMcp = useCallback14(
+    async (input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/mcps", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to create MCP (${res.status}): ${errText}`);
+        }
+        const created = await res.json();
+        setMcps((prev) => [created, ...prev]);
+        return created;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
       }
-      return await res.json();
     },
-    [fetchWithAuth, defaultMcpId]
+    [fetchWithAuth]
   );
-  const callTool = useCallback10(
-    async (name, args, mcpId) => {
-      const id = mcpId ?? defaultMcpId;
-      if (!id) throw new Error("MCP server ID is required to call tool");
-      const res = await fetchWithAuth(`/mcps/${id}/call-tool`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name, arguments: args })
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to call MCP tool: ${res.statusText}`);
+  const updateMcp = useCallback14(
+    async (mcpId, input) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/mcps/${mcpId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to update MCP (${res.status}): ${errText}`);
+        }
+        const updated = await res.json();
+        setMcps((prev) => prev.map((m) => m._id === mcpId ? updated : m));
+        return updated;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
       }
-      return await res.json();
     },
-    [fetchWithAuth, defaultMcpId]
+    [fetchWithAuth]
+  );
+  const deleteMcp = useCallback14(
+    async (mcpId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/mcps/${mcpId}`, { method: "DELETE" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to delete MCP (${res.status}): ${errText}`);
+        }
+        setMcps((prev) => prev.filter((m) => m._id !== mcpId));
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const bulkDeleteMcps = useCallback14(
+    async (ids) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth("/mcps/bulk-delete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to bulk-delete MCPs (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        const deletedSet = new Set(result.deleted);
+        setMcps((prev) => prev.filter((m) => !deletedSet.has(m._id)));
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
+  );
+  const testConnection = useCallback14(
+    async (mcpId) => {
+      setError(null);
+      try {
+        const res = await fetchWithAuth(`/mcps/${mcpId}/test`, { method: "POST" });
+        if (!res.ok) {
+          const errText = await res.text().catch(() => res.statusText);
+          throw new Error(`Failed to test MCP connection (${res.status}): ${errText}`);
+        }
+        const result = await res.json();
+        setMcps(
+          (prev) => prev.map(
+            (m) => m._id === mcpId ? { ...m, tools: result.tools, resources: result.resources, resourceTemplates: result.resourceTemplates } : m
+          )
+        );
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        throw errorObj;
+      }
+    },
+    [fetchWithAuth]
   );
+  useEffect13(() => {
+    if (autoFetch) void fetchMcps();
+  }, [autoFetch, fetchMcps]);
   return {
-    readResource,
-    callTool
+    mcps,
+    pagination,
+    isLoading,
+    error,
+    refetch: fetchMcps,
+    getMcp,
+    createMcp,
+    updateMcp,
+    deleteMcp,
+    bulkDeleteMcps,
+    testConnection
   };
 }
 
 // src/hooks/useWorkflows.ts
-import { useCallback as useCallback11, useEffect as useEffect10, useState as useState10 } from "react";
+import { useCallback as useCallback15, useEffect as useEffect14, useState as useState14 } from "react";
 function useWorkflows(options) {
   const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
-  const { autoFetch = true, search, status, page, limit } = opts;
+  const { autoFetch = true, search, scope, visibility, isEnabled, page, limit } = opts;
   const { fetchWithAuth } = usePersonaContext();
-  const [workflows, setWorkflows] = useState10([]);
-  const [pagination, setPagination] = useState10({
+  const [workflows, setWorkflows] = useState14([]);
+  const [pagination, setPagination] = useState14({
     page: page ?? 1,
     limit: limit ?? 20,
     total: 0,
     totalPages: 0
   });
-  const [isLoading, setIsLoading] = useState10(false);
-  const [error, setError] = useState10(null);
-  const fetchWorkflows = useCallback11(async () => {
+  const [isLoading, setIsLoading] = useState14(false);
+  const [error, setError] = useState14(null);
+  const fetchWorkflows = useCallback15(async () => {
     setIsLoading(true);
     setError(null);
     try {
       const params = new URLSearchParams();
       if (search) params.set("search", search);
-      if (status) params.set("status", status);
+      if (scope) params.set("scope", scope);
+      if (visibility) params.set("visibility", visibility);
+      if (isEnabled !== void 0) params.set("isEnabled", String(isEnabled));
       if (page) params.set("page", String(page));
       if (limit) params.set("limit", String(limit));
       const queryStr = params.toString() ? `?${params.toString()}` : "";
@@ -2645,14 +3598,17 @@ function useWorkflows(options) {
         throw new Error(`Failed to list workflows: ${res.statusText}`);
       }
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.items || data?.workflows || [];
+      const items = Array.isArray(data) ? data : data?.items ?? [];
       setWorkflows(items);
       if (data?.pagination) {
         setPagination({
           page: data.pagination.page ?? 1,
           limit: data.pagination.limit ?? items.length,
           total: data.pagination.total ?? items.length,
-          totalPages: data.pagination.totalPages ?? 1
+          // Backend's paginationEnvelope() names this field `pages`, not
+          // `totalPages` — this used to always fall through to the `?? 1`
+          // default.
+          totalPages: data.pagination.pages ?? 1
         });
       } else {
         setPagination({
@@ -2670,8 +3626,8 @@ function useWorkflows(options) {
     } finally {
       setIsLoading(false);
     }
-  }, [fetchWithAuth, search, status, page, limit]);
-  const createWorkflow = useCallback11(
+  }, [fetchWithAuth, search, scope, visibility, isEnabled, page, limit]);
+  const createWorkflow = useCallback15(
     async (input) => {
       setError(null);
       try {
@@ -2695,7 +3651,7 @@ function useWorkflows(options) {
     },
     [fetchWithAuth]
   );
-  useEffect10(() => {
+  useEffect14(() => {
     if (autoFetch) {
       void fetchWorkflows();
     }
@@ -2711,17 +3667,17 @@ function useWorkflows(options) {
 }
 
 // src/hooks/useWorkflow.ts
-import { useCallback as useCallback12, useEffect as useEffect11, useState as useState11 } from "react";
+import { useCallback as useCallback16, useEffect as useEffect15, useState as useState15 } from "react";
 function useWorkflow(workflowId, options) {
   const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
   const { autoFetch = true } = opts;
   const { fetchWithAuth } = usePersonaContext();
-  const [workflow, setWorkflow] = useState11(null);
-  const [versions, setVersions] = useState11([]);
-  const [mermaid, setMermaid] = useState11(null);
-  const [isLoading, setIsLoading] = useState11(false);
-  const [error, setError] = useState11(null);
-  const fetchWorkflow = useCallback12(async () => {
+  const [workflow, setWorkflow] = useState15(null);
+  const [versions, setVersions] = useState15([]);
+  const [mermaid, setMermaid] = useState15(null);
+  const [isLoading, setIsLoading] = useState15(false);
+  const [error, setError] = useState15(null);
+  const fetchWorkflow = useCallback16(async () => {
     if (!workflowId) return null;
     setIsLoading(true);
     setError(null);
@@ -2741,20 +3697,31 @@ function useWorkflow(workflowId, options) {
       setIsLoading(false);
     }
   }, [fetchWithAuth, workflowId]);
-  const fetchVersions = useCallback12(async () => {
+  const fetchVersions = useCallback16(async () => {
     if (!workflowId) return [];
     try {
       const res = await fetchWithAuth(`/workflows/${workflowId}/versions`);
       if (!res.ok) return [];
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.items || [];
+      const items = Array.isArray(data) ? data : data?.items ?? [];
       setVersions(items);
       return items;
     } catch {
       return [];
     }
   }, [fetchWithAuth, workflowId]);
-  const fetchMermaid = useCallback12(async () => {
+  const getVersion = useCallback16(
+    async (version) => {
+      if (!workflowId) throw new Error("Workflow ID is required");
+      const res = await fetchWithAuth(`/workflows/${workflowId}/versions/${version}`);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch workflow version (${res.status}): ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    [fetchWithAuth, workflowId]
+  );
+  const fetchMermaid = useCallback16(async () => {
     if (!workflowId) return "";
     try {
       const res = await fetchWithAuth(`/workflows/${workflowId}/mermaid`);
@@ -2767,18 +3734,18 @@ function useWorkflow(workflowId, options) {
       return "";
     }
   }, [fetchWithAuth, workflowId]);
-  const saveDraft = useCallback12(
-    async (draft) => {
+  const updateWorkflow = useCallback16(
+    async (input) => {
       if (!workflowId) throw new Error("Workflow ID is required");
       setError(null);
-      const res = await fetchWithAuth(`/workflows/${workflowId}/draft`, {
-        method: "POST",
+      const res = await fetchWithAuth(`/workflows/${workflowId}`, {
+        method: "PATCH",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ draft })
+        body: JSON.stringify(input)
       });
       if (!res.ok) {
         const errText = await res.text().catch(() => res.statusText);
-        throw new Error(`Failed to save draft (${res.status}): ${errText}`);
+        throw new Error(`Failed to update workflow (${res.status}): ${errText}`);
       }
       const updated = await res.json();
       setWorkflow(updated);
@@ -2786,27 +3753,41 @@ function useWorkflow(workflowId, options) {
     },
     [fetchWithAuth, workflowId]
   );
-  const publish = useCallback12(
-    async (summary) => {
+  const saveDraft = useCallback16(
+    async (draft) => {
       if (!workflowId) throw new Error("Workflow ID is required");
       setError(null);
-      const res = await fetchWithAuth(`/workflows/${workflowId}/publish`, {
-        method: "POST",
+      const res = await fetchWithAuth(`/workflows/${workflowId}/draft`, {
+        method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(summary ? { summary } : {})
+        body: JSON.stringify(draft)
       });
       if (!res.ok) {
         const errText = await res.text().catch(() => res.statusText);
-        throw new Error(`Failed to publish workflow (${res.status}): ${errText}`);
+        throw new Error(`Failed to save draft (${res.status}): ${errText}`);
       }
-      const versionResult = await res.json();
-      void fetchWorkflow();
-      void fetchVersions();
-      return versionResult;
+      const updated = await res.json();
+      setWorkflow(updated);
+      return updated;
     },
-    [fetchWithAuth, workflowId, fetchWorkflow, fetchVersions]
+    [fetchWithAuth, workflowId]
   );
-  const deleteWorkflow = useCallback12(async () => {
+  const publish = useCallback16(async () => {
+    if (!workflowId) throw new Error("Workflow ID is required");
+    setError(null);
+    const res = await fetchWithAuth(`/workflows/${workflowId}/publish`, {
+      method: "POST"
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => res.statusText);
+      throw new Error(`Failed to publish workflow (${res.status}): ${errText}`);
+    }
+    const versionResult = await res.json();
+    void fetchWorkflow();
+    void fetchVersions();
+    return versionResult;
+  }, [fetchWithAuth, workflowId, fetchWorkflow, fetchVersions]);
+  const deleteWorkflow = useCallback16(async () => {
     if (!workflowId) throw new Error("Workflow ID is required");
     setError(null);
     const res = await fetchWithAuth(`/workflows/${workflowId}`, {
@@ -2817,7 +3798,7 @@ function useWorkflow(workflowId, options) {
     }
     setWorkflow(null);
   }, [fetchWithAuth, workflowId]);
-  useEffect11(() => {
+  useEffect15(() => {
     if (autoFetch && workflowId) {
       void fetchWorkflow();
     }
@@ -2830,7 +3811,9 @@ function useWorkflow(workflowId, options) {
     error,
     refetch: fetchWorkflow,
     fetchVersions,
+    getVersion,
     fetchMermaid,
+    updateWorkflow,
     saveDraft,
     publish,
     deleteWorkflow
@@ -2838,25 +3821,25 @@ function useWorkflow(workflowId, options) {
 }
 
 // src/hooks/useWorkflowStream.ts
-import { useCallback as useCallback13, useEffect as useEffect12, useRef as useRef4, useState as useState12 } from "react";
+import { useCallback as useCallback17, useEffect as useEffect16, useRef as useRef4, useState as useState16 } from "react";
 function useWorkflowStream(workflowId, options) {
   const { baseUrl, getAuthToken, fetchWithAuth, logger } = usePersonaContext();
-  const [status, setStatus] = useState12("idle");
-  const [runId, setRunId] = useState12(null);
-  const [activeNodeId, setActiveNodeId] = useState12(null);
-  const [nodeRuns, setNodeRuns] = useState12(
+  const [status, setStatus] = useState16("idle");
+  const [runId, setRunId] = useState16(null);
+  const [activeNodeId, setActiveNodeId] = useState16(null);
+  const [nodeRuns, setNodeRuns] = useState16(
     {}
   );
-  const [text, setText] = useState12("");
-  const [output, setOutput] = useState12(null);
-  const [error, setError] = useState12(null);
-  const [events, setEvents] = useState12([]);
+  const [text, setText] = useState16("");
+  const [output, setOutput] = useState16(null);
+  const [error, setError] = useState16(null);
+  const [events, setEvents] = useState16([]);
   const abortControllerRef = useRef4(null);
   const currentRunIdRef = useRef4(null);
   currentRunIdRef.current = runId;
   const optionsRef = useRef4(options);
   optionsRef.current = options;
-  const cancel = useCallback13(async () => {
+  const cancel = useCallback17(async () => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
@@ -2877,7 +3860,7 @@ function useWorkflowStream(workflowId, options) {
     setStatus("cancelled");
     setActiveNodeId(null);
   }, [fetchWithAuth, logger]);
-  const reset = useCallback13(() => {
+  const reset = useCallback17(() => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
@@ -2891,7 +3874,7 @@ function useWorkflowStream(workflowId, options) {
     setError(null);
     setEvents([]);
   }, []);
-  const processStream = useCallback13(
+  const processStream = useCallback17(
     async (url, method, body, targetRunId) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3056,7 +4039,7 @@ function useWorkflowStream(workflowId, options) {
     },
     [getAuthToken]
   );
-  const start = useCallback13(
+  const start = useCallback17(
     async (input, opts) => {
       const targetWfId = opts?.workflowId || workflowId;
       if (!targetWfId) {
@@ -3077,7 +4060,7 @@ function useWorkflowStream(workflowId, options) {
     },
     [workflowId, baseUrl, processStream]
   );
-  const resume = useCallback13(
+  const resume = useCallback17(
     async (targetRunId, sinceSeq) => {
       if (!targetRunId) {
         throw new Error("Run ID is required to resume stream");
@@ -3090,7 +4073,7 @@ function useWorkflowStream(workflowId, options) {
     },
     [baseUrl, processStream]
   );
-  useEffect12(() => {
+  useEffect16(() => {
     return () => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3115,21 +4098,21 @@ function useWorkflowStream(workflowId, options) {
 }
 
 // src/hooks/useWorkflowRuns.ts
-import { useCallback as useCallback14, useEffect as useEffect13, useState as useState13 } from "react";
+import { useCallback as useCallback18, useEffect as useEffect17, useState as useState17 } from "react";
 function useWorkflowRuns(workflowId, options) {
   const opts = typeof options === "boolean" ? { autoFetch: options } : options ?? {};
   const { autoFetch = true, page = 1, limit = 20 } = opts;
   const { fetchWithAuth } = usePersonaContext();
-  const [runs, setRuns] = useState13([]);
-  const [pagination, setPagination] = useState13({
+  const [runs, setRuns] = useState17([]);
+  const [pagination, setPagination] = useState17({
     page,
     limit,
     total: 0,
     totalPages: 0
   });
-  const [isLoading, setIsLoading] = useState13(false);
-  const [error, setError] = useState13(null);
-  const fetchRuns = useCallback14(async () => {
+  const [isLoading, setIsLoading] = useState17(false);
+  const [error, setError] = useState17(null);
+  const fetchRuns = useCallback18(async () => {
     if (!workflowId) return [];
     setIsLoading(true);
     setError(null);
@@ -3140,14 +4123,16 @@ function useWorkflowRuns(workflowId, options) {
         throw new Error(`Failed to list workflow runs: ${res.statusText}`);
       }
       const data = await res.json();
-      const items = Array.isArray(data) ? data : data?.items || data?.runs || [];
+      const items = Array.isArray(data) ? data : data?.items ?? [];
       setRuns(items);
       if (data?.pagination) {
         setPagination({
           page: data.pagination.page ?? page,
           limit: data.pagination.limit ?? limit,
           total: data.pagination.total ?? items.length,
-          totalPages: data.pagination.totalPages ?? 1
+          // Backend's paginationEnvelope() names this field `pages`, not
+          // `totalPages`.
+          totalPages: data.pagination.pages ?? 1
         });
       }
       return items;
@@ -3159,7 +4144,7 @@ function useWorkflowRuns(workflowId, options) {
       setIsLoading(false);
     }
   }, [fetchWithAuth, workflowId, page, limit]);
-  const getRun = useCallback14(
+  const getRun = useCallback18(
     async (runId) => {
       if (!runId) throw new Error("Run ID is required");
       const res = await fetchWithAuth(`/workflows/runs/${runId}`);
@@ -3170,7 +4155,7 @@ function useWorkflowRuns(workflowId, options) {
     },
     [fetchWithAuth]
   );
-  const cancelRun = useCallback14(
+  const cancelRun = useCallback18(
     async (runId) => {
       if (!runId) throw new Error("Run ID is required");
       const res = await fetchWithAuth(`/workflows/runs/${runId}/cancel`, {
@@ -3185,7 +4170,7 @@ function useWorkflowRuns(workflowId, options) {
     },
     [fetchWithAuth]
   );
-  useEffect13(() => {
+  useEffect17(() => {
     if (autoFetch && workflowId) {
       void fetchRuns();
     }
@@ -3226,10 +4211,14 @@ export {
   useChat,
   useConnection,
   useFiles,
+  useKnowledgeBases,
   useMcp,
+  useMcpAdmin,
   useMcpConnections,
   useMemory,
   usePersonaContext,
+  useRcpSources,
+  useSkills,
   useThreads,
   useVoice,
   useWorkflow,