@ai-matrx/agents 0.24.2 → 0.25.1

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   fetchWithMatrxProtocolFallback: () => fetchWithMatrxProtocolFallback,
   followRuntimeOperationEvents: () => followRuntimeOperationEvents,
   followRuntimeOperationToEnd: () => followRuntimeOperationToEnd,
+  followUnavailableRejoin: () => followUnavailableRejoin,
   followWorkflowRunEvents: () => followWorkflowRunEvents,
   getRuntimeOperationStatus: () => getRuntimeOperationStatus,
   getRuntimeOperationsByLink: () => getRuntimeOperationsByLink,
@@ -89,6 +90,7 @@ __export(index_exports, {
   readImageRoleLimits: () => readImageRoleLimits,
   readLiveRunRejoin: () => readLiveRunRejoin,
   readLiveRunRequestId: () => readLiveRunRequestId,
+  readLiveStreamUnavailable: () => readLiveStreamUnavailable,
   readMatrxErrorCode: () => readMatrxErrorCode,
   readMatrxNdjsonStream: () => readMatrxNdjsonStream,
   readMatrxSseStream: () => readMatrxSseStream,
@@ -102,6 +104,7 @@ __export(index_exports, {
   rolesFor: () => rolesFor,
   runAgentToCompletion: () => runAgentToCompletion,
   runtimeOperationRejoinPath: () => runtimeOperationRejoinPath,
+  settleRunPickup: () => settleRunPickup,
   startAgentRun: () => startAgentRun,
   startMandateRun: () => startMandateRun,
   streamErrorText: () => streamErrorText,
@@ -1493,18 +1496,18 @@ async function followRuntimeOperationToEnd(transport, executionId, options) {
   let cursor = options.lastEventSeq ?? 0;
   let failures = 0;
   while (!outer?.aborted && failures < reconnectLimit) {
-    const attempt = new AbortController();
-    const onOuterAbort = () => attempt.abort();
+    const attempt2 = new AbortController();
+    const onOuterAbort = () => attempt2.abort();
     outer?.addEventListener("abort", onOuterAbort, { once: true });
     let stallTimer = null;
     const armStall = () => {
       if (stallTimer !== null) clearTimeout(stallTimer);
-      stallTimer = setTimeout(() => attempt.abort(), stallTimeoutMs);
+      stallTimer = setTimeout(() => attempt2.abort(), stallTimeoutMs);
     };
     try {
       const items = followRuntimeOperationEvents(transport, executionId, {
         lastEventSeq: cursor,
-        signal: attempt.signal,
+        signal: attempt2.signal,
         ...options.onMalformedFrame ? { onMalformedFrame: options.onMalformedFrame } : {}
       });
       armStall();
@@ -1599,7 +1602,7 @@ function readLiveRunRejoin(error) {
   const candidates = detailCandidates(bodyOf(error));
   if (candidates.length === 0) return null;
   const code = readMatrxErrorCode(error);
-  if (code !== MATRX_RUN_IN_PROGRESS && code !== MATRX_RESUME_CONFLICT) return null;
+  if (code !== MATRX_RUN_IN_PROGRESS) return null;
   const liveRequestId = firstString(candidates, "live_request_id");
   const pathFromBody = firstString(candidates, "rejoin_path");
   const rejoinPath = pathFromBody && pathFromBody.startsWith("/") ? pathFromBody : liveRequestId ? runtimeOperationRejoinPath(liveRequestId) : null;
@@ -1617,7 +1620,7 @@ function readLiveRunRequestId(error) {
   return readLiveRunRejoin(error)?.liveRequestId ?? null;
 }
 function isResumeConflict(error) {
-  return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_RESUME_CONFLICT && readLiveRunRejoin(error) === null;
+  return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_RESUME_CONFLICT;
 }
 function isLiveStreamUnavailable(error) {
   return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_LIVE_STREAM_UNAVAILABLE;
@@ -1720,7 +1723,7 @@ async function resumeOrRejoin(transport, resumeCall, options) {
     rejoin = target;
   }
   onRejoin?.(rejoin);
-  let unavailableBody;
+  let unavailable;
   try {
     const handle = await openMatrxStream(bound, rejoin.rejoinPath, {
       ...streamOptions,
@@ -1730,14 +1733,29 @@ async function resumeOrRejoin(transport, resumeCall, options) {
     await drain(handle, onEnvelope);
     return { kind: "rejoined", rejoin };
   } catch (error) {
-    if (!isLiveStreamUnavailable(error)) throw error;
-    unavailableBody = bodyOf(error);
+    const read = readLiveStreamUnavailable(error);
+    if (!read) throw error;
+    unavailable = read;
   }
-  const runId = firstString(detailCandidates(unavailableBody), "run_id") ?? rejoin.runId;
+  return followUnavailableRejoin(bound, rejoin, unavailable, {
+    ...signalOnly,
+    ...onOperationEvent ? { onOperationEvent } : {},
+    ...onWorkflowEvent ? { onWorkflowEvent } : {},
+    ...follow ? { follow } : {}
+  });
+}
+function readLiveStreamUnavailable(error) {
+  if (!isLiveStreamUnavailable(error)) return null;
+  return { runId: firstString(detailCandidates(bodyOf(error)), "run_id") };
+}
+async function followUnavailableRejoin(transport, rejoin, unavailable, options = {}) {
+  const bound = options.organizationId ? withRunOrganization(transport, options.organizationId) : transport;
+  const signalOnly = options.signal ? { signal: options.signal } : {};
+  const runId = unavailable.runId ?? rejoin.runId;
   if (runId && rejoin.rejoinPath.startsWith("/runtime/operations/")) {
     const result2 = await followWorkflowRunEvents(bound, runId, {
       ...signalOnly,
-      onEvent: (event, seq) => onWorkflowEvent?.(event, seq)
+      onEvent: (event, seq) => options.onWorkflowEvent?.(event, seq)
     });
     return { kind: "followed_workflow", rejoin, runId, ended: result2.ended };
   }
@@ -1757,10 +1775,10 @@ async function resumeOrRejoin(transport, resumeCall, options) {
     };
   }
   const result = await followRuntimeOperationToEnd(bound, operation.execution_id, {
-    ...follow,
+    ...options.follow,
     lastEventSeq: operation.last_event_seq,
     ...signalOnly,
-    onEvent: (event) => onOperationEvent?.(event)
+    onEvent: (event) => options.onOperationEvent?.(event)
   });
   return {
     kind: "followed",
@@ -1770,6 +1788,35 @@ async function resumeOrRejoin(transport, resumeCall, options) {
     status: result.status
   };
 }
+async function attempt(run) {
+  try {
+    await run();
+    return { reloaded: true };
+  } catch (error) {
+    return { reloaded: false, error };
+  }
+}
+async function settleRunPickup(pickup, options) {
+  switch (pickup.kind) {
+    case "resumed":
+    case "rejoined":
+      return { state: "streamed" };
+    case "resume_conflict":
+      return { state: "retry" };
+    case "followed_workflow":
+    case "followed": {
+      const status = pickup.kind === "followed" ? pickup.status : null;
+      const nothingLive = pickup.kind === "followed" && pickup.executionId === null;
+      if (pickup.ended || nothingLive) {
+        return { state: "settled", status, ...await attempt(options.reloadSavedTurn) };
+      }
+      return {
+        state: "still_running",
+        ...await attempt(options.onStillRunning ?? options.reloadSavedTurn)
+      };
+    }
+  }
+}
 
 // matrx/run.ts
 async function streamCall(transport, path, body, options) {