@ai-matrx/agents 0.23.0 → 0.24.1

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   fetchWithMatrxProtocolFallback: () => fetchWithMatrxProtocolFallback,
   followRuntimeOperationEvents: () => followRuntimeOperationEvents,
   followRuntimeOperationToEnd: () => followRuntimeOperationToEnd,
+  followWorkflowRunEvents: () => followWorkflowRunEvents,
   getRuntimeOperationStatus: () => getRuntimeOperationStatus,
   getRuntimeOperationsByLink: () => getRuntimeOperationsByLink,
   imageRoleVerdict: () => imageRoleVerdict,
@@ -86,6 +87,7 @@ __export(index_exports, {
   projectWorkflowNodeEvent: () => projectWorkflowNodeEvent,
   providerSessionFailureBody: () => providerSessionFailureBody,
   readImageRoleLimits: () => readImageRoleLimits,
+  readLiveRunRejoin: () => readLiveRunRejoin,
   readLiveRunRequestId: () => readLiveRunRequestId,
   readMatrxErrorCode: () => readMatrxErrorCode,
   readMatrxNdjsonStream: () => readMatrxNdjsonStream,
@@ -1585,17 +1587,37 @@ function readMatrxErrorCode(error) {
   }
   return null;
 }
-function readLiveRunRequestId(error) {
-  if (statusOf(error) !== 409) return null;
-  for (const candidate of detailCandidates(bodyOf(error))) {
-    if (candidate.code !== MATRX_RUN_IN_PROGRESS) continue;
-    const live = nonBlank(candidate.live_request_id);
-    if (live) return live.trim();
+function firstString(candidates, key) {
+  for (const candidate of candidates) {
+    const value = nonBlank(candidate[key]);
+    if (value) return value.trim();
   }
   return null;
 }
+function readLiveRunRejoin(error) {
+  if (statusOf(error) !== 409) return null;
+  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;
+  const liveRequestId = firstString(candidates, "live_request_id");
+  const pathFromBody = firstString(candidates, "rejoin_path");
+  const rejoinPath = pathFromBody && pathFromBody.startsWith("/") ? pathFromBody : liveRequestId ? runtimeOperationRejoinPath(liveRequestId) : null;
+  if (!rejoinPath) return null;
+  const root = bodyOf(error);
+  return {
+    liveRequestId,
+    rejoinPath,
+    runId: firstString(candidates, "run_id"),
+    code,
+    body: isRecord4(root) ? root : {}
+  };
+}
+function readLiveRunRequestId(error) {
+  return readLiveRunRejoin(error)?.liveRequestId ?? null;
+}
 function isResumeConflict(error) {
-  return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_RESUME_CONFLICT;
+  return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_RESUME_CONFLICT && readLiveRunRejoin(error) === null;
 }
 function isLiveStreamUnavailable(error) {
   return statusOf(error) === 409 && readMatrxErrorCode(error) === MATRX_LIVE_STREAM_UNAVAILABLE;
@@ -1625,54 +1647,110 @@ function withRunOrganization(transport, organizationId) {
     })
   };
 }
+async function followWorkflowRunEvents(transport, runId, options) {
+  const headers = { Accept: "text/event-stream" };
+  if (options.lastEventId) headers["Last-Event-ID"] = String(options.lastEventId);
+  let response;
+  try {
+    response = await requestStream(
+      transport,
+      `/runs/${encodePathSegment(runId)}/events/stream`,
+      {
+        method: "GET",
+        headers,
+        ...options.signal ? { signal: options.signal } : {}
+      }
+    );
+  } catch (error) {
+    if (options.signal?.aborted) return { ended: false };
+    throw error;
+  }
+  try {
+    for await (const frame of readMatrxSseStream(
+      response.body
+    )) {
+      if (frame.event === "end") return { ended: true };
+      if (frame.data === null) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(frame.data);
+      } catch {
+        continue;
+      }
+      if (!isRecord4(parsed)) continue;
+      options.onEvent(parsed, parsed.event === "node_stream" ? null : frame.seq);
+    }
+  } catch (error) {
+    if (!options.signal?.aborted) throw error;
+  }
+  return { ended: false };
+}
 async function drain(handle, onEnvelope) {
   for await (const envelope of handle.events) onEnvelope(envelope);
 }
 async function resumeOrRejoin(transport, resumeCall, options) {
-  const { onEnvelope, organizationId, onRejoin, onOperationEvent, follow, ...rest } = options;
+  const {
+    onEnvelope,
+    organizationId,
+    onRejoin,
+    onOperationEvent,
+    onWorkflowEvent,
+    follow,
+    ...rest
+  } = options;
   const bound = organizationId ? withRunOrganization(transport, organizationId) : transport;
   const streamOptions = {
     ...rest,
     ...options.signal ? { signal: options.signal } : {}
   };
-  let liveRequestId;
+  const signalOnly = options.signal ? { signal: options.signal } : {};
+  let rejoin;
   try {
     const handle = await resumeCall(bound, streamOptions);
     await drain(handle, onEnvelope);
     return { kind: "resumed", requestId: handle.requestId };
   } catch (error) {
-    if (error instanceof MatrxApiError && isResumeConflict(error)) {
-      return { kind: "resume_conflict", error };
+    const target = readLiveRunRejoin(error);
+    if (!target) {
+      if (error instanceof MatrxApiError && isResumeConflict(error)) {
+        return { kind: "resume_conflict", error };
+      }
+      throw error;
     }
-    const live = readLiveRunRequestId(error);
-    if (!live) throw error;
-    liveRequestId = live;
+    rejoin = target;
   }
-  onRejoin?.(liveRequestId);
+  onRejoin?.(rejoin);
+  let unavailableBody;
   try {
-    const handle = await rejoinRuntimeOperation(bound, liveRequestId, streamOptions);
+    const handle = await openMatrxStream(bound, rejoin.rejoinPath, {
+      ...streamOptions,
+      // The rejoin routes take no body model; the reference client posts {}.
+      body: {}
+    });
     await drain(handle, onEnvelope);
-    return { kind: "rejoined", liveRequestId };
+    return { kind: "rejoined", rejoin };
   } catch (error) {
     if (!isLiveStreamUnavailable(error)) throw error;
+    unavailableBody = bodyOf(error);
   }
-  const statusView = await getRuntimeOperationStatus(bound, liveRequestId, {
-    ...options.signal ? { signal: options.signal } : {}
-  });
+  const runId = firstString(detailCandidates(unavailableBody), "run_id") ?? rejoin.runId;
+  if (runId && rejoin.rejoinPath.startsWith("/runtime/operations/")) {
+    const result2 = await followWorkflowRunEvents(bound, runId, {
+      ...signalOnly,
+      onEvent: (event, seq) => onWorkflowEvent?.(event, seq)
+    });
+    return { kind: "followed_workflow", rejoin, runId, ended: result2.ended };
+  }
+  const liveRequestId = rejoin.liveRequestId;
+  const statusView = liveRequestId ? await getRuntimeOperationStatus(bound, liveRequestId, signalOnly) : null;
   const operation = statusView?.operations.find((op) => !op.is_terminal) ?? statusView?.operations[0] ?? null;
   if (!operation) {
-    return {
-      kind: "followed",
-      liveRequestId,
-      executionId: null,
-      ended: false,
-      status: null
-    };
+    return { kind: "followed", rejoin, executionId: null, ended: false, status: null };
   }
   if (operation.is_terminal) {
     return {
       kind: "followed",
-      liveRequestId,
+      rejoin,
       executionId: operation.execution_id,
       ended: true,
       status: operation.status
@@ -1681,12 +1759,12 @@ async function resumeOrRejoin(transport, resumeCall, options) {
   const result = await followRuntimeOperationToEnd(bound, operation.execution_id, {
     ...follow,
     lastEventSeq: operation.last_event_seq,
-    ...options.signal ? { signal: options.signal } : {},
+    ...signalOnly,
     onEvent: (event) => onOperationEvent?.(event)
   });
   return {
     kind: "followed",
-    liveRequestId,
+    rejoin,
     executionId: operation.execution_id,
     ended: result.ended,
     status: result.status