@ai-matrx/chat 0.4.12 → 0.4.14

package/dist/agents/runtime-reconnect/reconnect-server-operation.thunk.js

@@ -2,9 +2,7 @@ import { retryReconnect } from "./retry-reconnect.js";
 import { discardRetainedTransportConsumer } from "../redux/execution-system/thunks/process-stream.js";
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import {
-  pickServerJobOperation,
-  runtimeOperationRejoinPath,
-  settleRunPickup
+  runtimeOperationRejoinPath
 } from "@ai-matrx/agents/matrx";
 import { toast } from "../../host/notify.js";
 import { captureError } from "../../host/diagnostics.js";
@@ -26,7 +24,7 @@ import { resolveBackendForConversation } from "../redux/execution-system/thunks/
 import { surfaceColdPendingCalls } from "../redux/execution-system/thunks/surface-cold-pending-calls.thunk.js";
 import { resumeInstance } from "../redux/execution-system/thunks/resume-instance.thunk.js";
 import { selectActivePendingAsksForConversation } from "../ui-first-tools/redux/pending-asks.slice.js";
-import { fetchOperationsByLink, followOperationStream } from "./api.js";
+import { followConversationServerJob } from "./api.js";
 import { decideAfterContinueRefused, decideWaitingInputRecovery } from "./waiting-input-recovery.js";
 import { countOpenAsksForConversation } from "./parked-on-person.js";
 const RUNNING_KINDS = /* @__PURE__ */ new Set(["started", "resumed"]);
@@ -69,56 +67,25 @@ const reconnectServerOperation = createAsyncThunk(
         followers.delete(conversationId);
     };
     let op = null;
-    let settledWhileDisconnected = false;
-    try {
-      const byLink = await retryReconnect(
-        () => fetchOperationsByLink(backend, conversationId, ctrl.signal),
-        // org-filter: server-call the conversation's own organization rides the backend headers; the read is by conversation id
-        ctrl.signal,
-        stillOwner
-      );
-      if (!stillOwner()) {
-        clearFollower();
-        return noFollow;
-      }
-      const picked = pickServerJobOperation(byLink?.operations);
-      op = picked && !picked.is_terminal ? picked : null;
-      settledWhileDisconnected = Boolean(picked?.is_terminal);
-    } catch (err) {
-      const superseded = ctrl.signal.aborted || !stillOwner();
-      clearFollower();
-      if (superseded) return noFollow;
-      console.warn(
-        "[runtime-reconnect] operations-by-link fetch failed \u2014 falling back to legacy recovery.",
-        { conversationId, err }
-      );
-      if (source === "stream-loss") fallbackToLegacyRecovery();
-      return noFollow;
-    }
-    if (!op) {
-      clearFollower();
-      if (source === "stream-loss") fallbackToLegacyRecovery();
-      else if (settledWhileDisconnected)
-        await dispatch(loadConversation({ conversationId })).unwrap();
-      return noFollow;
-    }
-    console.warn(
-      "[runtime-reconnect] non-terminal server operation found \u2014 following its event stream.",
-      {
-        conversationId,
-        executionId: op.execution_id,
-        status: op.status,
-        source
-      }
-    );
+    const liveOp = () => {
+      if (!op) throw new Error("reconnect: no server operation identified yet");
+      return op;
+    };
+    let identified = false;
+    let superseded = false;
+    let sawLive = false;
+    let rejoinRan = false;
+    let standDown = false;
+    let waitingRecoveryInFlight = false;
     const stampOperation = (status, waitingInput, recoveryState) => {
+      const current = liveOp();
       const serverOperation = {
-        executionId: op.execution_id,
-        userRequestId: op.request_id,
+        executionId: current.execution_id,
+        userRequestId: current.request_id,
         status,
         waitingInput,
         ...recoveryState ? { recoveryState } : {},
-        startedAt: op.started_at,
+        startedAt: current.started_at,
         checkedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       dispatch(patchConversation({ conversationId, serverOperation }));
@@ -131,10 +98,10 @@ const reconnectServerOperation = createAsyncThunk(
       }
       dispatch(setInstanceStatus({ conversationId, status: "paused" }));
     };
-    let waitingRecoveryInFlight = false;
     const recoverWaitingInput = async () => {
       if (waitingRecoveryInFlight) return;
       waitingRecoveryInFlight = true;
+      const waiting = liveOp();
       stampOperation("waiting_input", true, "checking_for_prompt");
       try {
         const surfaced = await dispatch(
@@ -148,7 +115,7 @@ const reconnectServerOperation = createAsyncThunk(
           } catch (err) {
             console.error(
               "[runtime-reconnect] could not read the person's open asks; not resuming a turn that may be waiting on one.",
-              { conversationId, executionId: op.execution_id, err }
+              { conversationId, executionId: waiting.execution_id, err }
             );
             stampOperation("waiting_input", true, "checking_for_prompt");
             return;
@@ -158,7 +125,7 @@ const reconnectServerOperation = createAsyncThunk(
           pendingCallCount: surfaced,
           pendingAskCount: asks.length,
           parkedOnPersonCount,
-          userRequestId: op.request_id
+          userRequestId: waiting.request_id
         });
         if (decision === "prompt_visible") {
           stampOperation("waiting_input", true, "prompt_visible");
@@ -175,12 +142,12 @@ const reconnectServerOperation = createAsyncThunk(
         if (decision === "needs_action") {
           console.error(
             "[runtime-reconnect] waiting operation has no pending prompt and no request_id; user action is required.",
-            { conversationId, executionId: op.execution_id }
+            { conversationId, executionId: waiting.execution_id }
           );
           stampOperation("waiting_input", true, "needs_action");
           return;
         }
-        const userRequestId = op.request_id;
+        const userRequestId = waiting.request_id;
         if (!userRequestId) {
           stampOperation("waiting_input", true, "needs_action");
           return;
@@ -189,7 +156,7 @@ const reconnectServerOperation = createAsyncThunk(
           "[runtime-reconnect] waiting operation has zero pending calls \u2014 continuing the resolved request.",
           {
             conversationId,
-            executionId: op.execution_id,
+            executionId: waiting.execution_id,
             userRequestId
           }
         );
@@ -202,7 +169,7 @@ const reconnectServerOperation = createAsyncThunk(
         ).then((action) => {
           if (!resumeInstance.rejected.match(action)) return;
           const current = getState().conversations.byConversationId[conversationId]?.serverOperation;
-          if (current?.executionId !== op.execution_id) return;
+          if (current?.executionId !== waiting.execution_id) return;
           const next = decideAfterContinueRefused({
             originalErrorName: action.meta.originalErrorName,
             liveStream: hasAbortController(conversationId)
@@ -216,25 +183,24 @@ const reconnectServerOperation = createAsyncThunk(
       } catch (err) {
         console.error(
           "[runtime-reconnect] pending-call recovery check failed; preserving an explicit retry affordance.",
-          { conversationId, executionId: op.execution_id, err }
+          { conversationId, executionId: waiting.execution_id, err }
         );
         stampOperation("waiting_input", true, "needs_action");
       } finally {
         waitingRecoveryInFlight = false;
       }
     };
-    stampOperation(
-      op.status,
-      op.waiting_input,
-      op.waiting_input ? "checking_for_prompt" : void 0
-    );
-    if (!op.waiting_input && op.request_id) {
+    const consumeRejoin = async ({
+      operation,
+      requestId: rejoinId
+    }) => {
+      rejoinRan = true;
       const activeRequests = getState().activeRequests.byRequestId;
       const hintedRequest = requestId ? activeRequests[requestId] : void 0;
       const matchingRequest = Object.values(activeRequests).find(
-        (candidate) => candidate.conversationId === conversationId && (candidate.requestId === op.request_id || candidate.serverRequestId === op.request_id)
+        (candidate) => candidate.conversationId === conversationId && (candidate.requestId === rejoinId || candidate.serverRequestId === rejoinId || candidate.requestId === operation.request_id || candidate.serverRequestId === operation.request_id)
       );
-      const localRequestId = hintedRequest?.conversationId === conversationId ? hintedRequest.requestId : matchingRequest?.requestId ?? op.request_id;
+      const localRequestId = hintedRequest?.conversationId === conversationId ? hintedRequest.requestId : matchingRequest?.requestId ?? rejoinId;
       dispatch(createRequest({ requestId: localRequestId, conversationId }));
       dispatch(
         setRequestStatus({ requestId: localRequestId, status: "connecting" })
@@ -243,7 +209,7 @@ const reconnectServerOperation = createAsyncThunk(
         await runAiStream({
           requestId: localRequestId,
           conversationId,
-          url: `${backend.baseUrl}${runtimeOperationRejoinPath(op.request_id)}`,
+          url: `${backend.baseUrl}${runtimeOperationRejoinPath(rejoinId)}`,
           headers: backend.headers,
           body: {},
           channel: backend.channel,
@@ -258,117 +224,159 @@ const reconnectServerOperation = createAsyncThunk(
             );
           }
         });
-        const refreshed = await retryReconnect(
-          () => fetchOperationsByLink(backend, conversationId, ctrl.signal),
-          // org-filter: server-call the conversation's own organization rides the backend headers; the read is by conversation id
-          ctrl.signal,
-          stillOwner
-        );
-        if (!stillOwner()) {
-          clearFollower();
-          return noFollow;
-        }
-        const latest = pickServerJobOperation(refreshed?.operations);
-        const stillLive = latest && !latest.is_terminal ? latest : null;
-        if (stillLive) {
-          if (followers.get(conversationId) === ctrl) {
-            followers.delete(conversationId);
+      } catch (error) {
+        if (error instanceof StreamRejoinUnavailableError) throw error;
+        standDown = true;
+        return "stand-down";
+      }
+    };
+    let outcome;
+    try {
+      outcome = await followConversationServerJob(backend, conversationId, {
+        signal: ctrl.signal,
+        // org-filter: server-call the conversation's own organization rides the backend headers; the read is by conversation id
+        retry: (attempt) => retryReconnect(attempt, ctrl.signal, stillOwner),
+        onStatus: (status, operation) => {
+          if (status === "connecting") return;
+          if (!identified) {
+            identified = true;
+            if (!stillOwner()) {
+              superseded = true;
+              ctrl.abort();
+              return;
+            }
           }
+          if (!operation) return;
+          op = operation;
+          if (!sawLive && !operation.is_terminal) {
+            sawLive = true;
+            console.warn(
+              "[runtime-reconnect] non-terminal server operation found \u2014 following its event stream.",
+              {
+                conversationId,
+                executionId: operation.execution_id,
+                status: operation.status,
+                source
+              }
+            );
+            stampOperation(
+              operation.status,
+              operation.waiting_input,
+              operation.waiting_input ? "checking_for_prompt" : void 0
+            );
+            if (operation.waiting_input) void recoverWaitingInput();
+          }
+        },
+        rejoinConsumer: consumeRejoin,
+        onRejoinUnavailable: () => {
+          const current = liveOp();
+          console.warn(
+            "[runtime-reconnect] live response replay unavailable \u2014 following durable lifecycle instead.",
+            { conversationId, executionId: current.execution_id }
+          );
+          captureError({
+            source: "agent-stream-warning",
+            code: "live_replay_unavailable",
+            message: "A running response could not replay its live NDJSON; following durable lifecycle until the saved result is available.",
+            requestId: current.request_id ?? void 0,
+            conversationId,
+            raw: { executionId: current.execution_id, source }
+          });
+          stampOperation(current.status, false, "live_replay_unavailable");
+        },
+        afterRejoin: () => {
+          if (!stillOwner()) {
+            superseded = true;
+            return "handoff";
+          }
+          clearFollower();
           void dispatch(
             reconnectServerOperation({ conversationId, source: "cold-load" })
           );
-          return { followed: true, finalStatus: null };
-        }
-        await dispatch(loadConversation({ conversationId })).unwrap();
-        if (followers.get(conversationId) === ctrl) {
-          followers.delete(conversationId);
-        }
-        dispatch(patchConversation({ conversationId, serverOperation: null }));
-        return { followed: true, finalStatus: "completed" };
-      } catch (error) {
-        if (!(error instanceof StreamRejoinUnavailableError)) {
-          if (followers.get(conversationId) === ctrl) {
-            followers.delete(conversationId);
+          return "handoff";
+        },
+        onOperationEvent: (event) => {
+          if (hasAbortController(conversationId)) {
+            ctrl.abort();
+            return;
+          }
+          if (event.kind === "waiting_input") {
+            void recoverWaitingInput();
+          } else if (RUNNING_KINDS.has(event.kind)) {
+            stampOperation("running", false);
+          } else if (event.kind === "paused") {
+            stampOperation("paused", false);
           }
-          return noFollow;
+        },
+        reloadSavedResult: async ({ status }) => {
+          if (status === "none") return;
+          if (rejoinRan && !stillOwner()) {
+            superseded = true;
+            return;
+          }
+          if (!sawLive && source === "stream-loss") {
+            fallbackToLegacyRecovery();
+            return;
+          }
+          await dispatch(loadConversation({ conversationId })).unwrap();
         }
-        console.warn(
-          "[runtime-reconnect] live response replay unavailable \u2014 following durable lifecycle instead.",
-          { conversationId, executionId: op.execution_id }
-        );
-        captureError({
-          source: "agent-stream-warning",
-          code: "live_replay_unavailable",
-          message: "A running response could not replay its live NDJSON; following durable lifecycle until the saved result is available.",
-          requestId: op.request_id ?? void 0,
-          conversationId,
-          raw: { executionId: op.execution_id, source }
-        });
-        stampOperation(op.status, false, "live_replay_unavailable");
-      }
+      });
+    } catch (err) {
+      const stale = ctrl.signal.aborted || !stillOwner();
+      clearFollower();
+      if (stale) return noFollow;
+      console.warn(
+        "[runtime-reconnect] operations-by-link fetch failed \u2014 falling back to legacy recovery.",
+        { conversationId, err }
+      );
+      if (source === "stream-loss") fallbackToLegacyRecovery();
+      return noFollow;
     }
-    if (op.waiting_input) {
-      void recoverWaitingInput();
+    if (superseded) {
+      clearFollower();
+      return noFollow;
     }
-    const result = await followOperationStream({
-      backend,
-      executionId: op.execution_id,
-      lastEventSeq: op.last_event_seq,
-      signal: ctrl.signal,
-      onEvent: (event) => {
-        if (hasAbortController(conversationId)) {
-          ctrl.abort();
-          return;
-        }
-        if (event.kind === "waiting_input") {
-          void recoverWaitingInput();
-        } else if (RUNNING_KINDS.has(event.kind)) {
-          stampOperation("running", false);
-        } else if (event.kind === "paused") {
-          stampOperation("paused", false);
-        }
-      }
-    });
-    if (followers.get(conversationId) === ctrl) {
-      followers.delete(conversationId);
+    if (standDown) {
+      clearFollower();
+      return noFollow;
+    }
+    if (outcome.path === "rejoin" && !outcome.settled && !outcome.aborted) {
+      clearFollower();
+      return { followed: true, finalStatus: null };
+    }
+    clearFollower();
+    if (outcome.status === "none") {
+      if (source === "stream-loss") fallbackToLegacyRecovery();
+      return noFollow;
+    }
+    if (outcome.path === "already_settled" && !sawLive) {
+      if (outcome.reloadError !== void 0) throw outcome.reloadError;
+      return noFollow;
     }
-    if (ctrl.signal.aborted) {
+    if (outcome.aborted) {
       if (followers.has(conversationId)) return noFollow;
       dispatch(patchConversation({ conversationId, serverOperation: null }));
       return noFollow;
     }
-    const settlement = await settleRunPickup(
-      {
-        kind: "followed",
-        executionId: op.execution_id,
-        ended: result.ended,
-        status: result.status
-      },
-      {
-        reloadSavedTurn: async () => {
-          await dispatch(loadConversation({ conversationId })).unwrap();
-        },
-        onStillRunning: () => {
-          console.warn(
-            "[runtime-reconnect] event stream unavailable after retries \u2014 falling back to legacy recovery.",
-            { conversationId, executionId: op.execution_id }
-          );
-          dispatch(patchConversation({ conversationId, serverOperation: null }));
-          fallbackToLegacyRecovery();
-        }
-      }
-    );
-    if (settlement.state !== "settled") return noFollow;
-    if (!settlement.reloaded) {
+    if (!outcome.settled) {
+      console.warn(
+        "[runtime-reconnect] event stream unavailable after retries \u2014 falling back to legacy recovery.",
+        { conversationId, executionId: outcome.executionId }
+      );
+      dispatch(patchConversation({ conversationId, serverOperation: null }));
+      fallbackToLegacyRecovery();
+      return noFollow;
+    }
+    if (!outcome.reloaded) {
       console.warn(
         "[runtime-reconnect] operation settled but the conversation refetch failed.",
-        { conversationId, err: settlement.error }
+        { conversationId, err: outcome.reloadError }
       );
       dispatch(patchConversation({ conversationId, serverOperation: null }));
-      return { followed: true, finalStatus: result.status };
+      return { followed: true, finalStatus: outcome.status };
     }
     dispatch(patchConversation({ conversationId, serverOperation: null }));
-    const finalStatus = settlement.status;
+    const finalStatus = outcome.status;
     if (finalStatus === "completed") {
       const rid = requestId ?? selectLatestRequestId(conversationId)(getState());
       if (rid)
@@ -386,7 +394,7 @@ const reconnectServerOperation = createAsyncThunk(
     }
     console.warn("[runtime-reconnect] server operation settled \u2014 rehydrated.", {
       conversationId,
-      executionId: op.execution_id,
+      executionId: outcome.executionId,
       finalStatus
     });
     return { followed: true, finalStatus };

package/dist/agents/runtime-reconnect/types.d.ts

@@ -20,6 +20,8 @@ export interface RuntimeOperationView {
     execution_id: string;
     /** Durable runtime/chat request identity used by the resume endpoint. */
     request_id: string | null;
+    /** Newer by-link shape: the root run to rejoin by (preferred over `request_id`). */
+    root_request_id?: string | null;
     type: string;
     status: RuntimeExecutionStatus;
     is_terminal: boolean;

package/dist/agents/services/mcp-connections.service.d.ts

@@ -1,3 +1,15 @@
+/**
+ * MCP connections client — aidream `/api/mcp-connections/*`.
+ *
+ * Phase 4 of the Unified Credential Vault cutover: MCP tokens/credentials
+ * live ONLY in vault items on the server. The browser never sees a token —
+ * discovery, invocation, refresh, credential persistence, and disconnect all
+ * run in aidream with vault-resolved auth. The connection row
+ * (tool.mcp_user_conn) is non-secret metadata the FE may read directly.
+ *
+ * (Replaces the deleted Next.js /api/mcp/servers/[serverId]/* routes and the
+ * deleted mcp-client/token-refresh.ts.)
+ */
 import type { McpToolSchema } from "./mcp-client/tool-discovery.js";
 import type { components } from "@ai-matrx/agents/generated/api-types";
 import type { AttachableAvailability } from "../connectors/attachable-resources.js";

package/dist/agents/services/mcp-connections.service.js

@@ -1,4 +1,3 @@
-import { createClient } from "../../host/db.js";
 import { productionUrl } from "../../host/server/endpoints.js";
 import {
   buildMatrxRequestUrl,
@@ -7,22 +6,20 @@ import {
 } from "@ai-matrx/agents/matrx";
 import { applyOrganizationContextHeader } from "../../host/server/organization-context.js";
 import { ensureOrganizationForRequest } from "../../host/org.js";
+import { readSessionToken } from "../../host/identity.js";
 function backendBase() {
   return productionUrl();
 }
 async function authHeaders(method, explicitOrganizationId) {
-  const supabase = createClient();
-  const {
-    data: { session }
-  } = await supabase.auth.getSession();
-  if (!session?.access_token) throw new Error("Not signed in");
+  const accessToken = await readSessionToken();
+  if (!accessToken) throw new Error("Not signed in");
   const organizationId = await ensureOrganizationForRequest({
     method,
     organizationId: explicitOrganizationId
   });
   return applyOrganizationContextHeader(
     {
-      Authorization: `Bearer ${session.access_token}`,
+      Authorization: `Bearer ${accessToken}`,
       "Content-Type": "application/json"
     },
     organizationId

package/dist/agents/types/request.types.d.ts

@@ -137,6 +137,12 @@ export interface ActiveRequest {
      * Absent only for older servers that did not stamp a segment id.
      */
     transportStreamId?: string | null;
+    /**
+     * High-water `stream_seq` per emitter segment seen so far. A rejoin replays
+     * every segment from frame one; this is what drops segment A again after the
+     * page live-followed A then B.
+     */
+    transportSeqByStream?: Record<string, number>;
     /**
      * User-applied override for the rendered text. When non-null, this
      * supersedes the server-derived text built from `renderBlocks` for the

package/dist/agents/utils/json-extraction.js

@@ -1,7 +1,7 @@
 import {
   extractFirstJson
-} from "@ai-matrx/kit/json-extract";
-import { findAllFencedBlocks } from "@ai-matrx/kit/json-extract";
+} from "@ai-matrx/content-ir/json-extract";
+import { findAllFencedBlocks } from "@ai-matrx/content-ir/json-extract";
 function extractJsonFromText(text) {
   if (!text || typeof text !== "string") {
     return { success: false, error: "No text provided", rawText: text || "" };

package/dist/host/configure.js

@@ -7,7 +7,12 @@ import {
   createLogClientErrorDiagnostics,
   isChatSourceApp
 } from "./defaults/diagnostics.js";
-import { createDbIdentity } from "./defaults/identity.js";
+import {
+  createDbIdentity,
+  createTokenIdentity,
+  createUnreadableTokenIdentity,
+  isTokenOnlyClient
+} from "./defaults/identity.js";
 import { createStoredOrg } from "./defaults/org.js";
 import { createDefaultServer } from "./defaults/server.js";
 import { createDefaultServerApi } from "./defaults/server-api.js";
@@ -45,7 +50,8 @@ const PORTS = [
   "feedback",
   "routes",
   "canvas",
-  "routing"
+  "routing",
+  "deviceTools"
 ];
 const ANY_ROUTING = Object.freeze({ policy: () => "any" });
 const EMPTY_REGISTRATIONS = Object.freeze({});
@@ -55,7 +61,7 @@ function assertDb(host) {
     if (host?.source) return;
     throw new ChatHostInvalidError("`db` is missing (pass `db`, or a message `source`)");
   }
-  if (typeof db.rpc !== "function" || typeof db.from !== "function" || !db.auth) {
+  if (typeof db.rpc !== "function" || typeof db.from !== "function" || !isTokenOnlyClient(db) && !db.auth) {
     throw new ChatHostInvalidError(
       "`db` is not a Supabase client (no auth/rpc/from)"
     );
@@ -82,9 +88,12 @@ function resolveChatHost(host) {
     PORTS.filter((name) => host[name] !== void 0)
   );
   const ref = {};
-  const diagnostics = host.diagnostics ?? (hasDatabase ? createLogClientErrorDiagnostics(db, { sourceApp: host.sourceApp }) : createConsoleDiagnostics());
+  const diagnostics = host.diagnostics ?? (hasDatabase ? createLogClientErrorDiagnostics(db, {
+    sourceApp: host.sourceApp,
+    signedIn: async () => await ref.identity.getAccessToken() !== null
+  }) : createConsoleDiagnostics());
   const notify = host.notify ?? createDomNotifier();
-  const identity = host.identity ?? (hasDatabase ? createDbIdentity(db, () => ref.diagnostics) : SOURCE_ONLY_IDENTITY);
+  const identity = host.identity ?? (!hasDatabase ? SOURCE_ONLY_IDENTITY : host.accessToken ? createTokenIdentity(db, host.accessToken, () => ref.diagnostics) : isTokenOnlyClient(db) ? createUnreadableTokenIdentity((message) => announceOnce("identity:token-only-no-function", message)) : createDbIdentity(db, () => ref.diagnostics));
   const org = host.org ?? createStoredOrg(
     () => ref.notify,
     () => ref.diagnostics
@@ -130,6 +139,7 @@ function resolveChatHost(host) {
     routes: { ...DEFAULT_CHAT_ROUTES, ...host.routes },
     canvas: host.canvas ?? createUnhostedCanvas(() => ref.diagnostics),
     routing: host.routing ?? ANY_ROUTING,
+    deviceTools: host.deviceTools ?? null,
     overridden
   });
   return ref;