@palettelab/sdk 0.1.14 → 0.1.16

package/dist/index.js

@@ -21,8 +21,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   DataRoomClient: () => DataRoomClient,
+  Link: () => Link,
   OrganizationClient: () => OrganizationClient,
   PaletteApiError: () => PaletteApiError,
+  PaletteAppRouter: () => PaletteAppRouter,
   PlatformCtx: () => PlatformCtx,
   PluginProvider: () => PluginProvider,
   StorageClient: () => StorageClient,
@@ -42,15 +44,20 @@ __export(src_exports, {
   isPaletteApiError: () => isPaletteApiError,
   isSandboxRuntime: () => isSandboxRuntime,
   normalizePaletteLanguage: () => normalizePaletteLanguage,
+  notFound: () => notFound,
   setBaseUrl: () => setBaseUrl,
   translate: () => translate,
   updateInstallConfig: () => updateInstallConfig,
   uploadToSignedUrl: () => uploadToSignedUrl,
+  useParams: () => useParams,
+  usePathname: () => usePathname,
   usePlatform: () => usePlatform,
   usePluginChat: () => usePluginChat,
   usePluginDataRooms: () => usePluginDataRooms,
   usePluginTasks: () => usePluginTasks,
   usePluginTranslations: () => usePluginTranslations,
+  useRouter: () => useRouter,
+  useSearchParams: () => useSearchParams,
   withPluginProvider: () => withPluginProvider
 });
 module.exports = __toCommonJS(src_exports);
@@ -228,6 +235,7 @@ function createMockPlatformContext(overrides = {}) {
     apiFetch: async () => new Response(JSON.stringify({}), { status: 200 }),
     navigate: () => {
     },
+    routePath: "/",
     showToast: () => {
     },
     ...overrides
@@ -359,6 +367,8 @@ function hasAllPermissions(ctx, permissions) {
 }
 
 // src/storage.ts
+var DEFAULT_CHUNK_SIZE = 8 * 1024 * 1024;
+var MIN_CHUNK_SIZE = 256 * 1024;
 async function uploadToSignedUrl(uploadUrl, file, contentType = "application/octet-stream") {
   const res = await fetch(uploadUrl, {
     method: "PUT",
@@ -367,10 +377,178 @@ async function uploadToSignedUrl(uploadUrl, file, contentType = "application/oct
   });
   if (!res.ok) throw new Error(`Upload failed: ${res.statusText}`);
 }
+function normalizeChunkSize(value) {
+  const raw = Math.max(value || DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE);
+  return Math.ceil(raw / MIN_CHUNK_SIZE) * MIN_CHUNK_SIZE;
+}
+function defaultPluginId() {
+  if (typeof window === "undefined") return "";
+  const match = window.location.pathname.match(/\/apps\/([^/?#]+)/);
+  return match ? decodeURIComponent(match[1]) : "";
+}
+function fileFingerprint(pluginId, file, key) {
+  return [pluginId, key || file.name, file.size, file.lastModified].join(":");
+}
+function sessionStorageKey(pluginId, fingerprint) {
+  return `palette:storage-upload:${pluginId}:${fingerprint}`;
+}
+function readStoredSession(pluginId, fingerprint) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(sessionStorageKey(pluginId, fingerprint));
+    if (!raw) return null;
+    const session = JSON.parse(raw);
+    return session.plugin_id === pluginId && session.fingerprint === fingerprint ? session : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoredSession(pluginId, fingerprint, session) {
+  if (typeof window === "undefined") return;
+  const stored = { ...session, plugin_id: pluginId, fingerprint, updated_at: Date.now() };
+  window.localStorage.setItem(sessionStorageKey(pluginId, fingerprint), JSON.stringify(stored));
+}
+function clearStoredSession(pluginId, fingerprint) {
+  if (typeof window === "undefined") return;
+  window.localStorage.removeItem(sessionStorageKey(pluginId, fingerprint));
+}
+function absoluteApiUrl(pathOrUrl) {
+  return /^https?:\/\//i.test(pathOrUrl) ? pathOrUrl : `${getBaseUrl()}${pathOrUrl}`;
+}
+function isPaletteApiUpload(url) {
+  return url.startsWith(getBaseUrl()) || url.startsWith("/");
+}
+function report(loaded, total, chunkIndex, chunkCount, state, onProgress) {
+  onProgress?.({
+    loaded,
+    total,
+    percentage: total > 0 ? Math.min(100, Math.round(loaded / total * 1e4) / 100) : 100,
+    chunkIndex,
+    chunkCount,
+    state
+  });
+}
+function xhrPut(url, body, headers, signal, onUploadProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("PUT", absoluteApiUrl(url), true);
+    xhr.withCredentials = isPaletteApiUpload(url);
+    for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
+    xhr.upload.onprogress = (event) => {
+      if (event.lengthComputable) onUploadProgress?.(event.loaded);
+    };
+    xhr.onload = () => {
+      const ok = [200, 201, 204, 308].includes(xhr.status);
+      if (!ok) reject(new Error(`Upload failed: ${xhr.status} ${xhr.statusText}`));
+      else resolve({ status: xhr.status, range: xhr.getResponseHeader("Range") });
+    };
+    xhr.onerror = () => reject(new Error("Upload failed"));
+    xhr.onabort = () => reject(new DOMException("Upload aborted", "AbortError"));
+    if (signal) {
+      if (signal.aborted) {
+        xhr.abort();
+        return;
+      }
+      signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+}
+function uploadedFromRange(range) {
+  if (!range) return 0;
+  const match = range.match(/bytes=0-(\d+)/);
+  return match ? Number(match[1]) + 1 : 0;
+}
+async function queryGcsOffset(session) {
+  try {
+    const result = await xhrPut(session.upload_url, new Blob([]), {
+      "Content-Range": `bytes */${session.size}`
+    });
+    if ([200, 201, 204].includes(result.status)) return session.size;
+    return uploadedFromRange(result.range);
+  } catch {
+    return 0;
+  }
+}
+async function queryLocalOffset(session) {
+  const res = await fetch(absoluteApiUrl(session.status_url), { credentials: "include" });
+  if (!res.ok) return 0;
+  const body = await res.json();
+  return Number(body.uploaded_bytes || 0);
+}
+async function queryOffset(session) {
+  if (session.mode === "local_resumable") return queryLocalOffset(session);
+  return queryGcsOffset(session);
+}
 var StorageClient = class {
-  constructor() {
+  constructor(ctx) {
+    this.ctx = ctx;
     this.uploadToSignedUrl = uploadToSignedUrl;
   }
+  pluginId(explicit) {
+    const resolved = explicit || this.ctx?.pluginId || defaultPluginId();
+    if (!resolved) throw new Error("pluginId is required for app storage uploads");
+    return resolved;
+  }
+  async createSession(pluginId, file, options) {
+    const res = await (this.ctx?.apiFetch || apiFetch)(`/api/v1/app-storage/${encodeURIComponent(pluginId)}/uploads`, {
+      method: "POST",
+      body: JSON.stringify({
+        filename: file.name,
+        content_type: options.contentType || file.type || "application/octet-stream",
+        size: file.size,
+        key: options.key || null,
+        resumable: options.resumable ?? true,
+        chunk_size: normalizeChunkSize(options.chunkSize)
+      })
+    });
+    return res.json();
+  }
+  async upload(file, options = {}) {
+    const pluginId = this.pluginId(options.pluginId);
+    const fingerprint = fileFingerprint(pluginId, file, options.key);
+    const stored = options.resumable === false ? null : readStoredSession(pluginId, fingerprint);
+    const session = stored || await this.createSession(pluginId, file, options);
+    writeStoredSession(pluginId, fingerprint, session);
+    const chunkSize = normalizeChunkSize(options.chunkSize || session.chunk_size);
+    const chunkCount = Math.max(1, Math.ceil(file.size / chunkSize));
+    let offset = stored ? await queryOffset(session) : 0;
+    report(offset, file.size, Math.floor(offset / chunkSize), chunkCount, "starting", options.onProgress);
+    while (offset < file.size) {
+      if (options.signal?.aborted) throw new DOMException("Upload aborted", "AbortError");
+      const start = offset;
+      const end = Math.min(file.size, start + chunkSize) - 1;
+      const chunk = file.slice(start, end + 1);
+      const chunkIndex = Math.floor(start / chunkSize) + 1;
+      const lastReportedBase = start;
+      await xhrPut(
+        session.upload_url,
+        chunk,
+        {
+          "Content-Type": session.content_type,
+          "Content-Range": `bytes ${start}-${end}/${file.size}`
+        },
+        options.signal,
+        (loaded) => report(lastReportedBase + loaded, file.size, chunkIndex, chunkCount, "uploading", options.onProgress)
+      );
+      offset = end + 1;
+      report(offset, file.size, chunkIndex, chunkCount, offset >= file.size ? "complete" : "uploading", options.onProgress);
+      writeStoredSession(pluginId, fingerprint, session);
+    }
+    clearStoredSession(pluginId, fingerprint);
+    return {
+      uploadId: session.upload_id,
+      mode: session.mode,
+      bucket: session.bucket,
+      objectPath: session.object_path,
+      fileUrl: session.file_url,
+      contentType: session.content_type,
+      size: session.size
+    };
+  }
+  async resume(file, options = {}) {
+    return this.upload(file, { ...options, resumable: true });
+  }
 };
 
 // src/user-org.ts
@@ -448,7 +626,7 @@ var OrganizationClient = class {
 
 // src/palette-client.ts
 function createPaletteClient(ctx) {
-  const defaultPluginId = () => {
+  const defaultPluginId2 = () => {
     if (ctx?.pluginId) return ctx.pluginId;
     if (typeof window === "undefined") return "";
     const match = window.location.pathname.match(/\/apps\/([^/?#]+)/);
@@ -458,15 +636,15 @@ function createPaletteClient(ctx) {
     user: new UserClient(ctx),
     organization: new OrganizationClient(ctx),
     dataRooms: new DataRoomClient(),
-    storage: new StorageClient(),
+    storage: new StorageClient(ctx),
     config: {
       get: (pluginId = ctx?.pluginId ?? "") => {
-        const resolved = pluginId || defaultPluginId();
+        const resolved = pluginId || defaultPluginId2();
         if (!resolved) throw new Error("pluginId is required to read install config");
         return getInstallConfig(resolved);
       },
       update: (values, pluginId = ctx?.pluginId ?? "") => {
-        const resolved = pluginId || defaultPluginId();
+        const resolved = pluginId || defaultPluginId2();
         if (!resolved) throw new Error("pluginId is required to update install config");
         return updateInstallConfig(resolved, values);
       }
@@ -547,14 +725,207 @@ function usePluginTranslations(resources, options = {}) {
   };
 }
 
-// src/hooks/use-plugin-tasks.ts
+// src/router.tsx
 var import_react4 = require("react");
+var RouterCtx = (0, import_react4.createContext)(null);
+var NOT_FOUND = /* @__PURE__ */ Symbol.for("palette.router.not-found");
+function notFound() {
+  throw Object.assign(new Error("Palette route not found"), { code: NOT_FOUND });
+}
+function normalizePath(path) {
+  const clean = String(path || "/").split("#")[0].split("?")[0] || "/";
+  return `/${clean.replace(/^\/+/, "").replace(/\/+$/, "")}`.replace(/^\/$/, "/");
+}
+function splitPath(path) {
+  return normalizePath(path).split("/").filter(Boolean).map(decodeURIComponent);
+}
+function routeScore(route) {
+  if (typeof route.score === "number") return route.score;
+  return route.segments.reduce((score, segment) => {
+    if (segment.kind === "static") return score + 10;
+    if (segment.kind === "dynamic") return score + 5;
+    return score + (segment.optional ? 1 : 2);
+  }, route.segments.length);
+}
+function matchRoute(route, path) {
+  const parts = splitPath(path);
+  const params = {};
+  let index = 0;
+  for (const segment of route.segments) {
+    if (segment.kind === "catchAll") {
+      const rest = parts.slice(index);
+      if (!segment.optional && rest.length === 0) return null;
+      params[segment.name] = rest;
+      index = parts.length;
+      break;
+    }
+    const value = parts[index];
+    if (value === void 0) return null;
+    if (segment.kind === "static") {
+      if (value !== segment.value) return null;
+    } else {
+      params[segment.name] = value;
+    }
+    index += 1;
+  }
+  return index === parts.length ? params : null;
+}
+function currentPluginPath(pluginId, routePath) {
+  if (routePath) return normalizePath(routePath);
+  if (typeof window === "undefined") return "/";
+  const path = window.location.pathname;
+  if (pluginId) {
+    const prefix = `/apps/${pluginId}`;
+    if (path === prefix) return "/";
+    if (path.startsWith(`${prefix}/`)) return normalizePath(path.slice(prefix.length));
+  }
+  return normalizePath(path);
+}
+function currentSearchParams() {
+  if (typeof window === "undefined") return new URLSearchParams();
+  return new URLSearchParams(window.location.search);
+}
+var PaletteRouteErrorBoundary = class extends import_react4.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.reset = () => this.setState({ error: null });
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  render() {
+    const error = this.state.error;
+    if (!error) return this.props.children;
+    if (error.code === NOT_FOUND && this.props.notFound) {
+      return (0, import_react4.createElement)(this.props.notFound);
+    }
+    if (this.props.fallback) {
+      return (0, import_react4.createElement)(this.props.fallback, { error, reset: this.reset });
+    }
+    throw error;
+  }
+};
+function renderRoute(route) {
+  const page = (0, import_react4.createElement)(route.page);
+  const wrapped = (route.layouts || []).reduceRight(
+    (children, Layout) => (0, import_react4.createElement)(Layout, null, children),
+    page
+  );
+  return (0, import_react4.createElement)(
+    PaletteRouteErrorBoundary,
+    { fallback: route.error, notFound: route.notFound },
+    wrapped
+  );
+}
+function PaletteAppRouter({
+  routes,
+  notFound: NotFound
+}) {
+  const platform = usePlatform();
+  const [location, setLocation] = (0, import_react4.useState)(() => ({
+    pathname: currentPluginPath(platform.pluginId, platform.routePath),
+    searchParams: currentSearchParams()
+  }));
+  (0, import_react4.useEffect)(() => {
+    setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+  }, [platform.pluginId, platform.routePath]);
+  (0, import_react4.useEffect)(() => {
+    const sync = () => setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+    window.addEventListener("popstate", sync);
+    return () => window.removeEventListener("popstate", sync);
+  }, [platform.pluginId, platform.routePath]);
+  const sortedRoutes = (0, import_react4.useMemo)(
+    () => [...routes].sort((a, b) => routeScore(b) - routeScore(a)),
+    [routes]
+  );
+  const matched = (0, import_react4.useMemo)(() => {
+    for (const route of sortedRoutes) {
+      const params = matchRoute(route, location.pathname);
+      if (params) return { route, params };
+    }
+    return null;
+  }, [location.pathname, sortedRoutes]);
+  const navigate = (0, import_react4.useCallback)((target, replace = false) => {
+    const [pathPart, queryPart = ""] = String(target || "/").split("?");
+    const pathname = normalizePath(pathPart);
+    const next = `${pathname}${queryPart ? `?${queryPart}` : ""}`;
+    setLocation({ pathname, searchParams: new URLSearchParams(queryPart) });
+    const currentPath = typeof window === "undefined" ? "" : window.location.pathname;
+    const inPalettePath = platform.pluginId && (currentPath.startsWith(`/apps/${platform.pluginId}`) || platform.routePath !== void 0);
+    const osPath = inPalettePath && platform.pluginId ? `/apps/${platform.pluginId}${pathname === "/" ? "" : pathname}${queryPart ? `?${queryPart}` : ""}` : next;
+    if (replace && typeof window !== "undefined") window.history.replaceState(null, "", osPath);
+    else platform.navigate(osPath);
+  }, [platform]);
+  const state = (0, import_react4.useMemo)(() => ({
+    pathname: location.pathname,
+    searchParams: location.searchParams,
+    params: matched?.params || {},
+    push: (path) => navigate(path, false),
+    replace: (path) => navigate(path, true)
+  }), [location.pathname, location.searchParams, matched?.params, navigate]);
+  const content = matched ? renderRoute(matched.route) : NotFound ? (0, import_react4.createElement)(NotFound) : (0, import_react4.createElement)("div", null, "Page not found");
+  return (0, import_react4.createElement)(RouterCtx.Provider, { value: state }, content);
+}
+function useRouterState() {
+  const value = (0, import_react4.useContext)(RouterCtx);
+  if (!value) throw new Error("Palette app router hooks must be used inside PaletteAppRouter");
+  return value;
+}
+function useRouter() {
+  const { push, replace } = useRouterState();
+  return { push, replace, back: () => window.history.back(), forward: () => window.history.forward() };
+}
+function usePathname() {
+  return useRouterState().pathname;
+}
+function useSearchParams() {
+  return useRouterState().searchParams;
+}
+function useParams() {
+  return useRouterState().params;
+}
+function Link({
+  href,
+  replace,
+  onClick,
+  children,
+  ...props
+}) {
+  const router = useRouter();
+  return (0, import_react4.createElement)(
+    "a",
+    {
+      ...props,
+      href,
+      onClick: (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+        event.preventDefault();
+        if (replace) router.replace(href);
+        else router.push(href);
+      }
+    },
+    children
+  );
+}
+
+// src/hooks/use-plugin-tasks.ts
+var import_react5 = require("react");
 function usePluginTasks(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [tasks, setTasks] = (0, import_react4.useState)([]);
-  const [stats, setStats] = (0, import_react4.useState)(null);
-  const [loading, setLoading] = (0, import_react4.useState)(true);
-  const fetchTasks = (0, import_react4.useCallback)(async () => {
+  const [tasks, setTasks] = (0, import_react5.useState)([]);
+  const [stats, setStats] = (0, import_react5.useState)(null);
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  const fetchTasks = (0, import_react5.useCallback)(async () => {
     try {
       const params = new URLSearchParams();
       if (agentId) params.set("agent_id", String(agentId));
@@ -563,18 +934,18 @@ function usePluginTasks(agentId) {
     } catch {
     }
   }, [apiFetch2, agentId]);
-  const fetchStats = (0, import_react4.useCallback)(async () => {
+  const fetchStats = (0, import_react5.useCallback)(async () => {
     try {
       const res = await apiFetch2("/api/v1/tasks/stats");
       setStats(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     setLoading(true);
     Promise.all([fetchTasks(), fetchStats()]).finally(() => setLoading(false));
   }, [fetchTasks, fetchStats]);
-  const createTask = (0, import_react4.useCallback)(async (payload) => {
+  const createTask = (0, import_react5.useCallback)(async (payload) => {
     const res = await apiFetch2("/api/v1/tasks", {
       method: "POST",
       body: JSON.stringify(payload)
@@ -583,7 +954,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const updateTask = (0, import_react4.useCallback)(async (taskId, payload) => {
+  const updateTask = (0, import_react5.useCallback)(async (taskId, payload) => {
     const res = await apiFetch2(`/api/v1/tasks/${taskId}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
@@ -592,7 +963,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const deleteTask = (0, import_react4.useCallback)(async (taskId) => {
+  const deleteTask = (0, import_react5.useCallback)(async (taskId) => {
     await apiFetch2(`/api/v1/tasks/${taskId}`, { method: "DELETE" });
     await Promise.all([fetchTasks(), fetchStats()]);
   }, [apiFetch2, fetchTasks, fetchStats]);
@@ -600,23 +971,23 @@ function usePluginTasks(agentId) {
 }
 
 // src/hooks/use-plugin-data-rooms.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 function usePluginDataRooms() {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [rooms, setRooms] = (0, import_react5.useState)([]);
-  const [loading, setLoading] = (0, import_react5.useState)(true);
-  const fetchRooms = (0, import_react5.useCallback)(async () => {
+  const [rooms, setRooms] = (0, import_react6.useState)([]);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const fetchRooms = (0, import_react6.useCallback)(async () => {
     try {
       const res = await apiFetch2("/api/v1/data-rooms");
       setRooms(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     setLoading(true);
     fetchRooms().finally(() => setLoading(false));
   }, [fetchRooms]);
-  const fetchFolder = (0, import_react5.useCallback)(async (roomId, folderId) => {
+  const fetchFolder = (0, import_react6.useCallback)(async (roomId, folderId) => {
     const path = folderId ? `/api/v1/data-rooms/${roomId}/folders/${folderId}` : `/api/v1/data-rooms/${roomId}`;
     const res = await apiFetch2(path);
     return res.json();
@@ -625,19 +996,19 @@ function usePluginDataRooms() {
 }
 
 // src/hooks/use-plugin-chat.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 function usePluginChat(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [threads, setThreads] = (0, import_react6.useState)([]);
-  const [messages, setMessages] = (0, import_react6.useState)([]);
-  const [streaming, setStreaming] = (0, import_react6.useState)(false);
-  const [activeThreadId, setActiveThreadId] = (0, import_react6.useState)(null);
-  const abortRef = (0, import_react6.useRef)(null);
-  const fetchThreads = (0, import_react6.useCallback)(async () => {
+  const [threads, setThreads] = (0, import_react7.useState)([]);
+  const [messages, setMessages] = (0, import_react7.useState)([]);
+  const [streaming, setStreaming] = (0, import_react7.useState)(false);
+  const [activeThreadId, setActiveThreadId] = (0, import_react7.useState)(null);
+  const abortRef = (0, import_react7.useRef)(null);
+  const fetchThreads = (0, import_react7.useCallback)(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`);
     setThreads(await res.json());
   }, [apiFetch2, agentId]);
-  const createThread = (0, import_react6.useCallback)(async () => {
+  const createThread = (0, import_react7.useCallback)(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`, { method: "POST" });
     const thread = await res.json();
     setActiveThreadId(thread.id);
@@ -645,13 +1016,13 @@ function usePluginChat(agentId) {
     await fetchThreads();
     return thread;
   }, [apiFetch2, agentId, fetchThreads]);
-  const fetchMessages = (0, import_react6.useCallback)(async (threadId) => {
+  const fetchMessages = (0, import_react7.useCallback)(async (threadId) => {
     const res = await apiFetch2(`/api/v1/chat/threads/${threadId}/messages`);
     const msgs = await res.json();
     setMessages(msgs);
     setActiveThreadId(threadId);
   }, [apiFetch2]);
-  const sendMessage = (0, import_react6.useCallback)(async (threadId, content) => {
+  const sendMessage = (0, import_react7.useCallback)(async (threadId, content) => {
     setStreaming(true);
     abortRef.current = new AbortController();
     const userMsg = {
@@ -719,7 +1090,7 @@ function usePluginChat(agentId) {
       abortRef.current = null;
     }
   }, []);
-  const stopStreaming = (0, import_react6.useCallback)(() => {
+  const stopStreaming = (0, import_react7.useCallback)(() => {
     abortRef.current?.abort();
   }, []);
   return {
@@ -737,8 +1108,10 @@ function usePluginChat(agentId) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataRoomClient,
+  Link,
   OrganizationClient,
   PaletteApiError,
+  PaletteAppRouter,
   PlatformCtx,
   PluginProvider,
   StorageClient,
@@ -758,14 +1131,19 @@ function usePluginChat(agentId) {
   isPaletteApiError,
   isSandboxRuntime,
   normalizePaletteLanguage,
+  notFound,
   setBaseUrl,
   translate,
   updateInstallConfig,
   uploadToSignedUrl,
+  useParams,
+  usePathname,
   usePlatform,
   usePluginChat,
   usePluginDataRooms,
   usePluginTasks,
   usePluginTranslations,
+  useRouter,
+  useSearchParams,
   withPluginProvider
 });