@lssm/lib.contracts 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217073102

package/dist/workflow/sla-monitor.js

@@ -1 +1,47 @@
-var e=class{constructor(e){this.eventEmitter=e}check(e,t){let n=t.definition.sla;if(!n)return;let r=new Date().getTime();if(n.totalDurationMs){let t=r-e.createdAt.getTime();t>n.totalDurationMs&&(e.status===`running`||e.status===`paused`)&&this.eventEmitter(`workflow.sla_breach`,{workflowId:e.workflowId,workflowName:e.workflowName,type:`workflow_duration`,expectedMs:n.totalDurationMs,actualMs:t,breachedAt:new Date})}if(n.stepDurationMs&&e.status===`running`&&e.currentStep){let t=e.history.find(t=>t.stepId===e.currentStep&&t.status===`running`);if(t){let i=n.stepDurationMs[e.currentStep];if(i){let n=r-t.startedAt.getTime();n>i&&this.eventEmitter(`workflow.sla_breach`,{workflowId:e.workflowId,workflowName:e.workflowName,type:`step_duration`,stepId:e.currentStep,expectedMs:i,actualMs:n,breachedAt:new Date})}}}}};export{e as SLAMonitor};
+//#region src/workflow/sla-monitor.ts
+var SLAMonitor = class {
+	constructor(eventEmitter) {
+		this.eventEmitter = eventEmitter;
+	}
+	check(state, spec) {
+		const sla = spec.definition.sla;
+		if (!sla) return;
+		const now = (/* @__PURE__ */ new Date()).getTime();
+		if (sla.totalDurationMs) {
+			const duration = now - state.createdAt.getTime();
+			if (duration > sla.totalDurationMs) {
+				if (state.status === "running" || state.status === "paused") this.eventEmitter("workflow.sla_breach", {
+					workflowId: state.workflowId,
+					workflowName: state.workflowName,
+					type: "workflow_duration",
+					expectedMs: sla.totalDurationMs,
+					actualMs: duration,
+					breachedAt: /* @__PURE__ */ new Date()
+				});
+			}
+		}
+		if (sla.stepDurationMs) {
+			if (state.status === "running" && state.currentStep) {
+				const currentExecution = state.history.find((h) => h.stepId === state.currentStep && h.status === "running");
+				if (currentExecution) {
+					const stepLimit = sla.stepDurationMs[state.currentStep];
+					if (stepLimit) {
+						const stepDuration = now - currentExecution.startedAt.getTime();
+						if (stepDuration > stepLimit) this.eventEmitter("workflow.sla_breach", {
+							workflowId: state.workflowId,
+							workflowName: state.workflowName,
+							type: "step_duration",
+							stepId: state.currentStep,
+							expectedMs: stepLimit,
+							actualMs: stepDuration,
+							breachedAt: /* @__PURE__ */ new Date()
+						});
+					}
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+export { SLAMonitor };

package/dist/workflow/spec.js

@@ -1 +1,32 @@
-function e(e){return`${e.name}.v${e.version}`}var t=class{items=new Map;register(t){let n=e(t.meta);if(this.items.has(n))throw Error(`Duplicate workflow ${n}`);return this.items.set(n,t),this}list(){return[...this.items.values()]}get(e,t){if(t!=null)return this.items.get(`${e}.v${t}`);let n,r=-1/0;for(let t of this.items.values())t.meta.name===e&&t.meta.version>r&&(r=t.meta.version,n=t);return n}};export{t as WorkflowRegistry};
+//#region src/workflow/spec.ts
+function workflowKey(meta) {
+	return `${meta.name}.v${meta.version}`;
+}
+var WorkflowRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = workflowKey(spec.meta);
+		if (this.items.has(key)) throw new Error(`Duplicate workflow ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(name, version) {
+		if (version != null) return this.items.get(`${name}.v${version}`);
+		let candidate;
+		let max = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.name !== name) continue;
+			if (spec.meta.version > max) {
+				max = spec.meta.version;
+				candidate = spec;
+			}
+		}
+		return candidate;
+	}
+};
+
+//#endregion
+export { WorkflowRegistry };

package/dist/workflow/validation.js

@@ -1 +1,175 @@
-var e=class extends Error{constructor(e,t){super(e),this.issues=t,this.name=`WorkflowValidationError`}};function t(e,t={}){let n=[],{definition:a}=e;if(!a.steps.length)return n.push({level:`error`,message:`Workflow must declare at least one step.`}),n;let l=r(a,n),u=a.entryStepId??a.steps[0]?.id??null;u?l.has(u)||n.push({level:`error`,message:`Entry step "${u}" is not defined in steps.`}):n.push({level:`error`,message:`Workflow requires an entry step (definition.entryStepId).`});let d=i(a,l,n);return o(a.steps,t,n),s(u,l,d,n),c(d,n),n}function n(n,r={}){let i=t(n,r);if(i.filter(e=>e.level===`error`).length)throw new e(`Workflow ${n.meta.name}.v${n.meta.version} is invalid`,i)}function r(e,t){let n=new Map;for(let r of e.steps){if(n.has(r.id)){t.push({level:`error`,message:`Duplicate step id "${r.id}" detected.`});continue}n.set(r.id,r),r.type===`automation`&&!r.action?.operation&&t.push({level:`warning`,message:`Automation step "${r.id}" does not declare an operation.`}),r.type===`human`&&!r.action?.form&&t.push({level:`warning`,message:`Human step "${r.id}" does not declare a form.`}),r.guard&&!r.guard.value.trim()&&t.push({level:`error`,message:`Guard for step "${r.id}" must have a non-empty value.`})}return n}function i(e,t,n){let r=new Map,i=new Map;for(let e of t.keys())r.set(e,new Set),i.set(e,0);for(let o of e.transitions){let e=t.get(o.from),s=t.get(o.to);if(!e){n.push({level:`error`,message:`Transition refers to unknown "from" step "${o.from}".`});continue}if(!s){n.push({level:`error`,message:`Transition refers to unknown "to" step "${o.to}".`});continue}r.get(o.from)?.add(o.to),i.set(o.to,(i.get(o.to)??0)+1),a(o,n)}let o=[...i.entries()].filter(([,e])=>e===0).map(([e])=>e);return o.length>1&&n.push({level:`warning`,message:`Workflow has multiple potential entry steps: ${o.join(`, `)}`}),r}function a(e,t){e.condition&&!e.condition.trim()&&t.push({level:`error`,message:`Transition ${e.from} -> ${e.to} declares an empty condition.`})}function o(e,t,n){for(let r of e){let e=r.action;e&&(e.operation&&t.operations&&(t.operations.getSpec(e.operation.name,e.operation.version)||n.push({level:`error`,message:`Step "${r.id}" references unknown operation ${e.operation.name}.v${e.operation.version}.`})),e.form&&t.forms&&(t.forms.get(e.form.key,e.form.version)||n.push({level:`error`,message:`Step "${r.id}" references unknown form ${e.form.key}.v${e.form.version}.`})))}}function s(e,t,n,r){if(!e||!t.has(e))return;let i=new Set,a=[e];for(i.add(e);a.length;){let e=a.shift(),t=n.get(e);if(t)for(let e of t)i.has(e)||(i.add(e),a.push(e))}for(let n of t.keys())i.has(n)||r.push({level:`error`,message:`Step "${n}" is unreachable from entry step "${e}".`})}function c(e,t){let n=new Set,r=new Set,i=!1,a=o=>{if(r.has(o)){i||=(t.push({level:`error`,message:`Workflow contains a cycle involving step "${o}".`}),!0);return}if(n.has(o))return;r.add(o);let s=e.get(o);if(s)for(let e of s)a(e);r.delete(o),n.add(o)};for(let t of e.keys())a(t)}export{e as WorkflowValidationError,n as assertWorkflowSpecValid,t as validateWorkflowSpec};
+//#region src/workflow/validation.ts
+var WorkflowValidationError = class extends Error {
+	constructor(message, issues) {
+		super(message);
+		this.issues = issues;
+		this.name = "WorkflowValidationError";
+	}
+};
+/**
+* Validate workflow structure, references, and reachability.
+* Returns the collected issues. Consumers may call {@link assertWorkflowSpecValid}
+* to throw on validation errors.
+*/
+function validateWorkflowSpec(spec, options = {}) {
+	const issues = [];
+	const { definition } = spec;
+	if (!definition.steps.length) {
+		issues.push({
+			level: "error",
+			message: "Workflow must declare at least one step."
+		});
+		return issues;
+	}
+	const stepsById = indexSteps(definition, issues);
+	const entryStepId = definition.entryStepId ?? definition.steps[0]?.id ?? null;
+	if (!entryStepId) issues.push({
+		level: "error",
+		message: "Workflow requires an entry step (definition.entryStepId)."
+	});
+	else if (!stepsById.has(entryStepId)) issues.push({
+		level: "error",
+		message: `Entry step "${entryStepId}" is not defined in steps.`
+	});
+	const adjacency = buildAdjacency(definition, stepsById, issues);
+	validateStepActions(definition.steps, options, issues);
+	validateReachability(entryStepId, stepsById, adjacency, issues);
+	detectCycles(adjacency, issues);
+	return issues;
+}
+function assertWorkflowSpecValid(spec, options = {}) {
+	const issues = validateWorkflowSpec(spec, options);
+	if (issues.filter((issue) => issue.level === "error").length) throw new WorkflowValidationError(`Workflow ${spec.meta.name}.v${spec.meta.version} is invalid`, issues);
+}
+function indexSteps(definition, issues) {
+	const stepsById = /* @__PURE__ */ new Map();
+	for (const step of definition.steps) {
+		if (stepsById.has(step.id)) {
+			issues.push({
+				level: "error",
+				message: `Duplicate step id "${step.id}" detected.`
+			});
+			continue;
+		}
+		stepsById.set(step.id, step);
+		if (step.type === "automation" && !step.action?.operation) issues.push({
+			level: "warning",
+			message: `Automation step "${step.id}" does not declare an operation.`
+		});
+		if (step.type === "human" && !step.action?.form) issues.push({
+			level: "warning",
+			message: `Human step "${step.id}" does not declare a form.`
+		});
+		if (step.guard && !step.guard.value.trim()) issues.push({
+			level: "error",
+			message: `Guard for step "${step.id}" must have a non-empty value.`
+		});
+	}
+	return stepsById;
+}
+function buildAdjacency(definition, stepsById, issues) {
+	const adjacency = /* @__PURE__ */ new Map();
+	const incoming = /* @__PURE__ */ new Map();
+	for (const stepId of stepsById.keys()) {
+		adjacency.set(stepId, /* @__PURE__ */ new Set());
+		incoming.set(stepId, 0);
+	}
+	for (const transition of definition.transitions) {
+		const from = stepsById.get(transition.from);
+		const to = stepsById.get(transition.to);
+		if (!from) {
+			issues.push({
+				level: "error",
+				message: `Transition refers to unknown "from" step "${transition.from}".`
+			});
+			continue;
+		}
+		if (!to) {
+			issues.push({
+				level: "error",
+				message: `Transition refers to unknown "to" step "${transition.to}".`
+			});
+			continue;
+		}
+		adjacency.get(transition.from)?.add(transition.to);
+		incoming.set(transition.to, (incoming.get(transition.to) ?? 0) + 1);
+		validateTransition(transition, issues);
+	}
+	const roots = [...incoming.entries()].filter(([, count]) => count === 0).map(([id]) => id);
+	if (roots.length > 1) issues.push({
+		level: "warning",
+		message: `Workflow has multiple potential entry steps: ${roots.join(", ")}`
+	});
+	return adjacency;
+}
+function validateTransition(transition, issues) {
+	if (transition.condition && !transition.condition.trim()) issues.push({
+		level: "error",
+		message: `Transition ${transition.from} -> ${transition.to} declares an empty condition.`
+	});
+}
+function validateStepActions(steps, options, issues) {
+	for (const step of steps) {
+		const action = step.action;
+		if (!action) continue;
+		if (action.operation && options.operations) {
+			if (!options.operations.getSpec(action.operation.name, action.operation.version)) issues.push({
+				level: "error",
+				message: `Step "${step.id}" references unknown operation ${action.operation.name}.v${action.operation.version}.`
+			});
+		}
+		if (action.form && options.forms) {
+			if (!options.forms.get(action.form.key, action.form.version)) issues.push({
+				level: "error",
+				message: `Step "${step.id}" references unknown form ${action.form.key}.v${action.form.version}.`
+			});
+		}
+	}
+}
+function validateReachability(entryStepId, stepsById, adjacency, issues) {
+	if (!entryStepId || !stepsById.has(entryStepId)) return;
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entryStepId];
+	visited.add(entryStepId);
+	while (queue.length) {
+		const current = queue.shift();
+		const neighbours = adjacency.get(current);
+		if (!neighbours) continue;
+		for (const next of neighbours) {
+			if (visited.has(next)) continue;
+			visited.add(next);
+			queue.push(next);
+		}
+	}
+	for (const stepId of stepsById.keys()) if (!visited.has(stepId)) issues.push({
+		level: "error",
+		message: `Step "${stepId}" is unreachable from entry step "${entryStepId}".`
+	});
+}
+function detectCycles(adjacency, issues) {
+	const visited = /* @__PURE__ */ new Set();
+	const stack = /* @__PURE__ */ new Set();
+	let cycleReported = false;
+	const dfs = (node) => {
+		if (stack.has(node)) {
+			if (!cycleReported) {
+				issues.push({
+					level: "error",
+					message: `Workflow contains a cycle involving step "${node}".`
+				});
+				cycleReported = true;
+			}
+			return;
+		}
+		if (visited.has(node)) return;
+		stack.add(node);
+		const neighbours = adjacency.get(node);
+		if (neighbours) for (const next of neighbours) dfs(next);
+		stack.delete(node);
+		visited.add(node);
+	};
+	for (const node of adjacency.keys()) dfs(node);
+}
+
+//#endregion
+export { WorkflowValidationError, assertWorkflowSpecValid, validateWorkflowSpec };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.contracts",
-  "version": "0.0.0-canary-20251217063201",
+  "version": "0.0.0-canary-20251217073102",
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "publish:pkg:canary": "bun publish:pkg --tag canary",
@@ -16,20 +16,27 @@
     "test": "bun run"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217063201",
-    "@lssm/tool.typescript": "0.0.0-canary-20251217063201",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217073102",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217073102",
     "@types/express": "^5.0.3",
     "@types/turndown": "^5.0.6",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@pothos/core": "^4.9.1",
+    "@pothos/plugin-complexity": "^4.1.2",
+    "@pothos/plugin-dataloader": "^4.4.2",
+    "@pothos/plugin-prisma": "^4.14.0",
+    "@pothos/plugin-relay": "^4.4.3",
+    "@pothos/plugin-tracing": "^1.1.2",
     "@aws-sdk/client-secrets-manager": "^3.950.0",
     "@aws-sdk/client-sqs": "^3.948.0",
     "@elevenlabs/elevenlabs-js": "^2.27.0",
     "@google-cloud/secret-manager": "^6.1.1",
     "@google-cloud/storage": "^7.18.0",
-    "@lssm/lib.schema": "0.0.0-canary-20251217063201",
+    "@lssm/lib.logger": "0.0.0-canary-20251217073102",
+    "@lssm/lib.schema": "0.0.0-canary-20251217073102",
     "@mistralai/mistralai": "^1.2.3",
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@qdrant/js-client-rest": "^1.16.2",