@ai-matrx/chat 0.4.12 → 0.4.14

package/dist/host/contract.d.ts

@@ -738,6 +738,34 @@ export interface ChatAppIdentity {
  * `"local-only"` (confidential) conversation refuses every target but the Matrx Local engine on this
  * computer, loudly, before a byte leaves the machine. Default: `"any"` for every conversation.
  */
+/** What a device-tool run answered (the same shape the browser-extension bridge answers). */
+export type ChatDeviceToolInvocation = {
+    handled: false;
+    reason: string;
+} | {
+    handled: true;
+    ok: true;
+    output: Record<string, unknown>;
+} | {
+    handled: true;
+    ok: false;
+    error: string;
+};
+/**
+ * Tools that run ON THIS DEVICE for a cloud agent (lanes/agents-chat-proposal.md W0(c)): the
+ * browser tools when the chat runs inside Matrx Extend, local machine tools in a desktop host. The
+ * package owns the whole loop around them — the delegated call's lifecycle, the durable result
+ * submit with retry, and the resume (`surfaceDelegatedToolCall` → `submitToolResult`); the host
+ * only executes. `handled: false` = "not a tool this device owns" (the model is told, never a
+ * wedge). Absent: delegated device tools go to the installed browser extension through the server
+ * port (`invokeMatrxExtendTool`), as on the web.
+ */
+export interface ChatDeviceToolsPort {
+    invoke(toolName: string, args: Record<string, unknown>, context: {
+        conversationId: string;
+        callId: string;
+    }): Promise<ChatDeviceToolInvocation>;
+}
 export interface ChatRoutingPort {
     policy(conversationId: string): ChatRoutingPolicy;
 }
@@ -767,7 +795,16 @@ export interface ChatHost {
      * that is not matrx-frontend never labels its rows as the main app's.
      */
     app?: ChatAppIdentity;
-    /** Default: from db.auth (getSession + onAuthStateChange); admin level from admin.admins. */
+    /**
+     * The token function a token-only client was built with (supabase-js `accessToken` option, the
+     * matrx-local custodian shape): pass the SAME function here and the default identity reads who is
+     * signed in from it. A token-only `db` without it is signed out, announced once with this remedy.
+     */
+    accessToken?: () => Promise<string | null>;
+    /**
+     * Default: from db.auth (getSession + onAuthStateChange); for a token-only `db`, from
+     * `accessToken`. Admin level from admin.admins either way.
+     */
     identity?: ChatIdentityPort;
     /** Default: no active org; `require` refuses loudly (never auto-picks). */
     org?: ChatOrgPort;
@@ -803,8 +840,10 @@ export interface ChatHost {
     canvas?: ChatCanvasPort;
     /** Default: every conversation may go to any target (`"any"`). */
     routing?: ChatRoutingPort;
+    /** Default: none — delegated device tools go to the browser extension via the server port. */
+    deviceTools?: ChatDeviceToolsPort;
 }
-export type ChatPortName = "identity" | "org" | "server" | "notify" | "diagnostics" | "prefs" | "navigation" | "windows" | "catalog" | "registry" | "chrome" | "feedback" | "routes" | "canvas" | "routing";
+export type ChatPortName = "identity" | "org" | "server" | "notify" | "diagnostics" | "prefs" | "navigation" | "windows" | "catalog" | "registry" | "chrome" | "feedback" | "routes" | "canvas" | "routing" | "deviceTools";
 /** Every port present. `overridden` names the ports the host supplied itself. */
 export interface ResolvedChatHost {
     /** The host's client, or the no-database stand-in when it gave only a `source`. */
@@ -831,5 +870,7 @@ export interface ResolvedChatHost {
     routes: ChatRoutes;
     canvas: ChatCanvasPort;
     routing: ChatRoutingPort;
+    /** The host's on-device tool executor, or null. */
+    deviceTools: ChatDeviceToolsPort | null;
     overridden: ReadonlySet<ChatPortName>;
 }

package/dist/host/db.js

@@ -3,6 +3,7 @@ import {
   AuthSessionMissingError
 } from "@supabase/supabase-js";
 import { getChatHost } from "./configure.js";
+import { decodeTokenClaims, isTokenOnlyClient } from "./defaults/identity.js";
 function createClient() {
   return getChatHost().db;
 }
@@ -35,6 +36,11 @@ function userFromClaims(claims) {
   };
 }
 async function getClaimsUser(client, jwt) {
+  if (isTokenOnlyClient(client)) {
+    const token = jwt ?? await getChatHost().identity.getAccessToken().catch(() => null);
+    const claims = token ? decodeTokenClaims(token) : null;
+    return { data: { user: userFromClaims(claims ?? void 0) }, error: null };
+  }
   const { data, error } = await client.auth.getClaims(jwt);
   if (error) {
     if (isSignedOutError(error)) return { data: { user: null }, error: null };

package/dist/host/defaults/diagnostics.d.ts

@@ -27,6 +27,11 @@ export interface LogClientErrorDiagnosticsOptions {
     /** Default: `process.env.NODE_ENV === "production"`. */
     persist?: boolean;
     flushDelayMs?: number;
+    /**
+     * Is someone signed in? The resolver passes the identity port's answer, so a token-only client
+     * works. Default (a db with an auth-js session): `db.auth.getSession()`.
+     */
+    signedIn?: () => Promise<boolean>;
 }
 export declare function isChatSourceApp(value: unknown): value is ChatSourceApp;
 export declare function createLogClientErrorDiagnostics(db: ChatDb, options: LogClientErrorDiagnosticsOptions): ChatDiagnosticsPort;

package/dist/host/defaults/diagnostics.js

@@ -59,8 +59,7 @@ function createLogClientErrorDiagnostics(db, options) {
     if (queue.length === 0) return;
     let signedIn = false;
     try {
-      const { data } = await db.auth.getSession();
-      signedIn = Boolean(data.session?.user);
+      signedIn = options.signedIn ? await options.signedIn() : Boolean((await db.auth.getSession()).data.session?.user);
     } catch {
       signedIn = false;
     }

package/dist/host/defaults/identity.d.ts

@@ -3,6 +3,32 @@
  * admin level from `admin.admins` (RLS: a person reads their own row). Starts
  * on first use, never at import, so SSR and tests that never ask pay nothing.
  */
+import type { User } from "@supabase/supabase-js";
 import type { ChatDb, ChatDiagnosticsPort, ChatIdentity, ChatIdentityPort } from "../contract.js";
 export declare const SIGNED_OUT_IDENTITY: ChatIdentity;
 export declare function createDbIdentity(db: ChatDb, diagnostics: () => ChatDiagnosticsPort): ChatIdentityPort;
+/**
+ * Is this a supabase-js client built with the `accessToken` option? Such a client has no auth-js
+ * session: touching `db.auth` throws by construction (matrx-local's custodian client is one). The
+ * probe reads the property inside a try, so it never throws itself.
+ */
+export declare function isTokenOnlyClient(db: unknown): boolean;
+/** A JWT's payload as an object (no verification — routing metadata only). */
+export declare function decodeTokenClaims(token: string): Record<string, unknown> | null;
+/**
+ * The person a token names, read from its claims — routing metadata, not verification (the
+ * server and RLS verify every call that token makes). `null` when the token names nobody.
+ */
+export declare function userFromAccessToken(token: string | null): User | null;
+/**
+ * Identity for a token-only client: the host hands the same `accessToken` function it gave
+ * supabase-js, and the package reads who is signed in from it. Every `getAccessToken()` re-reads
+ * the token, so a refresh or an account switch reaches the snapshot (and its subscribers) the next
+ * time anything asks; admin level is read through `db` exactly like the session default.
+ */
+export declare function createTokenIdentity(db: ChatDb, getToken: () => Promise<string | null>, diagnostics: () => ChatDiagnosticsPort): ChatIdentityPort;
+/**
+ * A token-only client with no `accessToken` function: nobody can be read. Signed out and settled
+ * (never a forever-loading screen), announced once with the remedy.
+ */
+export declare function createUnreadableTokenIdentity(announce: (message: string) => void): ChatIdentityPort;

package/dist/host/defaults/identity.js

@@ -113,7 +113,139 @@ function createDbIdentity(db, diagnostics) {
     }
   };
 }
+function isTokenOnlyClient(db) {
+  if (db === null || typeof db !== "object") return false;
+  try {
+    const auth = db.auth;
+    if (!auth) return true;
+    void auth.getSession;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function decodeTokenClaims(token) {
+  const payload = token.split(".")[1];
+  if (!payload) return null;
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    const parsed = JSON.parse(
+      typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("utf8")
+    );
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function userFromAccessToken(token) {
+  if (!token) return null;
+  const claims = decodeTokenClaims(token);
+  if (!claims || typeof claims.sub !== "string" || !claims.sub) return null;
+  const meta = claims.user_metadata;
+  const appMeta = claims.app_metadata;
+  return {
+    id: claims.sub,
+    email: typeof claims.email === "string" ? claims.email : void 0,
+    user_metadata: meta !== null && typeof meta === "object" ? meta : {},
+    app_metadata: appMeta !== null && typeof appMeta === "object" ? appMeta : {},
+    aud: typeof claims.aud === "string" ? claims.aud : "authenticated",
+    created_at: ""
+  };
+}
+function createTokenIdentity(db, getToken, diagnostics) {
+  let snapshot = SIGNED_OUT_IDENTITY;
+  let started = false;
+  let adminFor = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function publish(next) {
+    if (snapshot.userId === next.userId && snapshot.accessToken === next.accessToken && snapshot.adminLevel === next.adminLevel && snapshot.authReady === next.authReady) {
+      return;
+    }
+    snapshot = next;
+    for (const listener of listeners) listener();
+  }
+  async function readAdminLevel(userId) {
+    try {
+      const { data, error } = await db.schema("admin").from("admins").select("level").eq("user_id", userId).maybeSingle();
+      if (error) throw error;
+      const level = data?.level;
+      return ADMIN_LEVELS.includes(level) ? level : null;
+    } catch (error) {
+      diagnostics().capture(error, { area: "identity", code: "admin-level-unreadable" });
+      return null;
+    }
+  }
+  async function refresh() {
+    let token;
+    try {
+      token = await getToken();
+    } catch (error) {
+      diagnostics().capture(error, { area: "identity", code: "access-token-unreadable" });
+      token = null;
+    }
+    const user = userFromAccessToken(token);
+    const level = user && user.id === snapshot.userId ? snapshot.adminLevel : null;
+    publish(identityFromUser(user, level, user ? token : null));
+    if (user && adminFor !== user.id) {
+      adminFor = user.id;
+      const read = await readAdminLevel(user.id);
+      if (snapshot.userId === user.id) publish(identityFromUser(user, read, snapshot.accessToken));
+    }
+    return user ? token : null;
+  }
+  function start() {
+    if (started) return;
+    started = true;
+    void refresh();
+  }
+  return {
+    current() {
+      start();
+      return snapshot;
+    },
+    subscribe(listener) {
+      start();
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getAccessToken: refresh
+  };
+}
+function createUnreadableTokenIdentity(announce) {
+  const value = Object.freeze({ ...SIGNED_OUT_IDENTITY, authReady: true });
+  let said = false;
+  const say = () => {
+    if (said) return;
+    said = true;
+    announce(
+      "This chat's database client was built with an access-token function, so the chat cannot read who is signed in. Pass the same function to the chat host as `accessToken`."
+    );
+  };
+  return {
+    current() {
+      say();
+      return value;
+    },
+    subscribe() {
+      say();
+      return () => {
+      };
+    },
+    async getAccessToken() {
+      say();
+      return null;
+    }
+  };
+}
 export {
   SIGNED_OUT_IDENTITY,
-  createDbIdentity
+  createDbIdentity,
+  createTokenIdentity,
+  createUnreadableTokenIdentity,
+  decodeTokenClaims,
+  isTokenOnlyClient,
+  userFromAccessToken
 };

package/dist/host/identity.d.ts

@@ -50,8 +50,25 @@ export declare function isNotAuthenticatedError(error: unknown): error is NotAut
 /** The signed-in person's id; throws `NotAuthenticatedError` when nobody is. */
 export declare function requireUserId(): string;
 /**
- * Does this client carry a signed-in session? A local read of the host's
- * `db.auth` (no network). For skipping reads only a signed-in person can make;
+ * The signed-in person's access token, or null — THE one session read in the package. It goes
+ * through the host's identity port, so a session client (auth-js) and a token-only client
+ * (`ChatHost.accessToken`) answer the same way; nothing else in the package touches `db.auth`
+ * (guard: `host/__tests__/session-reads-go-through-the-identity-port.test.ts`).
+ */
+export declare function readSessionToken(): Promise<string | null>;
+/** `readSessionToken` in the structural shape `@ai-matrx/data`'s session retry reads. */
+export declare const hostSessionSource: {
+    getSession(): Promise<{
+        data: {
+            session: {
+                access_token: string;
+            } | null;
+        };
+        error: null;
+    }>;
+};
+/**
+ * Does this client carry a signed-in session? For skipping reads only a signed-in person can make;
  * "no session" means an empty result, never a way around a reader a guest needs.
  */
 export declare function hasBrowserSession(): Promise<boolean>;

package/dist/host/identity.js

@@ -40,11 +40,11 @@ function requireUserId() {
   if (!id) throw new NotAuthenticatedError();
   return id;
 }
-async function hasBrowserSession() {
-  if (!chatHostHasDatabase()) return false;
-  let db;
+async function readSessionToken() {
+  if (!chatHostHasDatabase()) return null;
+  let host;
   try {
-    db = getChatHost().db;
+    host = getChatHost();
   } catch (error) {
     announceOnce(
       "identity:no-host-session",
@@ -52,16 +52,22 @@ async function hasBrowserSession() {
         error?.message ?? error
       )}).`
     );
-    return false;
+    return null;
   }
   try {
-    const {
-      data: { session }
-    } = await db.auth.getSession();
-    return Boolean(session);
+    return await host.identity.getAccessToken();
   } catch {
-    return false;
+    return null;
+  }
+}
+const hostSessionSource = {
+  async getSession() {
+    const token = await readSessionToken();
+    return { data: { session: token ? { access_token: token } : null }, error: null };
   }
+};
+async function hasBrowserSession() {
+  return await readSessionToken() !== null;
 }
 async function isSignedOutVisitor() {
   return !getUserId() && !await hasBrowserSession();
@@ -70,8 +76,10 @@ export {
   NotAuthenticatedError,
   getUserId,
   hasBrowserSession,
+  hostSessionSource,
   isNotAuthenticatedError,
   isSignedOutVisitor,
+  readSessionToken,
   requireUserId,
   selectAccessToken,
   selectActiveUserName,

package/dist/host/session-retry.js

@@ -1,11 +1,11 @@
 import { createSessionRetry } from "@ai-matrx/data/db";
-import { supabase } from "./db.js";
+import { hostSessionSource } from "./identity.js";
 import {
   isMissingSessionError,
   SessionUnavailableError
 } from "@ai-matrx/data/db";
 const runWithSessionRetry = createSessionRetry({
-  auth: { getSession: () => supabase.auth.getSession() }
+  auth: hostSessionSource
 });
 export {
   SessionUnavailableError,

package/dist/surfaces/services/bind-agent-to-surface.service.js

@@ -16,6 +16,7 @@ import { ensureOrgAvailability } from "../../host/ui-slots.js";
 import { assertMappingsAreAnswerable } from "../../ui/mandates-storage/provision-shapes.js";
 import { ensureOrgId } from "../../host/org.js";
 import { readProjectScopeOrganizationId } from "../../host/ui-slots.js";
+import { hasBrowserSession } from "../../host/identity.js";
 function tierFromScope(scope) {
   if (scope.userId) return "user";
   if (scope.organizationId) return "org";
@@ -359,10 +360,7 @@ async function listAgentSurfaceBindings(agentId) {
 async function fetchSurfaceBindingLayers(agentId, surfaceName) {
   const chain = [...getSurfaceAncestry(surfaceName), surfaceName];
   const sb = createClient();
-  const {
-    data: { session }
-  } = await sb.auth.getSession();
-  if (!session) return [];
+  if (!await hasBrowserSession()) return [];
   const { data, error } = await sb.schema("agent").from("menu_surface").select(MENU_SURFACE_COLUMNS).eq("agent_id", agentId).in("surface_name", chain);
   if (error) throw error;
   const rows = (data ?? []).map(fromRow).filter(

package/dist/tool-call-visualization/renderers/agent-call/CollabCallCard.js

@@ -9,7 +9,7 @@ import { useConversationTitle } from "../../../agents/hooks/useConversationTitle
 import { EntityRef } from "../../../host/ui-slots.js";
 import MarkdownStream from "../../../ui/markdown-stream/MarkdownStream.js";
 import { AnswerValueView } from "../../../host/ui-slots.js";
-import { stripThinkingStreaming } from "@ai-matrx/kit/text";
+import { stripThinkingStreaming } from "@ai-matrx/content-ir/source";
 import { cn } from "@ai-matrx/design-system";
 import { getCollabCallInfo } from "./collab.js";
 import { ErrorAlchemyMenu } from "../../../host/ui-slots.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/chat",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "THE one AI Matrx person-to-agent chat system: the full chat (running agents, conversations, tool calls, streaming, context, surfaces, voice) as per-module subpaths @ai-matrx/chat/<domain>/<module> over a host contract (/host, /host/react) whose only required value is a db; plus the kernel compatibility entries (., /external-store, /matrx, /react, /tools, styles.css, tokens.css) until P28.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -230,8 +230,8 @@
     "@ai-matrx/alchemy": "latest",
     "@ai-matrx/associations": "latest",
     "@ai-matrx/browser-audio": "latest",
-    "@ai-matrx/content-ir": "latest",
     "@ai-matrx/canvas": "latest",
+    "@ai-matrx/content-ir": "latest",
     "@ai-matrx/data": "latest",
     "@ai-matrx/content-ir-react": "latest",
     "@ai-matrx/design-system": "latest",
@@ -240,12 +240,12 @@
     "@ai-matrx/kit": "latest",
     "@ai-matrx/media": "latest",
     "@ai-matrx/realtime": "latest",
+    "@ai-matrx/records": "latest",
     "@ai-matrx/records-ui": "latest",
-    "@ai-matrx/rich-content": "latest",
-    "@ai-matrx/print": "latest",
     "@ai-matrx/rich-editor": "latest",
+    "@ai-matrx/rich-content": "latest",
     "@ai-matrx/tap-target": "latest",
-    "@ai-matrx/records": "latest"
+    "@ai-matrx/print": "latest"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
@@ -342,6 +342,7 @@
     "check:front-door": "node ./scripts/check-front-door.mjs",
     "check:front-door:self-test": "node ./scripts/check-front-door.mjs --self-test",
     "check:front-door:canary": "node ./scripts/check-front-door.mjs --root ./canary/src",
-    "deps:write": "node ./scripts/finish-build.mjs --write-deps"
+    "deps:write": "node ./scripts/finish-build.mjs --write-deps",
+    "check:side-panel-bundle": "node ./scripts/check-side-panel-bundle.mjs"
   }
 }