@mastra/factory 0.24.0-alpha.1 → 0.24.0-alpha.3

package/dist/rules/dispatcher.js

@@ -6,10 +6,10 @@ import "../boards/index.js";
 import { FactoryDispatchError, factoryDispatchFailureCode, factoryDispatchFailureMetadata } from "./dispatch-errors.js";
 import { FACTORY_RULE_MATERIALIZATION_KEY, WorkItemClaimConflictError } from "../storage/domains/work-items/base.js";
 import { moveCardToBoard } from "../boards/relocate.js";
-import { isHumanActorId } from "../storage/domains/audit/actors.js";
-import { resolvePromptInvocation, resolveSkillInvocation, resolveSkillResumeInvocation } from "../skills/service.js";
 import { decisionOvertaken } from "./decision-applicability.js";
 import { FACTORY_OPEN_RUN_STALE_MS, heartbeatSessionOpenRun, isOpenRunLiveElsewhere, listSessionOpenRuns, recordSessionRunStart, waitForSessionRunAudit } from "../session/run-audit.js";
+import { isHumanActorId } from "../storage/domains/audit/actors.js";
+import { resolvePromptInvocation, resolveSkillInvocation, resolveSkillResumeInvocation } from "../skills/service.js";
 import { withWorkItemFeed } from "../storage/domains/comments/feed-context.js";
 import { RequestContext } from "@mastra/core/request-context";
 //#region src/rules/dispatcher.ts
@@ -36,6 +36,8 @@ const STALE_BINDING_TTL_MS = 1440 * 6e4;
 const RECONCILE_INTERVAL_MS = 3e4;
 /** The card moved on before this run could act; it settles as superseded, not succeeded. */
 var FactoryDecisionSuperseded = class extends Error {};
+/** A run that ran and ended in error; the session's own listener reports it to followers. */
+var RunEndedInError = class extends Error {};
 function isTerminalFailure(attempts, failureCode) {
 	return attempts >= MAX_ATTEMPTS || !factoryDispatchFailureMetadata(failureCode).canRetry;
 }
@@ -100,6 +102,8 @@ function watchRun(session, { timeoutMs, approvePlans, onAgentEnd, label, runStil
 		wait,
 		supersededAtEnd: () => supersededAtEnd,
 		endReason: () => endReason,
+		/** The tool the run is parked on, when it ended suspended. */
+		parked: () => parked,
 		close: unsubscribe,
 		/** The run's own verdict, thrown as what the dispatcher should record. */
 		async settle() {
@@ -115,7 +119,7 @@ function watchRun(session, { timeoutMs, approvePlans, onAgentEnd, label, runStil
 				observed = await wait();
 			}
 			if (!observed) throw new FactoryDispatchError("run_terminal_event_missing", `${label} terminal event was not observed before timeout.`);
-			if (endReason === "error") throw new Error(`${label} ended in error.`);
+			if (endReason === "error") throw new RunEndedInError(`${label} ended in error.`);
 			if (endReason === "aborted") {
 				if (omFailure) {
 					if (isPermanentProviderRejection(omFailure)) throw new FactoryDispatchError("run_configuration_invalid", `${label} was aborted by an observational-memory failure that will not succeed on retry: ${omFailure}`);
@@ -243,6 +247,7 @@ var FactoryDecisionDispatcher = class {
 	#reconcileToolResults;
 	#prepareBinding;
 	#primeCredentials;
+	#reportRunEnd;
 	#feedReader;
 	#dismissStaleReviews;
 	#resolveLinkedWorkItemParentId;
@@ -275,6 +280,7 @@ var FactoryDecisionDispatcher = class {
 		this.#reconcileToolResults = options.reconcileToolResults;
 		this.#prepareBinding = options.prepareBinding;
 		this.#primeCredentials = options.primeCredentials;
+		this.#reportRunEnd = options.reportRunEnd;
 		this.#feedReader = options.feedReader;
 		this.#dismissStaleReviews = options.dismissStaleReviews;
 		this.#resolveLinkedWorkItemParentId = options.resolveLinkedWorkItemParentId;
@@ -654,6 +660,7 @@ var FactoryDecisionDispatcher = class {
 						}));
 						if (await kickoffStale()) throw new FactoryDecisionSuperseded();
 					}
+					const since = /* @__PURE__ */ new Date();
 					const run = watchRun(session, {
 						timeoutMs: this.#skillCompletionObservationTimeoutMs,
 						approvePlans: await this.#plansAreAutoApproved(record),
@@ -686,7 +693,13 @@ var FactoryDecisionDispatcher = class {
 						}
 						await this.#recordRunStart(session, binding, deliveryId, record.approvedBy ?? void 0, run.endReason, item?.title);
 						try {
-							await this.#withOpenRunHeartbeat(session, deliveryId, () => run.settle());
+							await this.#reportingRunEnd({
+								binding,
+								startedBy,
+								since,
+								attempts: record.attempts,
+								superseded: async () => await run.supersededAtEnd() ?? await this.#roleSuperseded(record, decision.role)
+							}, () => this.#withOpenRunHeartbeat(session, deliveryId, () => run.settle()));
 						} catch (error) {
 							if (!(await run.supersededAtEnd() ?? await this.#roleSuperseded(record, decision.role))) throw error;
 						}
@@ -1045,6 +1058,44 @@ var FactoryDecisionDispatcher = class {
 			clearInterval(timer);
 		}
 	}
+	/**
+	* Settle a watched run; when it fails terminally, tell the item's followers.
+	* A retryable failure says nothing, since the retry reports. How a run that
+	* ran ends (done, blocked, an error) is reported by the session's own
+	* listener; this covers failures no run end shows. The reporter skips
+	* recipients that already have a final report from this run, and never
+	* throws, so reporting can't change the decision's outcome.
+	*/
+	async #reportingRunEnd({ binding, startedBy, since, attempts, superseded }, settle) {
+		try {
+			await settle();
+		} catch (error) {
+			const reportRunEnd = this.#reportRunEnd;
+			if (reportRunEnd && !(error instanceof RunEndedInError) && !(error instanceof FactoryDecisionSuperseded) && !await superseded?.()) {
+				const failureCode = factoryDispatchFailureCode(error);
+				if (isTerminalFailure(attempts, failureCode)) reportRunEnd({
+					orgId: binding.orgId,
+					factoryProjectId: binding.factoryProjectId,
+					workItemId: binding.workItemId,
+					role: binding.role,
+					sender: {
+						sessionId: binding.sessionId,
+						threadId: binding.threadId,
+						userId: startedBy
+					},
+					since,
+					outcome: {
+						status: "failed",
+						failureCode,
+						reason: sanitizeDispatchError(error)
+					}
+				}).catch((reportError) => {
+					console.warn(`[factory] run-end report failed for binding ${binding.id}:`, reportError);
+				});
+			}
+			throw error;
+		}
+	}
 	async #recordRunStart(session, binding, kickoffId, approvedBy, observedEnd, workItemName) {
 		if (!this.#audit) return;
 		const humanApproved = isHumanActorId(approvedBy);
@@ -1092,6 +1143,7 @@ var FactoryDecisionDispatcher = class {
 					userId: startedBy,
 					orgId: record.orgId
 				});
+				const since = /* @__PURE__ */ new Date();
 				const run = watchRun(session, {
 					timeoutMs: this.#skillCompletionObservationTimeoutMs,
 					approvePlans: await this.#plansAreAutoApproved(record),
@@ -1121,7 +1173,12 @@ var FactoryDecisionDispatcher = class {
 						settled = await sendKickoff(`factory-kickoff:${record.kickoffKey}:retry:${record.attempts}:${deliveryGeneration}`);
 					}
 					await this.#recordRunStart(session, binding, `factory-kickoff:${record.kickoffKey}:${record.attempts}`, startedBy, run.endReason, item?.title);
-					await run.settle();
+					await this.#reportingRunEnd({
+						binding,
+						startedBy,
+						since,
+						attempts: record.attempts
+					}, () => run.settle());
 				} finally {
 					run.close();
 				}