@ajna-inc/workflow 0.5.37 → 0.6.1

package/build/services/WorkflowService.mjs

@@ -0,0 +1,582 @@
+import { __toCommonJS } from "../_virtual/rolldown_runtime.mjs";
+import { WorkflowModuleConfig } from "../WorkflowModuleConfig.mjs";
+import { __decorateMetadata, init_decorateMetadata } from "../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate, init_decorate } from "../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { WorkflowInstanceRecord } from "../repository/WorkflowInstanceRecord.mjs";
+import { WorkflowInstanceRepository } from "../repository/WorkflowInstanceRepository.mjs";
+import { WorkflowTemplateRecord } from "../repository/WorkflowTemplateRecord.mjs";
+import { WorkflowTemplateRepository } from "../repository/WorkflowTemplateRepository.mjs";
+import { WorkflowEventTypes } from "../WorkflowEvents.mjs";
+import { ActionRegistry, IssueCredentialMessageV2Action, IssueCredentialV2Action, LocalStateSetAction, PresentProofV2Action, ProposeCredentialV2Action, RequestCredentialV2Action } from "../actions/ActionRegistry.mjs";
+import { GuardEvaluator, init_GuardEvaluator } from "../engine/GuardEvaluator.mjs";
+import { validateTemplateJson, validateTemplateRefs } from "../model/TemplateValidation.mjs";
+import { ensureArray, findSectionForState, transitionsFromState } from "../model/types.mjs";
+import { CompleteMessage } from "../protocol/messages/CompleteMessage.mjs";
+import { UiFilter_exports, init_UiFilter } from "../ui/UiFilter.mjs";
+import { AgentConfig, AgentContext, EventEmitter, Hasher, TypedArrayEncoder, injectable } from "@credo-ts/core";
+import { DidCommConnectionService, DidCommMessageSender, DidCommOutboundMessageContext, ReturnRouteTypes } from "@credo-ts/didcomm";
+
+//#region src/services/WorkflowService.ts
+init_GuardEvaluator();
+init_decorateMetadata();
+init_decorate();
+var _ref, _ref2, _ref3, _ref4, _ref5;
+const stableStringify = (obj) => {
+	const allKeys = [];
+	JSON.stringify(obj, (k, v) => {
+		allKeys.push(k);
+		return v;
+	});
+	allKeys.sort();
+	return JSON.stringify(obj, allKeys);
+};
+const sha256 = (input) => {
+	const hash = Hasher.hash(TypedArrayEncoder.fromString(input), "sha-256");
+	return TypedArrayEncoder.toHex(hash);
+};
+let WorkflowService = class WorkflowService$1 {
+	constructor(templateRepo, instanceRepo, config, agentConfig, eventEmitter) {
+		this.templateRepo = templateRepo;
+		this.instanceRepo = instanceRepo;
+		this.config = config;
+		this.agentConfig = agentConfig;
+		this.eventEmitter = eventEmitter;
+		this.actions = new ActionRegistry();
+		this.actions.register(new LocalStateSetAction());
+		this.actions.register(new ProposeCredentialV2Action());
+		this.actions.register(new IssueCredentialV2Action());
+		this.actions.register(new RequestCredentialV2Action());
+		this.actions.register(new IssueCredentialMessageV2Action());
+		this.actions.register(new PresentProofV2Action());
+	}
+	registerActions(actions) {
+		for (const a of actions) this.actions.register(a);
+	}
+	async publishTemplate(agentContext, template) {
+		validateTemplateJson(template);
+		validateTemplateRefs(template);
+		const hash = sha256(stableStringify(template));
+		const existing = await this.templateRepo.findByTemplateIdAndVersion(agentContext, template.template_id, template.version);
+		if (existing) {
+			existing.template = template;
+			existing.hash = hash;
+			await this.templateRepo.update(agentContext, existing);
+			return existing;
+		}
+		const record = new WorkflowTemplateRecord({
+			template,
+			hash
+		});
+		await this.templateRepo.save(agentContext, record);
+		return record;
+	}
+	async start(agentContext, opts) {
+		if (opts.instance_id) try {
+			const existingByInstance = await this.instanceRepo.getByInstanceId(agentContext, opts.instance_id);
+			if (existingByInstance) return existingByInstance;
+		} catch {}
+		const tplRec = await this.templateRepo.findByTemplateIdAndVersion(agentContext, opts.template_id, opts.template_version);
+		if (!tplRec) throw this.problem("invalid_template", `template not found: ${opts.template_id}@${opts.template_version || "latest"}`);
+		const tpl = tplRec.template;
+		const startState = tpl.states.find((s) => s.type === "start")?.name || tpl.states[0]?.name;
+		if (!startState) throw this.problem("invalid_template", "no start state");
+		const policy = tpl.instance_policy;
+		const connectionId = opts.connection_id;
+		if (policy.mode === "singleton_per_connection") {
+			const existing = ensureArray(await this.instanceRepo.findByTemplateAndConnection(agentContext, tpl.template_id, connectionId)).shift();
+			if (existing) {
+				if (this.config.autoReturnExistingOnSingleton) return existing;
+				throw this.problem("already_exists", "instance already exists for template/connection");
+			}
+		}
+		let multiplicityKeyValue;
+		if (policy.mode === "multi_per_connection" && policy.multiplicity_key) {
+			multiplicityKeyValue = this.evalMultiplicity(policy.multiplicity_key, opts.context || {});
+			const dup = ensureArray(await this.instanceRepo.findByTemplateConnAndMultiplicity(agentContext, tpl.template_id, connectionId, multiplicityKeyValue)).shift();
+			if (dup) return dup;
+		}
+		let participants = opts.participants || {};
+		try {
+			if (connectionId) {
+				const conn = await agentContext.dependencyManager.resolve(DidCommConnectionService).getById(agentContext, connectionId);
+				const theirDid = conn?.theirDid;
+				const myDid = conn?.did || conn?.myDid;
+				if (theirDid) {
+					const holder = participants.holder || {};
+					if (!holder.did) holder.did = theirDid;
+					participants.holder = holder;
+				}
+				if (myDid) {
+					const issuer = participants.issuer || {};
+					if (!issuer.did) issuer.did = myDid;
+					participants.issuer = issuer;
+				}
+			}
+		} catch {}
+		const instanceId = opts.instance_id || this.uuid();
+		const section = findSectionForState(tpl, startState);
+		const rec = new WorkflowInstanceRecord({
+			instanceId,
+			templateId: tpl.template_id,
+			templateVersion: tpl.version,
+			connectionId,
+			participants,
+			state: startState,
+			section,
+			context: { ...opts.context || {} },
+			artifacts: {},
+			status: "active",
+			history: [],
+			multiplicityKeyValue,
+			idempotencyKeys: []
+		});
+		await this.instanceRepo.save(agentContext, rec);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStateChanged,
+				payload: {
+					instanceRecord: rec,
+					previousState: null,
+					newState: rec.state,
+					event: "start",
+					actionKey: void 0,
+					msgId: void 0
+				}
+			});
+		} catch (_e) {}
+		return rec;
+	}
+	async advance(agentContext, opts, instanceRecord) {
+		let inst;
+		if (instanceRecord) inst = instanceRecord;
+		else try {
+			inst = await this.instanceRepo.getById(agentContext, opts.instance_id);
+		} catch {
+			const found = await this.instanceRepo.getByInstanceId(agentContext, opts.instance_id);
+			if (!found) throw this.problem("invalid_event", "instance not found");
+			inst = found;
+		}
+		const tplRec = await this.templateRepo.findByTemplateIdAndVersion(agentContext, inst.templateId, inst.templateVersion);
+		if (!tplRec) throw this.problem("invalid_template", "template not found for instance");
+		const tpl = tplRec.template;
+		if (inst.status === "paused") throw this.problem("forbidden", "instance is paused");
+		if (inst.status === "canceled") throw this.problem("forbidden", "instance is canceled");
+		if (inst.status === "completed") throw this.problem("invalid_event", "instance already completed");
+		if (opts.idempotency_key && inst.idempotencyKeys?.includes(opts.idempotency_key)) {
+			const prior = inst.idempotency?.find?.((i) => i.key === opts.idempotency_key);
+			if (prior && prior.event !== opts.event) throw this.problem("idempotency_conflict", "same key, different event");
+			return inst;
+		}
+		const candidates = transitionsFromState(tpl, inst.state).filter((t$1) => t$1.on === opts.event);
+		if (!candidates.length) throw this.problem("invalid_event", `no transition for event ${opts.event} from ${inst.state}`);
+		const env = GuardEvaluator.envFromInstance(this.toInstanceData(inst));
+		const enabled = candidates.filter((t$1) => GuardEvaluator.evalGuard(t$1.guard, env));
+		if (!enabled.length) throw this.problem("guard_failed", "guard evaluated false");
+		const t = enabled[0];
+		let artifactsDelta = {};
+		let messageId;
+		if (t.action) {
+			const def = tpl.actions.find((a) => a.key === t.action);
+			if (!def) throw this.problem("invalid_template", `action not defined: ${t.action}`);
+			const handler = this.actions.get(def.typeURI);
+			if (!handler) throw this.problem("action_error", `no handler for type ${def.typeURI}`);
+			const exec = async () => handler.execute({
+				agentContext,
+				template: tpl,
+				instance: this.toInstanceData(inst),
+				action: def,
+				input: opts.input
+			});
+			const timeoutMs = this.config.actionTimeoutMs ?? 15e3;
+			const race = Promise.race([exec(), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("action timeout")), timeoutMs))]);
+			let result;
+			try {
+				result = await race;
+			} catch (e) {
+				throw Object.assign(new Error(e.message || "action timeout"), { code: "action_error" });
+			}
+			artifactsDelta = result?.artifacts || {};
+			if (result?.contextMerge) inst.context = result.contextMerge;
+			if (result?.messageId) messageId = result.messageId;
+		}
+		const fromState = inst.state;
+		try {
+			if ((await this.instanceRepo.getById(agentContext, inst.id)).state !== fromState) throw this.problem("state_conflict", "state changed concurrently");
+		} catch (_e) {}
+		const prevState = inst.state;
+		inst.history.push({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			event: opts.event,
+			from: inst.state,
+			to: t.to,
+			actionKey: t.action,
+			msg_id: messageId
+		});
+		inst.state = t.to;
+		inst.section = findSectionForState(tpl, t.to);
+		inst.artifacts = {
+			...inst.artifacts,
+			...artifactsDelta
+		};
+		if (opts.idempotency_key) {
+			inst.idempotencyKeys = [...inst.idempotencyKeys || [], opts.idempotency_key];
+			inst.idempotency = [...inst.idempotency || [], {
+				key: opts.idempotency_key,
+				event: opts.event,
+				to: t.to,
+				actionKey: t.action
+			}];
+			const limit = Math.max(1, this.config.idempotencyHistoryLimit ?? 100);
+			if ((inst.idempotencyKeys?.length || 0) > limit) inst.idempotencyKeys = inst.idempotencyKeys.slice(-limit);
+			if ((inst.idempotency?.length || 0) > limit) inst.idempotency = inst.idempotency.slice(-limit);
+		}
+		let reachedFinal = false;
+		try {
+			if (tpl.states.find((s) => s.name === t.to)?.type === "final") {
+				inst.status = "completed";
+				reachedFinal = true;
+			}
+		} catch (_e) {}
+		await this.instanceRepo.update(agentContext, inst);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStateChanged,
+				payload: {
+					instanceRecord: inst,
+					previousState: prevState,
+					newState: inst.state,
+					event: opts.event,
+					actionKey: t.action,
+					msgId: messageId
+				}
+			});
+		} catch (_e) {}
+		if (reachedFinal) {
+			try {
+				this.eventEmitter?.emit(agentContext, {
+					type: WorkflowEventTypes.WorkflowInstanceStatusChanged,
+					payload: {
+						instanceRecord: inst,
+						previousStatus: "active",
+						newStatus: "completed"
+					}
+				});
+			} catch (_e) {}
+			try {
+				this.eventEmitter?.emit(agentContext, {
+					type: WorkflowEventTypes.WorkflowInstanceCompleted,
+					payload: {
+						instanceRecord: inst,
+						state: inst.state,
+						section: inst.section
+					}
+				});
+			} catch (_e) {}
+			await this.sendCompleteMessage(agentContext, inst);
+		}
+		return inst;
+	}
+	async status(agentContext, opts, instanceRecord) {
+		let inst;
+		if (instanceRecord) inst = instanceRecord;
+		else try {
+			inst = await this.instanceRepo.getById(agentContext, opts.instance_id);
+		} catch {
+			const found = await this.instanceRepo.getByInstanceId(agentContext, opts.instance_id);
+			if (!found) throw this.problem("invalid_event", "instance not found");
+			inst = found;
+		}
+		const tplRec = await this.templateRepo.findByTemplateIdAndVersion(agentContext, inst.templateId, inst.templateVersion);
+		if (!tplRec) throw this.problem("invalid_template", "template not found for instance");
+		const tpl = tplRec.template;
+		const instData = this.toInstanceData(inst);
+		const env = GuardEvaluator.envFromInstance(instData);
+		const allowed = transitionsFromState(tpl, inst.state).filter((t) => GuardEvaluator.evalGuard(t.guard, env)).map((t) => t.on);
+		const includeActions = opts.include_actions ?? true;
+		const includeUi = opts.include_ui ?? true;
+		const uiEnv = {
+			context: instData.context || {},
+			participants: instData.participants || {},
+			artifacts: instData.artifacts || {},
+			viewer: opts.viewer
+		};
+		const Ui = (init_UiFilter(), __toCommonJS(UiFilter_exports));
+		let derivedProfile = opts.ui_profile;
+		try {
+			const viewerRole = opts.viewer?.role;
+			const viewerKey = opts.viewer?.participantKey;
+			const viewerDid = opts.viewer?.did;
+			const mapKeyToProfile = (k) => {
+				if (!k) return void 0;
+				const key = k.toLowerCase();
+				if (key === "sender" || key === "issuer") return "sender";
+				if (key === "receiver" || key === "holder") return "receiver";
+			};
+			if (!derivedProfile) derivedProfile = mapKeyToProfile(viewerRole) || mapKeyToProfile(viewerKey);
+			if (!derivedProfile && viewerDid && instData?.participants && typeof instData.participants === "object") for (const [pKey, pVal] of Object.entries(instData.participants)) {
+				const did = pVal?.did;
+				if (did && did === viewerDid) {
+					derivedProfile = mapKeyToProfile(pKey);
+					if (derivedProfile) break;
+				}
+			}
+			if (!derivedProfile) {
+				let myDid;
+				if (instData?.connection_id) try {
+					const conn = await agentContext.dependencyManager.resolve(DidCommConnectionService).getById(agentContext, instData.connection_id);
+					myDid = conn?.did || conn?.myDid;
+				} catch {}
+				if (myDid && instData?.participants && typeof instData.participants === "object") for (const [pKey, pVal] of Object.entries(instData.participants)) {
+					const did = pVal?.did;
+					if (did && did === myDid) {
+						derivedProfile = mapKeyToProfile(pKey);
+						if (derivedProfile) break;
+					}
+				}
+			}
+		} catch {}
+		const selected = Ui.selectUi(tpl?.display_hints, inst.state, derivedProfile);
+		const filtered = Ui.filterAndBindUi(selected, uiEnv, opts.viewer, derivedProfile);
+		const menu = includeActions ? filtered.filter((i) => i?.type === "button" || i?.type === "submit-button").map((i) => ({
+			label: i?.label,
+			event: i?.event
+		})) : [];
+		const assets = Ui.collectAssets(filtered, tpl?.display_hints?.assets);
+		const ui = includeUi ? filtered : void 0;
+		let connection;
+		if (inst.connectionId) try {
+			const conn = await agentContext.dependencyManager.resolve(DidCommConnectionService).getById(agentContext, inst.connectionId);
+			connection = {
+				id: conn?.id,
+				myDid: conn?.did || conn?.myDid,
+				theirDid: conn?.theirDid
+			};
+		} catch {}
+		return {
+			instance_id: inst.instanceId,
+			template_id: inst.templateId,
+			template_version: inst.templateVersion,
+			connection_id: inst.connectionId,
+			connection,
+			participants: inst.participants,
+			context: inst.context,
+			status: inst.status,
+			createdAt: inst.createdAt,
+			updatedAt: inst?.updatedAt,
+			state: inst.state,
+			section: inst.section,
+			allowed_events: allowed,
+			action_menu: menu,
+			artifacts: inst.artifacts,
+			...includeUi ? { ui } : {},
+			...derivedProfile ? { ui_profile: derivedProfile } : {},
+			...assets ? { assets } : {}
+		};
+	}
+	async pause(agentContext, opts, instanceRecord) {
+		const inst = instanceRecord || await this.getInstanceByIdOrTag(agentContext, opts.instance_id);
+		const prev = inst.status;
+		inst.status = "paused";
+		await this.instanceRepo.update(agentContext, inst);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStatusChanged,
+				payload: {
+					instanceRecord: inst,
+					previousStatus: prev,
+					newStatus: inst.status,
+					reason: opts.reason
+				}
+			});
+		} catch (_e) {}
+		return inst;
+	}
+	async resume(agentContext, opts, instanceRecord) {
+		const inst = instanceRecord || await this.getInstanceByIdOrTag(agentContext, opts.instance_id);
+		const prev = inst.status;
+		inst.status = "active";
+		await this.instanceRepo.update(agentContext, inst);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStatusChanged,
+				payload: {
+					instanceRecord: inst,
+					previousStatus: prev,
+					newStatus: inst.status,
+					reason: opts.reason
+				}
+			});
+		} catch (_e) {}
+		return inst;
+	}
+	async cancel(agentContext, opts, instanceRecord) {
+		const inst = instanceRecord || await this.getInstanceByIdOrTag(agentContext, opts.instance_id);
+		const prev = inst.status;
+		inst.status = "canceled";
+		await this.instanceRepo.update(agentContext, inst);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStatusChanged,
+				payload: {
+					instanceRecord: inst,
+					previousStatus: prev,
+					newStatus: inst.status,
+					reason: opts.reason
+				}
+			});
+		} catch (_e) {}
+		return inst;
+	}
+	async complete(agentContext, opts, instanceRecord) {
+		const inst = instanceRecord || await this.getInstanceByIdOrTag(agentContext, opts.instance_id);
+		const tplRec = await this.templateRepo.findByTemplateIdAndVersion(agentContext, inst.templateId, inst.templateVersion);
+		if (!tplRec) throw this.problem("invalid_template", "template not found for instance");
+		if (tplRec.template.states.find((s) => s.name === inst.state)?.type !== "final") throw this.problem("forbidden", "cannot complete: state is not final");
+		const prev = inst.status;
+		inst.status = "completed";
+		await this.instanceRepo.update(agentContext, inst);
+		try {
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceStatusChanged,
+				payload: {
+					instanceRecord: inst,
+					previousStatus: prev,
+					newStatus: inst.status,
+					reason: opts.reason
+				}
+			});
+			this.eventEmitter?.emit(agentContext, {
+				type: WorkflowEventTypes.WorkflowInstanceCompleted,
+				payload: {
+					instanceRecord: inst,
+					state: inst.state,
+					section: inst.section
+				}
+			});
+		} catch (_e) {}
+		return inst;
+	}
+	async autoAdvanceByConnection(agentContext, connectionId, event) {
+		const inst = await this.instanceRepo.findLatestByConnection(agentContext, connectionId);
+		if (!inst) return;
+		try {
+			await this.advance(agentContext, {
+				instance_id: inst.instanceId,
+				event,
+				idempotency_key: `auto:${event}:${inst.instanceId}`
+			});
+		} catch (e) {
+			this.agentConfig.logger.debug(`Workflow autoAdvance error: ${e.message}`);
+		}
+	}
+	evalMultiplicity(expr, context) {
+		try {
+			const env = {
+				context,
+				participants: {},
+				artifacts: {}
+			};
+			const val = GuardEvaluator.evalValue(expr, env);
+			return val != null ? String(val) : "";
+		} catch {
+			return "";
+		}
+	}
+	toInstanceData(rec) {
+		return {
+			instance_id: rec.instanceId,
+			template_id: rec.templateId,
+			template_version: rec.templateVersion,
+			connection_id: rec.connectionId,
+			participants: rec.participants,
+			state: rec.state,
+			section: rec.section,
+			context: rec.context,
+			artifacts: rec.artifacts,
+			status: rec.status,
+			history: rec.history,
+			multiplicityKeyValue: rec.multiplicityKeyValue,
+			idempotencyKeys: rec.idempotencyKeys
+		};
+	}
+	problem(code, comment) {
+		const err = new Error(comment);
+		err.code = code;
+		return err;
+	}
+	async getInstanceByIdOrTag(agentContext, instanceId) {
+		try {
+			return await this.instanceRepo.getById(agentContext, instanceId);
+		} catch {
+			const found = await this.instanceRepo.getByInstanceId(agentContext, instanceId);
+			if (!found) throw this.problem("invalid_event", "instance not found");
+			return found;
+		}
+	}
+	uuid() {
+		return `wf_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+	}
+	validateTemplate(t) {
+		const fail = (msg) => {
+			throw this.problem("invalid_template", msg);
+		};
+		if (!t.template_id || !t.version || !t.title) fail("missing required fields");
+		if (!Array.isArray(t.states) || !t.states.length) fail("states required");
+		if (!Array.isArray(t.transitions)) fail("transitions required");
+		if (!Array.isArray(t.actions)) fail("actions required");
+		const stateNames = new Set(t.states.map((s) => s.name));
+		if (![...t.states].some((s) => s.type === "start")) fail("start state required");
+		for (const s of t.states) if (s.section && !t.sections?.some((sec) => sec.name === s.section)) fail(`state.section not found: ${s.section}`);
+		for (const tr of t.transitions) {
+			if (!stateNames.has(tr.from)) fail(`transition.from unknown: ${tr.from}`);
+			if (!stateNames.has(tr.to)) fail(`transition.to unknown: ${tr.to}`);
+			if (tr.action && !t.actions.some((a) => a.key === tr.action)) fail(`transition.action unknown: ${tr.action}`);
+		}
+		for (const a of t.actions) if ("profile_ref" in a && a.profile_ref) {
+			const pr = a.profile_ref;
+			if (pr.startsWith("cp.")) {
+				const key = pr.slice(3);
+				if (!t.catalog?.credential_profiles || !t.catalog.credential_profiles[key]) fail(`catalog.cp missing: ${key}`);
+			} else if (pr.startsWith("pp.")) {
+				const key = pr.slice(3);
+				if (!t.catalog?.proof_profiles || !t.catalog.proof_profiles[key]) fail(`catalog.pp missing: ${key}`);
+			} else fail(`invalid profile_ref: ${pr}`);
+		}
+	}
+	async sendCompleteMessage(agentContext, inst) {
+		try {
+			if (!inst.connectionId) return;
+			const connectionSvc = agentContext.dependencyManager.resolve(DidCommConnectionService);
+			const messageSender = agentContext.dependencyManager.resolve(DidCommMessageSender);
+			const connection = await connectionSvc.getById(agentContext, inst.connectionId);
+			const msg = new CompleteMessage({
+				thid: inst.instanceId,
+				body: {
+					instance_id: inst.instanceId,
+					reason: "state_final"
+				}
+			});
+			try {
+				msg.setReturnRouting(ReturnRouteTypes.thread, inst.instanceId);
+			} catch (_e) {}
+			const outbound = new DidCommOutboundMessageContext(msg, {
+				agentContext,
+				connection
+			});
+			await messageSender.sendMessage(outbound);
+		} catch (e) {
+			this.agentConfig.logger.debug(`Workflow complete notify error: ${e.message}`);
+		}
+	}
+};
+WorkflowService = __decorate([injectable(), __decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof WorkflowTemplateRepository !== "undefined" && WorkflowTemplateRepository) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof WorkflowInstanceRepository !== "undefined" && WorkflowInstanceRepository) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof WorkflowModuleConfig !== "undefined" && WorkflowModuleConfig) === "function" ? _ref3 : Object,
+	typeof (_ref4 = typeof AgentConfig !== "undefined" && AgentConfig) === "function" ? _ref4 : Object,
+	typeof (_ref5 = typeof EventEmitter !== "undefined" && EventEmitter) === "function" ? _ref5 : Object
+])], WorkflowService);
+
+//#endregion
+export { WorkflowService };
+//# sourceMappingURL=WorkflowService.mjs.map