@agimon-ai/po-workflow 0.0.0-alpha.84 → 0.0.0-alpha.86

package/dist/extensions/server.cjs

@@ -4083,7 +4083,6 @@ function createWorkflowServices() {
 		registerPolicy(session, coordinator, callback, options) {
 			if (disposed || !session || !coordinator) throw new Error("Workflow policy registration is unavailable.");
 			const key = JSON.stringify([session, coordinator]);
-			if (policies.has(key)) throw new Error("Workflow policy coordinator is already registered for this session.");
 			const keys = new Set(options.environmentKeys);
 			for (const name of keys) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || /^(PO_|WORKFLOW_)/.test(name)) throw new Error("Protected workflow policy environment key.");
 			const generation = (0, node_crypto.randomUUID)();
@@ -4130,7 +4129,7 @@ function createWorkflowServices() {
 			return policies.get(key)?.generation === policy.generation ? "delivered" : "unavailable";
 		},
 		registerOwner(session, owner) {
-			if (disposed || owners.has(session)) throw new Error("Workflow owner is already registered.");
+			if (disposed) throw new Error("Workflow services are disposed.");
 			const generation = (0, node_crypto.randomUUID)();
 			owners.set(session, {
 				generation,
@@ -4212,6 +4211,7 @@ function createWorkflowServices() {
 			for (const entry of listeners) if (entry.runId === state.run.runId && read(entry.session, entry.runId) !== void 0) entry.listener(structuredClone(runs.get(state.run.runId).state));
 		},
 		withdraw(owner) {
+			if (owners.has(owner)) return;
 			for (const [id, run] of runs) if (run.owner === owner) runs.delete(id);
 			for (const entry of listeners) if (entry.session === owner) listeners.delete(entry);
 		},
@@ -7186,6 +7186,7 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 	*/
 	const launchIn = async (owner, parameters) => {
 		if (serverHost.context.requestApi === void 0) return textResult(`Error: this host cannot reach session ${owner} to launch the workflow there.`, true);
+		watchOwner(owner);
 		const response = await serverHost.context.requestApi({
 			scope: "session",
 			sessionId: owner
@@ -7479,11 +7480,24 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 			...(savedLocations ?? []).map((location) => location.homeDir)
 		])].map((home) => featureFor(home).registry);
 	};
+	const settlementDeliveries = /* @__PURE__ */ new Map();
 	settlement = require_RecoverWorkflowService.createWorkflowSettlement({
 		sessionId: host.context.sessionId,
 		signal: startupAbort.signal,
 		registries: admissionRegistries,
-		settle: async (request) => publicServices ? publicServices.settle(request) : "unavailable",
+		settle: async (request) => {
+			const delivery = publicServices ? await publicServices.settle(request) : "unavailable";
+			if (settlementDeliveries.get(request.run.runId) !== delivery) {
+				settlementDeliveries.set(request.run.runId, delivery);
+				telemetry.recordEvent("po_workflow.settlement_delivery", {
+					name: request.binding.association.coordinator,
+					outcome: request.outcome,
+					status: delivery,
+					attached: publicServices !== void 0
+				});
+			}
+			return delivery;
+		},
 		report: reportLifecycleFailure
 	});
 	const rehydrateRun = async (id) => {
@@ -7600,9 +7614,7 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 		registries: admissionRegistries,
 		validate: validateAdmission,
 		registerPolicy(coordinator, callback, options) {
-			assertAvailable();
-			if (!publicServices) throw new Error("Workflow policy registration is unavailable.");
-			if (policies.has(coordinator)) throw new Error("Workflow policy coordinator is already registered for this session.");
+			if (disposed) throw new Error(RUNTIME_DISPOSED_MESSAGE);
 			const registration = {
 				callback,
 				options: {
@@ -7610,11 +7622,15 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 					environmentKeys: [...options.environmentKeys]
 				}
 			};
-			registration.binding = {
+			if (publicServices) registration.binding = {
 				service: publicServices,
 				handle: publicServices.registerPolicy(host.context.sessionId, coordinator, callback, registration.options)
 			};
 			policies.set(coordinator, registration);
+			telemetry.recordEvent("po_workflow.policy_registered", {
+				name: coordinator,
+				state: registration.binding ? "bound" : "waiting"
+			});
 			queueMicrotask(deliverSettlements);
 			return { dispose() {
 				registration.binding?.handle.dispose();
@@ -7629,6 +7645,7 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 				const ownerId = record.admission?.ownerSessionId ?? request.previousRun.ownerSessionId;
 				const owner = publicServices?.owner(ownerId);
 				if (!owner) throw new Error("Workflow recovery owner is unavailable; admission remains pending.");
+				watchOwner(ownerId);
 				await owner.recover(request.previousRun, request.options?.runner, admission);
 			} else {
 				const input = await admissionInput(request);
@@ -7636,6 +7653,7 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 				if (ownerId !== void 0) {
 					const owner = publicServices?.owner(ownerId);
 					if (!owner) throw new Error("Workflow launch owner is unavailable; admission remains pending.");
+					watchOwner(ownerId);
 					await owner.launch(input, {
 						...admission,
 						ownerSessionId: ownerId
@@ -7836,6 +7854,7 @@ function createWorkflowServerRuntime(host, serverHost, runtime, resolveSecrets,
 								service,
 								handle: service.registerPolicy(host.context.sessionId, coordinator, registration.callback, registration.options)
 							};
+							telemetry.recordEvent("po_workflow.policies_bound", { size: policies.size });
 							queueMicrotask(deliverSettlements);
 						} catch (error) {
 							detach();