@ai-matrx/chat 0.4.10 → 0.4.14

package/dist/agents/redux/execution-system/utils/stream-block-accumulator.js

@@ -1,9 +1,9 @@
-import { parseDecisionOptionsFromBody } from "../../../../utils/inline-decision/decision-options.js";
-import { QuotedKindLift } from "../../../../utils/content-ir/surfaces/quoted-kind-lift.js";
-import { canonicalizeCompletedLegacyQuizEnvelope } from "../../../../utils/content-ir/legacy-quiz-envelope.js";
-import { envelopeMatchesParsedSource } from "../../../../utils/content-ir/envelope-parity.js";
-import { MarkdownEscapedKindJson } from "../../../../utils/content-ir/surfaces/markdown-escaped-kind.js";
-import { KindImageAltUnwrap } from "../../../../utils/content-ir/surfaces/kind-image-alt.js";
+import { parseDecisionOptionsFromBody } from "@ai-matrx/rich-content/utils/decision-options";
+import { QuotedKindLift } from "@ai-matrx/content-ir/surfaces";
+import { canonicalizeCompletedLegacyQuizEnvelope } from "@ai-matrx/content-ir/surfaces";
+import { envelopeMatchesParsedSource } from "@ai-matrx/content-ir/surfaces";
+import { MarkdownEscapedKindJson } from "@ai-matrx/content-ir/surfaces";
+import { KindImageAltUnwrap } from "@ai-matrx/content-ir/surfaces";
 import { FENCE_META_KEY, splitFenceInfo } from "@ai-matrx/content-ir/source";
 import {
   hasUnclosedBacktickRun,
@@ -16,7 +16,7 @@ import {
   kindGrammar,
   kindObjectProseBreak,
   bareRegionBreaksIntoProse
-} from "../../../../utils/content-ir/surfaces/json-kind-signal.js";
+} from "@ai-matrx/content-ir/surfaces";
 import {
   findBalancedXmlClose,
   initialXmlBalance
@@ -68,7 +68,7 @@ import {
 import {
   normalizeRecoveredContainerPiece,
   splitAroundEmbeddedKindJson
-} from "../../../../utils/content-ir/surfaces/embedded-kind-json.js";
+} from "@ai-matrx/content-ir/surfaces";
 import { captureError } from "../../../../host/diagnostics.js";
 const isSpecialCodeLanguage = (language) => SPECIAL_CODE_LANGUAGES.includes(language);
 const envelopeForCompletedXmlRegion = (tag, regionText) => hostSplitterEnvelopes()?.xmlRegion(tag, regionText) ?? null;

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

@@ -18,8 +18,9 @@
  * follower may retry for minutes across a deploy drain by design), and no
  * org header (org rides the conversation body only, like `runAiStream`).
  */
+import { type FollowServerJobOptions, type ServerJobOutcome } from "@ai-matrx/agents/matrx";
 import type { ResolvedBackend } from "../redux/execution-system/thunks/resolve-base-url.js";
-import type { RuntimeExecutionStatus, RuntimeOperationEvent, RuntimeOperationsByLinkResponse } from "./types.js";
+import type { RuntimeOperationsByLinkResponse } from "./types.js";
 /**
  * `GET /runtime/operations/by-link/conversation/{conversationId}` — the
  * identify step. Returns `null` when the surface is absent or the caller owns
@@ -27,29 +28,9 @@ import type { RuntimeExecutionStatus, RuntimeOperationEvent, RuntimeOperationsBy
  * shape by design); throws on other failures.
  */
 export declare function fetchOperationsByLink(backend: ResolvedBackend, conversationId: string, signal?: AbortSignal): Promise<RuntimeOperationsByLinkResponse | null>;
-export interface FollowOperationResult {
-    /** True when the server sent the terminal `end` frame. */
-    ended: boolean;
-    /** The root status carried on the `end` frame (when `ended`). */
-    status: RuntimeExecutionStatus | null;
-}
-export interface FollowOperationOptions {
-    backend: ResolvedBackend;
-    executionId: string;
-    /** Resume cursor — the operation view's `last_event_seq` (0 = from start). */
-    lastEventSeq: number;
-    /** Caller teardown — aborting resolves the promise with `ended: false`. */
-    signal: AbortSignal;
-    /** Fired per durable spine event (lifecycle transitions + notes). */
-    onEvent: (event: RuntimeOperationEvent, seq: number | null) => void;
-}
 /**
- * `GET /runtime/executions/{id}/events/stream` — SSE replay-then-follow with
- * bounded reconnects, via the package's `followRuntimeOperationToEnd`
- * (production defaults). Resolves `{ended: true, status}` on the server's
- * `end` frame (the operation settled); `{ended: false}` when the caller
- * aborted or every reconnect attempt failed. A WAITING_INPUT park keeps the
- * stream open by design — a resume re-attaches to the same execution and its
- * events continue arriving here on the same cursor.
+ * Identify → rejoin → follow → settle for one conversation, on the shared
+ * `followServerJob` core over this backend's channel. Chat supplies only its
+ * wiring (the Redux rejoin consumer, banner callbacks, `loadConversation`).
  */
-export declare function followOperationStream(opts: FollowOperationOptions): Promise<FollowOperationResult>;
+export declare function followConversationServerJob(backend: ResolvedBackend, conversationId: string, options: Omit<FollowServerJobOptions, "target">): Promise<ServerJobOutcome>;

package/dist/agents/runtime-reconnect/api.js

@@ -1,6 +1,6 @@
 import {
   createMatrxTransport,
-  followRuntimeOperationToEnd,
+  followServerJob,
   getRuntimeOperationsByLink
 } from "@ai-matrx/agents/matrx";
 function transportFor(backend) {
@@ -21,19 +21,13 @@ async function fetchOperationsByLink(backend, conversationId, signal) {
     { limit: 5, ...signal ? { signal } : {} }
   );
 }
-async function followOperationStream(opts) {
-  const result = await followRuntimeOperationToEnd(
-    transportFor(opts.backend),
-    opts.executionId,
-    {
-      lastEventSeq: opts.lastEventSeq,
-      signal: opts.signal,
-      onEvent: (event, seq) => opts.onEvent(event, seq)
-    }
-  );
-  return { ended: result.ended, status: result.status };
+function followConversationServerJob(backend, conversationId, options) {
+  return followServerJob(transportFor(backend), {
+    ...options,
+    target: { linkKind: "conversation", linkId: conversationId }
+  });
 }
 export {
   fetchOperationsByLink,
-  followOperationStream
+  followConversationServerJob
 };

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/canvasItemContext.js

@@ -1,4 +1,4 @@
-import { isMaterializedArtifactId } from "./artifactId.js";
+import { isMaterializedArtifactId } from "@ai-matrx/rich-content/utils/lifted/artifactId";
 const CANVAS_ITEM_SOURCE_KIND = "canvas_item";
 const DESCRIPTION = "A pinned conversation artifact (code or JSON). Read with ctx_get on this key (the artifact UUID). Apply every change with ctx_patch \u2014 edits save as a new version of the same artifact. Do NOT recreate it; extend or edit it.";
 function isCanvasItemContextKey(key) {