@ai-matrx/chat 0.4.22 → 0.4.26

package/dist/host/defaults/files-host.js

@@ -0,0 +1,212 @@
+import {
+  configureFilesHost,
+  isFilesHostConfigured
+} from "@ai-matrx/media/files/engine/host/configure";
+import { getStoreSingleton } from "../../store/store-singleton.js";
+const DEFAULT_FILES_SERVICE_URL = "https://files.matrxserver.com";
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const FILES_SERVICE_ROUTES = [
+  [/^\/files\/upload\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/files\/bulk\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/files\/sync\/(?:changes|folders)\/?$/i, /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/?$`, "i"), /* @__PURE__ */ new Set(["GET", "PATCH", "DELETE"])],
+  [new RegExp(`^/files/${UUID}/download/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/pdf-pages/?$`, "i"), /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/files/${UUID}/restore/?$`, "i"), /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/files/${UUID}/asset/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/share-links/?$`, "i"), /* @__PURE__ */ new Set(["GET", "POST"])],
+  [/^\/assets\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/assets\/presets\/?$/i, /* @__PURE__ */ new Set(["GET"])],
+  [/^\/assets\/(?:preview|preview\/multipart|pdf-compress|pdf-compress\/multipart)\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/assets/${UUID}/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [/^\/share\/[^/]+(?:\/download)?\/?$/i, /* @__PURE__ */ new Set(["GET"])]
+];
+function isFilesServiceRoute(path, method = "GET") {
+  const pathname = path.split(/[?#]/, 1)[0];
+  return FILES_SERVICE_ROUTES.some(([pattern, methods]) => pattern.test(pathname) && methods.has(method.toUpperCase()));
+}
+class FilesRequestError extends Error {
+  status;
+  code;
+  userMessage;
+  constructor(status, message, code = "internal") {
+    super(message);
+    this.name = "FilesRequestError";
+    this.status = status;
+    this.code = code;
+    this.userMessage = message;
+  }
+}
+const trim = (url) => url.replace(/\/+$/, "");
+function createDefaultFilesServer(host) {
+  const filesBase = (override) => trim(override ?? DEFAULT_FILES_SERVICE_URL);
+  const serverBase = (override) => trim(override ?? host().server.baseUrl());
+  const baseFor = (path, override, method) => override ? trim(override) : isFilesServiceRoute(path, method) ? filesBase() : serverBase();
+  async function buildHeaders(opts, includeContentType) {
+    const requestId = opts.requestId ?? (globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`);
+    const headers = { ...await host().server.headers?.() ?? {}, "X-Request-Id": requestId };
+    if (opts.organizationId) headers["X-Organization-Id"] = opts.organizationId;
+    if (opts.idempotencyKey) headers["Idempotency-Key"] = opts.idempotencyKey;
+    if (includeContentType) headers["Content-Type"] = "application/json";
+    return { headers, requestId };
+  }
+  const meta = (status, requestId, serverRequestId) => ({ requestId, status, serverRequestId });
+  async function failure(response) {
+    let message = `HTTP ${response.status}`;
+    let code = response.status >= 500 ? "internal" : "invalid_request";
+    try {
+      const body = await response.json();
+      const said = body.user_message ?? body.message ?? body.detail;
+      if (typeof said === "string" && said) message = said;
+      if (typeof body.error === "string") code = body.error;
+    } catch {
+    }
+    return new FilesRequestError(response.status, message, code);
+  }
+  async function send(method, path, opts = {}, body, form) {
+    const { headers, requestId } = await buildHeaders(opts, body !== void 0 && !form);
+    const response = await fetch(`${baseFor(path, opts.baseUrlOverride, method)}${path}`, {
+      method,
+      headers,
+      body: form ?? (body === void 0 ? void 0 : JSON.stringify(body)),
+      signal: opts.signal
+    });
+    if (!response.ok) throw await failure(response);
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : null;
+    return { data, meta: meta(response.status, requestId, response.headers.get("x-request-id")) };
+  }
+  async function download(path, opts = {}) {
+    const { headers, requestId } = await buildHeaders(opts, false);
+    const response = await fetch(`${baseFor(path, opts.baseUrlOverride, "GET")}${path}`, { headers, signal: opts.signal });
+    if (!response.ok) throw await failure(response);
+    const disposition = response.headers.get("content-disposition");
+    const filename = disposition?.match(/filename\*?=(?:UTF-8'')?"?([^";]+)"?/i)?.[1] ?? null;
+    return { blob: await response.blob(), meta: meta(response.status, requestId, response.headers.get("x-request-id")), filename: filename ? decodeURIComponent(filename) : null };
+  }
+  return {
+    resolveFilesBaseUrl: filesBase,
+    resolveBaseUrlForPath: baseFor,
+    buildHeaders: (opts, includeContentType) => buildHeaders(opts, includeContentType),
+    getJson: (path, opts) => send("GET", path, opts),
+    postJson: (path, body, opts) => send("POST", path, opts, body),
+    patchJson: (path, body, opts) => send("PATCH", path, opts, body),
+    putJson: (path, body, opts) => send("PUT", path, opts, body),
+    del: (path, opts) => send("DELETE", path, opts),
+    delJson: (path, body, opts) => send("DELETE", path, opts, body),
+    postMultipart: (path, form, opts) => send("POST", path, opts, void 0, form),
+    uploadWithProgress: (path, form, onProgress, opts = {}) => new Promise((resolve, reject) => {
+      void buildHeaders(opts, false).then(({ headers, requestId }) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("POST", `${baseFor(path, opts.baseUrlOverride, "POST")}${path}`);
+        for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
+        xhr.upload.addEventListener("progress", (event) => onProgress({ loaded: event.loaded, total: event.total }));
+        xhr.addEventListener("load", () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              resolve({ data: xhr.responseText ? JSON.parse(xhr.responseText) : null, meta: meta(xhr.status, requestId, xhr.getResponseHeader("x-request-id")) });
+            } catch (error) {
+              reject(error);
+            }
+          } else {
+            let message = `Upload failed (${xhr.status}).`;
+            try {
+              const body = JSON.parse(xhr.responseText);
+              message = body.user_message ?? body.message ?? body.detail ?? message;
+            } catch {
+            }
+            reject(new FilesRequestError(xhr.status, message));
+          }
+        });
+        xhr.addEventListener("error", () => reject(new FilesRequestError(null, "Upload failed \u2014 check your connection.")));
+        xhr.addEventListener("abort", () => reject(new FilesRequestError(null, "Upload cancelled.", "cancelled")));
+        if (opts.signal) {
+          if (opts.signal.aborted) xhr.abort();
+          else opts.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+        }
+        xhr.send(form);
+      }, reject);
+    }),
+    downloadBlob: download,
+    downloadBlobWithProgress: async (path, onProgress, opts) => {
+      const result = await download(path, opts);
+      onProgress({ loaded: result.blob.size, total: result.blob.size });
+      return result;
+    }
+  };
+}
+const DEFAULT_SHARE_LINK_ORIGIN = "https://aimatrx.com";
+function createDefaultShareLinks(host) {
+  const rpc = (fn, args) => host().db.rpc(fn, args);
+  const shareLinkUrl = (token) => `${DEFAULT_SHARE_LINK_ORIGIN}/s/${token}`;
+  return {
+    shareLinkUrl,
+    async createShareLink(options) {
+      const { data, error } = await rpc("create_share_link", {
+        p_resource_type: options.resourceType,
+        p_resource_id: options.resourceId,
+        p_permission_level: options.permissionLevel ?? "viewer",
+        p_expires_at: options.expiresAt ?? void 0,
+        p_max_uses: options.maxUses ?? void 0,
+        p_label: options.label ?? void 0
+      });
+      if (error) return { success: false, error: error.message ?? "Failed to create link" };
+      const res = data;
+      if (!res?.success || !res.token) return { success: false, error: res?.error ?? "Failed to create link" };
+      return { success: true, token: res.token, shortToken: res.short_token ?? null, url: shareLinkUrl(res.token) };
+    },
+    async listShareLinks(resourceType, resourceId) {
+      const { data, error } = await rpc("list_share_links", { p_resource_type: resourceType, p_resource_id: resourceId });
+      if (error || !Array.isArray(data)) throw new Error(`Could not load this item's share links${error?.message ? `: ${error.message}` : "."}`);
+      return data.map((r) => ({
+        id: r.id,
+        token: r.token,
+        shortToken: r.short_token ?? null,
+        permissionLevel: r.permission_level,
+        label: r.label ?? null,
+        expiresAt: r.expires_at ?? null,
+        maxUses: r.max_uses ?? null,
+        useCount: r.use_count ?? 0,
+        isActive: r.is_active ?? false,
+        createdAt: r.created_at ?? null,
+        lastUsedAt: r.last_used_at ?? null
+      }));
+    },
+    async revokeShareLink(linkId) {
+      const { data, error } = await rpc("revoke_share_link", { p_link_id: linkId });
+      if (error) return { success: false, error: error.message };
+      const res = data;
+      return { success: !!res?.success, error: res?.error };
+    }
+  };
+}
+const UPLOAD_REASON = "upload this file";
+function configureBareFilesHost(host) {
+  if (isFilesHostConfigured()) return;
+  configureFilesHost({
+    db: host.db,
+    server: createDefaultFilesServer(() => host),
+    store: () => getStoreSingleton(),
+    scope: () => ({
+      userId: host.identity.current().userId ?? null,
+      organizationId: host.org.active()?.id ?? null,
+      projectId: null,
+      taskId: null
+    }),
+    shareLinks: createDefaultShareLinks(() => host),
+    ensureOrganizationContext: async ({ organizationId }) => organizationId ?? await host.org.require(UPLOAD_REASON),
+    notify: {
+      success: (message) => host.notify.success(message),
+      error: (message) => host.notify.error(message)
+    }
+  });
+}
+export {
+  DEFAULT_FILES_SERVICE_URL,
+  DEFAULT_SHARE_LINK_ORIGIN,
+  FilesRequestError,
+  configureBareFilesHost,
+  createDefaultFilesServer,
+  createDefaultShareLinks,
+  isFilesServiceRoute
+};

package/dist/host/defaults/memory-navigation.d.ts

@@ -0,0 +1,12 @@
+import type { ChatNavigationPort } from "../contract.js";
+export interface MemoryNavigationOptions {
+    initial?: string | null;
+    home?: string;
+    persist?: (address: string) => void;
+    openExternal?: (href: string) => void;
+}
+/** A memory port plus the address it holds, for hosts that read or restore it. */
+export interface MemoryNavigationPort extends ChatNavigationPort {
+    address(): string;
+}
+export declare function createMemoryNavigation(options?: MemoryNavigationOptions): MemoryNavigationPort;

package/dist/host/defaults/memory-navigation.js

@@ -0,0 +1,102 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useSyncExternalStore } from "react";
+const LOCAL_ORIGIN = "https://chat.memory.local";
+function defaultOpenExternal(href) {
+  if (typeof window !== "undefined") window.open(href, "_blank", "noopener,noreferrer");
+}
+function createMemoryNavigation(options = {}) {
+  const home = options.home ?? "/chat";
+  const openExternal = options.openExternal ?? defaultOpenExternal;
+  let address = options.initial && options.initial.startsWith("/") ? options.initial : home;
+  const listeners = /* @__PURE__ */ new Set();
+  const history = [];
+  const ahead = [];
+  const set = (next) => {
+    if (next === address) return;
+    address = next;
+    for (const listener of listeners) listener();
+    options.persist?.(next);
+  };
+  const toAddress = (href) => {
+    try {
+      const url = new URL(href, LOCAL_ORIGIN + address);
+      return url.origin === LOCAL_ORIGIN ? url.pathname + url.search : null;
+    } catch {
+      return null;
+    }
+  };
+  const go = (href, mode) => {
+    const next = toAddress(href);
+    if (next === null) {
+      openExternal(href);
+      return;
+    }
+    if (mode === "push" && next !== address) {
+      history.push(address);
+      ahead.length = 0;
+    }
+    set(next);
+  };
+  const router = {
+    push: (href) => go(href, "push"),
+    replace: (href) => go(href, "replace"),
+    back: () => {
+      ahead.push(address);
+      set(history.pop() ?? home);
+    },
+    forward: () => {
+      const next = ahead.pop();
+      if (next === void 0) return;
+      history.push(address);
+      set(next);
+    },
+    refresh: () => void 0,
+    prefetch: () => void 0
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const useAddress = () => useSyncExternalStore(subscribe, () => address, () => address);
+  let cached = null;
+  const paramsFor = (current) => {
+    if (cached?.address !== current) {
+      cached = { address: current, params: new URLSearchParams(current.split("?")[1] ?? "") };
+    }
+    return cached.params;
+  };
+  function MemoryLink({ href, children, onClick, prefetch, replace, scroll, ...anchor }) {
+    void prefetch;
+    void scroll;
+    return /* @__PURE__ */ jsx(
+      "a",
+      {
+        ...anchor,
+        href,
+        onClick: (event) => {
+          onClick?.(event);
+          if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey) return;
+          event.preventDefault();
+          go(href, replace ? "replace" : "push");
+        },
+        children
+      }
+    );
+  }
+  return {
+    address: () => address,
+    push: router.push,
+    replace: router.replace,
+    back: router.back,
+    useRouter: () => router,
+    usePathname: () => useAddress().split("?")[0] || home,
+    useSearchParams: () => paramsFor(useAddress()),
+    Link: MemoryLink
+  };
+}
+export {
+  createMemoryNavigation
+};

package/dist/host/defaults/resource-picker-menu.d.ts

@@ -0,0 +1,14 @@
+import type { Resource } from "../../agents/resources/types.js";
+import type { ResourcePickerViewId } from "../../agents/resources/picker-view-id.js";
+export interface DefaultResourcePickerMenuProps {
+    conversationId: string;
+    initialView?: ResourcePickerViewId;
+    initialUploadFiles?: readonly File[];
+    onResourceSelected?: (resource: Resource) => unknown;
+    onExitInitialView?: () => void;
+    onClose?: () => void;
+    [extra: string]: unknown;
+}
+/** The views this default draws; every other view is the host picker's. */
+export declare const DEFAULT_PICKER_VIEWS: ReadonlySet<ResourcePickerViewId>;
+export declare function DefaultResourcePickerMenu({ conversationId, initialView, initialUploadFiles, onResourceSelected, onExitInitialView, onClose, }: DefaultResourcePickerMenuProps): import("react").JSX.Element | null;

package/dist/host/defaults/resource-picker-menu.js

@@ -0,0 +1,117 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Button, Input } from "@ai-matrx/design-system";
+import { useUploadAgentResources } from "../../agents/components/inputs/resources/usePasteImageResource.js";
+const DEFAULT_PICKER_VIEWS = /* @__PURE__ */ new Set(["files", "webpage"]);
+function FilesView({ conversationId, initialUploadFiles, done }) {
+  const upload = useUploadAgentResources(conversationId);
+  const input = useRef(null);
+  const [dragging, setDragging] = useState(false);
+  const started = useRef(false);
+  const send = (files) => {
+    if (files.length === 0) return;
+    void upload(files);
+    done();
+  };
+  useEffect(() => {
+    if (started.current || !initialUploadFiles?.length) return;
+    started.current = true;
+    send([...initialUploadFiles]);
+  });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `m-2 flex flex-col items-center gap-2 rounded-md border border-dashed p-4 text-sm ${dragging ? "border-primary bg-primary/5" : "border-border"}`,
+      "data-chat-default-picker": "files",
+      onDragOver: (event) => {
+        event.preventDefault();
+        setDragging(true);
+      },
+      onDragLeave: () => setDragging(false),
+      onDrop: (event) => {
+        event.preventDefault();
+        setDragging(false);
+        send(Array.from(event.dataTransfer.files));
+      },
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "Drop files here" }),
+        /* @__PURE__ */ jsx(Button, { type: "button", size: "sm", onClick: () => input.current?.click(), children: "Choose files" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: input,
+            type: "file",
+            multiple: true,
+            hidden: true,
+            onChange: (event) => {
+              send(Array.from(event.target.files ?? []));
+              event.target.value = "";
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function normalizeUrl(raw) {
+  const text = raw.trim();
+  if (!text) return null;
+  try {
+    const url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(text) ? text : `https://${text}`);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function LinkView({ select }) {
+  const [text, setText] = useState("");
+  const url = normalizeUrl(text);
+  return /* @__PURE__ */ jsxs(
+    "form",
+    {
+      className: "flex items-center gap-2 p-2",
+      "data-chat-default-picker": "webpage",
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (url) select(url);
+      },
+      children: [
+        /* @__PURE__ */ jsx(Input, { autoFocus: true, className: "h-8 text-sm", placeholder: "https://", value: text, onChange: (event) => setText(event.target.value) }),
+        /* @__PURE__ */ jsx(Button, { type: "submit", size: "sm", disabled: !url, children: "Attach" })
+      ]
+    }
+  );
+}
+function DefaultResourcePickerMenu({
+  conversationId,
+  initialView,
+  initialUploadFiles,
+  onResourceSelected,
+  onExitInitialView,
+  onClose
+}) {
+  const done = () => {
+    onExitInitialView?.();
+    onClose?.();
+  };
+  if (initialView === "files") {
+    return /* @__PURE__ */ jsx(FilesView, { conversationId, initialUploadFiles, done });
+  }
+  if (initialView === "webpage") {
+    return /* @__PURE__ */ jsx(
+      LinkView,
+      {
+        select: (url) => {
+          void onResourceSelected?.({ type: "webpage", data: url });
+          done();
+        }
+      }
+    );
+  }
+  return null;
+}
+export {
+  DEFAULT_PICKER_VIEWS,
+  DefaultResourcePickerMenu
+};

package/dist/host/defaults/setting-control-input.d.ts

@@ -0,0 +1,11 @@
+import type { ControlDefinition } from "../../agents/redux/agent-settings/types.js";
+export interface DefaultSettingControlInputProps {
+    settingKey: string;
+    control: ControlDefinition;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    disabled?: boolean;
+    id?: string;
+    [extra: string]: unknown;
+}
+export declare function DefaultSettingControlInput({ settingKey, control, value, onChange, disabled, id }: DefaultSettingControlInputProps): import("react").JSX.Element;

package/dist/host/defaults/setting-control-input.js

@@ -0,0 +1,91 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Input, Switch, Textarea } from "@ai-matrx/design-system";
+const FIELD = "h-8 w-full text-sm";
+function JsonField({ id, value, disabled, onChange }) {
+  const text = value === void 0 || value === null ? "" : JSON.stringify(value, null, 2);
+  const [draft, setDraft] = useState(text);
+  const [invalid, setInvalid] = useState(false);
+  useEffect(() => setDraft(text), [text]);
+  return /* @__PURE__ */ jsx(
+    Textarea,
+    {
+      id,
+      value: draft,
+      disabled,
+      rows: 3,
+      "aria-invalid": invalid || void 0,
+      className: "w-full font-mono text-xs",
+      onChange: (event) => setDraft(event.target.value),
+      onBlur: () => {
+        if (draft.trim() === "") return onChange(void 0);
+        try {
+          onChange(JSON.parse(draft));
+          setInvalid(false);
+        } catch {
+          setInvalid(true);
+        }
+      }
+    }
+  );
+}
+function DefaultSettingControlInput({ settingKey, control, value, onChange, disabled, id }) {
+  const fieldId = id ?? `setting-${settingKey}`;
+  switch (control.type) {
+    case "boolean":
+      return /* @__PURE__ */ jsx(Switch, { id: fieldId, checked: value === true, disabled, onCheckedChange: (checked) => onChange(checked) });
+    case "enum":
+      return /* @__PURE__ */ jsxs(
+        "select",
+        {
+          id: fieldId,
+          className: `${FIELD} rounded-md border border-input bg-background px-2`,
+          value: typeof value === "string" ? value : "",
+          disabled,
+          onChange: (event) => onChange(event.target.value === "" ? void 0 : event.target.value),
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "", children: "Default" }),
+            (control.enum ?? []).map((option) => /* @__PURE__ */ jsx("option", { value: option, children: option }, option))
+          ]
+        }
+      );
+    case "number":
+    case "integer":
+      return /* @__PURE__ */ jsx(
+        Input,
+        {
+          id: fieldId,
+          type: "number",
+          className: FIELD,
+          value: typeof value === "number" ? String(value) : "",
+          min: control.min,
+          max: control.max,
+          step: control.type === "integer" ? 1 : "any",
+          disabled,
+          onChange: (event) => {
+            const raw = event.target.value;
+            if (raw === "") return onChange(void 0);
+            const parsed = control.type === "integer" ? Number.parseInt(raw, 10) : Number(raw);
+            if (Number.isFinite(parsed)) onChange(parsed);
+          }
+        }
+      );
+    case "string":
+      return /* @__PURE__ */ jsx(
+        Input,
+        {
+          id: fieldId,
+          className: FIELD,
+          value: typeof value === "string" ? value : value === void 0 || value === null ? "" : String(value),
+          disabled,
+          onChange: (event) => onChange(event.target.value === "" ? void 0 : event.target.value)
+        }
+      );
+    default:
+      return /* @__PURE__ */ jsx(JsonField, { id: fieldId, value, disabled, onChange });
+  }
+}
+export {
+  DefaultSettingControlInput
+};

package/dist/host/index.d.ts

@@ -12,6 +12,7 @@ export { createDefaultServer, DEFAULT_CHAT_SERVER_URL, } from "./defaults/server
 export { createDomNotifier } from "./defaults/notify.js";
 export { createWebPrefs, createHostKeptPrefs, CHAT_PREFS_PREFIX, type HostKeptPrefs } from "./defaults/prefs.js";
 export { createWindowNavigation } from "./defaults/navigation.js";
+export { createMemoryNavigation, type MemoryNavigationOptions, type MemoryNavigationPort, } from "./defaults/memory-navigation.js";
 export { createUnhostedWindows } from "./defaults/windows.js";
 export { CHAT_WINDOWS, CHAT_WINDOW_IDS, DEFAULT_WINDOW_INSTANCE_ID, isChatWindowId, type ChatWindowId, } from "./windows.js";
 export type { ChatWindowOpeners } from "./window-openers.js";
@@ -24,4 +25,5 @@ export { createClient, getClaimsUser, schedulerDb, supabase, type ChatClaimsUser
 export type { ChatDatabase } from "./db-types.js";
 export { ChatNoDatabaseError, NO_DATABASE_CODE_PREFIX, createNoDatabaseStandIn, isChatNoDatabaseError, isNoDatabase, } from "./no-database.js";
 export * from "./source.js";
+export * from "./conversation-hooks.js";
 export * from "../agents/routing/confidential-routing.js";

package/dist/host/index.js

@@ -29,6 +29,9 @@ import {
 import { createDomNotifier } from "./defaults/notify.js";
 import { createWebPrefs, createHostKeptPrefs, CHAT_PREFS_PREFIX } from "./defaults/prefs.js";
 import { createWindowNavigation } from "./defaults/navigation.js";
+import {
+  createMemoryNavigation
+} from "./defaults/memory-navigation.js";
 import { createUnhostedWindows } from "./defaults/windows.js";
 import {
   CHAT_WINDOWS,
@@ -55,6 +58,7 @@ import {
   isNoDatabase
 } from "./no-database.js";
 export * from "./source.js";
+export * from "./conversation-hooks.js";
 export * from "../agents/routing/confidential-routing.js";
 export {
   CHAT_ACTIVE_ORG_STORAGE_KEY,
@@ -88,6 +92,7 @@ export {
   createDomNotifier,
   createHostKeptPrefs,
   createLogClientErrorDiagnostics,
+  createMemoryNavigation,
   createNoDatabaseStandIn,
   createNoPickerOrg,
   createStoredOrg,

package/dist/host/react.d.ts

@@ -31,3 +31,4 @@ export declare function useMaybeChatHost(): ResolvedChatHost | null;
 /** The host from the nearest <ChatProvider>. Throws the named, remedied error outside one. */
 export declare function useChatHost(): ResolvedChatHost;
 export { Link, usePathname, useRouter, useSearchParams } from "./navigation.js";
+export { useConversationHeld } from "./conversation-hooks-react.js";

package/dist/host/react.js

@@ -65,10 +65,12 @@ function useChatHost() {
   return host;
 }
 import { Link, usePathname, useRouter, useSearchParams } from "./navigation.js";
+import { useConversationHeld } from "./conversation-hooks-react.js";
 export {
   ChatProvider,
   Link,
   useChatHost,
+  useConversationHeld,
   useMaybeChatHost,
   usePathname,
   useRouter,

package/dist/host/ui-slots.d.ts

@@ -1,4 +1,4 @@
-import { type ComponentType, type ChangeEvent, type ReactNode } from "react";
+import { Component, type ComponentType, type ChangeEvent, type ReactNode } from "react";
 import type { EditableContextMenuProps, NonEditableContextMenuProps } from "../context-menu/types.js";
 /** The host context menu's props (its registration is typed against them). */
 export type { EditableContextMenuProps, NonEditableContextMenuProps };
@@ -419,6 +419,28 @@ export interface ChatUiSlots {
 export declare function registerChatUi(next: Partial<ChatUiSlots>): void;
 /** Test seam: forget every registration. */
 export declare function resetChatUiForTests(): void;
+/** True when the host registered `name` (a door that only a host implementation can open shows only then). */
+export declare function isHostSlotRegistered(name: keyof ChatUiSlots): boolean;
+/**
+ * EVERY SLOT DEGRADES, NEVER CRASHES (P29a finding 1). A host panel that throws while rendering
+ * (a hook slot it needs is missing, its own bug) draws nothing in its place; the failure is
+ * reported once through the diagnostics port. The page around it keeps working.
+ */
+export declare class SlotBoundary extends Component<{
+    name: string;
+    children?: ReactNode;
+}, {
+    failed: boolean;
+}> {
+    state: {
+        failed: boolean;
+    };
+    static getDerivedStateFromError(): {
+        failed: boolean;
+    };
+    componentDidCatch(error: unknown): void;
+    render(): ReactNode;
+}
 /**
  * A named slot with the caller's own stand-in (for a package default richer than one line,
  * e.g. a context-item body falling back to `GenericBody`). Same contract as the wrappers above:
@@ -498,6 +520,7 @@ export declare const WindowPanel: AnyComponent;
 /** A bare host draws a plain full-screen tabbed sheet. */
 export declare const FullScreenOverlay: AnyComponent;
 export declare const ResourcePickerWindow: AnyComponent;
+/** A bare host gets the package's own Files + Link picker (`defaults/resource-picker-menu`); the app registers its full one. */
 export declare const ResourcePickerMenu: SlotComponent<ResourcePickerMenuProps>;
 export declare const FilesResourcePicker: SlotComponent<FilesPickerProps>;
 export declare const NotePickerPopover: SlotComponent<NotePickerProps>;
@@ -736,6 +759,7 @@ export declare const CreatorRunPanel: SlotComponent<{
     tabs?: string[];
 }>;
 export declare const AgentSettingsCore: AnyComponent;
+/** A bare host gets the package's own per-type setting control (`defaults/setting-control-input`). */
 export declare const SettingControlInput: AnyComponent;
 export declare const InputCapabilitiesEditor: AnyComponent;
 export declare const CustomDataBindingSummary: AnyComponent;