@memberjunction/ai-agent-manager 5.51.0 → 6.1.0-edge.1

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @memberjunction/ai-agent-manager@5.51.0 build
+> @memberjunction/ai-agent-manager@6.1.0-edge.1 build /home/runner/work/MJ/MJ/packages/AI/AgentManager/core
 > tsc && tsc-alias -f
 

package/CHANGELOG.md

@@ -1,5 +1,93 @@
 # @memberjunction/ai-agent-manager
 
+## 6.1.0-edge.1
+
+### Minor Changes
+
+- 394d276: Phase 6 (Track E) — **`WorkflowSpec`: one object binding WHAT runs to WHEN it runs.**
+
+  `TaskGraphSpec` answered _what_ a workflow does; the scheduling and entity-action substrates answered _when_ something fires. Nothing expressed both at once, so "a workflow" was not a thing anyone could hand over — it was a graph plus a separately-configured trigger that only a human knew were related.
+
+  **`graph` is `TaskGraphSpec` verbatim, not a copy.** That is why this composes rather than translates: a graph authored on the canvas, emitted by an agent, or promoted from a past run is _already_ this shape. A parallel graph type would have re-created the drift Phase 4 spent itself removing.
+
+  **No new storage, and that is the design.** There is no `Workflow` table. A workflow's WHAT is a Flow agent; its WHEN is a Scheduled Job. `WorkflowSpecSync` **reconciles** those, following the pattern `MJRecordProcessEntityServer.Save()` already proved — resolve the type, find the rows this definition owns, upsert or disable. Inventing a `Workflow` row would create a second definition of "a scheduled thing" and give the scheduler two masters that can disagree.
+
+  Rows are owned by a marker inside their own `Configuration`, not by name, so **renaming a workflow cannot orphan its schedule** and leave a second one firing beside the new row. A trigger the spec no longer names is **disabled, not deleted** — the row carries run counts, last-run and next-run, which are the only record it ever fired.
+
+  **Order is load-bearing.** The agent persists _before_ triggers reconcile, because a Scheduled Job needs its ID to point at. Reversed, you get a job referencing an agent that does not exist — a schedule that fires forever and does nothing, with no error anyone sees. Validation runs before either, so a rejected save leaves no orphan agent behind.
+
+  **Two operations, because drafting and committing are different acts.** `Workflow.Validate` writes nothing, so an agent can iterate a draft before anything reaches the scheduler — the draft-then-confirm shape dry-run and Plan Mode established. `Workflow.Save` commits. Both run the identical validator, so a workflow that validates cannot be rejected on save for a different reason. Together they close the "agents cannot schedule anything" hole: today `Create Scheduled Job` cannot even set `Configuration`.
+
+  **Agent persistence crosses a seam.** `AgentSpecSync` is the one place that writes an agent; importing it into the execution substrate would invert the dependency, so the host registers a writer instead. A host without one gets an honest failure rather than a half-saved workflow. The writer reuses Phase 4's `ConvertTaskGraphToAgentSpec` unchanged — "save a runtime graph as a workflow" and "persist a workflow's graph" turn out to be the same operation, which is the practical payoff of the convergence.
+
+  **A discovery worth recording:** `AgentScheduledJobDriver` has existed since the scheduling engine shipped, and `ScheduledJobType.DriverClass` is UNIQUE — so the `Agent` job type was already seeded. The substrate for scheduling an agent was there all along; only the authoring surface was missing. TG12 now pins that seed, because without it a scheduled workflow throws at the moment a user is least able to interpret it.
+
+  **Draft is the default status**, not Active. Every authoring surface — the canvas, a chat card, an agent's MCP call — produces something the author has not yet watched run against real data.
+
+  **Entity-change triggers reconcile too.** My first pass deferred these to Track D on the belief that entity-action invocation was not wired. AN-BC challenged that and was right: `HandleEntityActions` has fired entity actions from the save pipeline all along — validate, before/after save, before/after delete — and `Execute Agent` exists as the dispatch target, written for exactly this. Nothing was missing but the **binding row**. `WorkflowSpecSync` now creates the three rows that express "when an Invoice is updated, run Execute Agent with this agent": the `EntityAction`, the `EntityActionInvocation`, and an `EntityActionParam` carrying the agent. Idempotent by lookup rather than delete-and-recreate, because re-saving a workflow must not detach and re-attach a live trigger — a change landing in that window would be missed.
+
+  40 new unit tests (29 validator, 11 sync) plus integration checks TG11 and TG12. IT71 runs 12/12.
+
+### Patch Changes
+
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+- Updated dependencies [394d276]
+  - @memberjunction/core@6.1.0-edge.1
+  - @memberjunction/core-entities@6.1.0-edge.1
+  - @memberjunction/ai-agents@6.1.0-edge.1
+  - @memberjunction/ai-core-plus@6.1.0-edge.1
+  - @memberjunction/aiengine@6.1.0-edge.1
+  - @memberjunction/ai-engine-base@6.1.0-edge.1
+  - @memberjunction/templates@6.1.0-edge.1
+  - @memberjunction/global@6.1.0-edge.1
+
+## 6.1.0-edge.0
+
+### Patch Changes
+
+- Updated dependencies [2412415]
+- Updated dependencies [9699d0e]
+- Updated dependencies [052b4c7]
+- Updated dependencies [9a905e8]
+- Updated dependencies [841e6ea]
+- Updated dependencies [1d88e00]
+- Updated dependencies [27e4d09]
+- Updated dependencies [1100077]
+  - @memberjunction/core-entities@6.1.0-edge.0
+  - @memberjunction/core@6.1.0-edge.0
+  - @memberjunction/aiengine@6.1.0-edge.0
+  - @memberjunction/ai-agents@6.1.0-edge.0
+  - @memberjunction/ai-engine-base@6.1.0-edge.0
+  - @memberjunction/ai-core-plus@6.1.0-edge.0
+  - @memberjunction/templates@6.1.0-edge.0
+  - @memberjunction/global@6.1.0-edge.0
+
+## 6.0.0
+
+### Patch Changes
+
+- Updated dependencies [a2670a9]
+  - @memberjunction/core@6.0.0
+  - @memberjunction/ai-agents@6.0.0
+  - @memberjunction/ai-engine-base@6.0.0
+  - @memberjunction/ai-core-plus@6.0.0
+  - @memberjunction/aiengine@6.0.0
+  - @memberjunction/core-entities@6.0.0
+  - @memberjunction/templates@6.0.0
+  - @memberjunction/global@6.0.0
+
 ## 5.51.0
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2023 MemberJunction
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/index.d.ts

@@ -8,4 +8,5 @@ export * from './agent-spec-sync.js';
 export * from './agents/architect-agent.js';
 export * from './agents/builder-agent.js';
 export * from './agents/planning-designer-agent.js';
+export * from './workflow-agent-writer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kCAAkC,CAAC;AAEjD,cAAc,mBAAmB,CAAC;AAGlC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kCAAkC,CAAC;AAEjD,cAAc,mBAAmB,CAAC;AAGlC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,cAAc,yBAAyB,CAAC"}

package/dist/index.js

@@ -10,4 +10,5 @@ export * from './agent-spec-sync.js';
 export * from './agents/architect-agent.js';
 export * from './agents/builder-agent.js';
 export * from './agents/planning-designer-agent.js';
+export * from './workflow-agent-writer.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAwB;AACxB,cAAc,kCAAkC,CAAC;AAEjD,cAAc,mBAAmB,CAAC;AAElC,+BAA+B;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAwB;AACxB,cAAc,kCAAkC,CAAC;AAEjD,cAAc,mBAAmB,CAAC;AAElC,+BAA+B;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,cAAc,yBAAyB,CAAC"}

package/dist/workflow-agent-writer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Persists a workflow's graph as a Flow agent, via `AgentSpecSync`.
+ *
+ * This is the host side of the seam `WorkflowSpecSync` declares. It lives here, in the agent-manager,
+ * because `AgentSpecSync` is the **one place that writes an agent** — it already owns atomic
+ * multi-entity writes and the mutation audit, and a second writer would be a second set of rules
+ * about what a valid agent record is.
+ *
+ * The conversion itself is `ConvertTaskGraphToAgentSpec`, shipped in Phase 4. That it is reusable
+ * here without modification is the practical payoff of the convergence: "save a runtime graph as a
+ * workflow" and "persist a workflow's graph" turn out to be the same operation, because after Phase 4
+ * they are the same model.
+ *
+ * @module @memberjunction/ai-agent-manager
+ */
+import { UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { type WorkflowSpec } from '@memberjunction/ai-core-plus';
+/** ClassFactory key under which hosts resolve the writer. */
+export declare const WORKFLOW_AGENT_WRITER_KEY = "WorkflowAgentWriter";
+/** Base so hosts can resolve an implementation without importing this package directly. */
+export declare abstract class WorkflowAgentWriterBase {
+    abstract PersistFlowAgent(spec: WorkflowSpec, context: {
+        ContextUser: UserInfo;
+        Provider: IMetadataProvider;
+    }): Promise<string>;
+}
+export declare class WorkflowAgentWriter extends WorkflowAgentWriterBase {
+    /**
+     * Converts the workflow's graph to a Flow `AgentSpec` and persists it.
+     *
+     * **Losses are logged, not swallowed.** The converter reports what it could not carry across —
+     * human steps, unresolvable agents, run-specific inputs. Dropping that silently would hand
+     * someone a workflow missing an approval they believed they had saved, and they would only find
+     * out by running it. The save still proceeds: a workflow that is 90% right and says so is more
+     * useful than a refusal, and the losses are surfaced to the caller by the operation above.
+     */
+    PersistFlowAgent(spec: WorkflowSpec, context: {
+        ContextUser: UserInfo;
+        Provider: IMetadataProvider;
+    }): Promise<string>;
+    /** Resolves the Flow agent type, so the persisted agent is a Flow rather than a Loop. */
+    private resolveFlowAgentTypeID;
+    /** Name → ID for every agent, lowercased so a spec's human-entered name still resolves. */
+    private buildAgentNameIndex;
+}
+/** Prevents tree-shaking of the registered writer. */
+export declare function LoadWorkflowAgentWriter(): void;
+//# sourceMappingURL=workflow-agent-writer.d.ts.map

package/dist/workflow-agent-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-agent-writer.d.ts","sourceRoot":"","sources":["../src/workflow-agent-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAqB,QAAQ,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEtF,OAAO,EAGH,KAAK,YAAY,EACpB,MAAM,8BAA8B,CAAC;AAGtC,6DAA6D;AAC7D,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,2FAA2F;AAC3F,8BAAsB,uBAAuB;aACzB,gBAAgB,CAC5B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,WAAW,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,iBAAiB,CAAA;KAAE,GAChE,OAAO,CAAC,MAAM,CAAC;CACrB;AAED,qBACa,mBAAoB,SAAQ,uBAAuB;IAC5D;;;;;;;;OAQG;IACU,gBAAgB,CACzB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,WAAW,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,iBAAiB,CAAA;KAAE,GAChE,OAAO,CAAC,MAAM,CAAC;IAuClB,yFAAyF;YAC3E,sBAAsB;IAUpC,2FAA2F;YAC7E,mBAAmB;CASpC;AAED,sDAAsD;AACtD,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C"}

package/dist/workflow-agent-writer.js

@@ -0,0 +1,95 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview Persists a workflow's graph as a Flow agent, via `AgentSpecSync`.
+ *
+ * This is the host side of the seam `WorkflowSpecSync` declares. It lives here, in the agent-manager,
+ * because `AgentSpecSync` is the **one place that writes an agent** — it already owns atomic
+ * multi-entity writes and the mutation audit, and a second writer would be a second set of rules
+ * about what a valid agent record is.
+ *
+ * The conversion itself is `ConvertTaskGraphToAgentSpec`, shipped in Phase 4. That it is reusable
+ * here without modification is the practical payoff of the convergence: "save a runtime graph as a
+ * workflow" and "persist a workflow's graph" turn out to be the same operation, because after Phase 4
+ * they are the same model.
+ *
+ * @module @memberjunction/ai-agent-manager
+ */
+import { LogError, RunView } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { ConvertTaskGraphToAgentSpec, FormatSaveAsWorkflowLosses, } from '@memberjunction/ai-core-plus';
+import { AgentSpecSync } from './agent-spec-sync.js';
+/** ClassFactory key under which hosts resolve the writer. */
+export const WORKFLOW_AGENT_WRITER_KEY = 'WorkflowAgentWriter';
+/** Base so hosts can resolve an implementation without importing this package directly. */
+export class WorkflowAgentWriterBase {
+}
+let WorkflowAgentWriter = class WorkflowAgentWriter extends WorkflowAgentWriterBase {
+    /**
+     * Converts the workflow's graph to a Flow `AgentSpec` and persists it.
+     *
+     * **Losses are logged, not swallowed.** The converter reports what it could not carry across —
+     * human steps, unresolvable agents, run-specific inputs. Dropping that silently would hand
+     * someone a workflow missing an approval they believed they had saved, and they would only find
+     * out by running it. The save still proceeds: a workflow that is 90% right and says so is more
+     * useful than a refusal, and the losses are surfaced to the caller by the operation above.
+     */
+    async PersistFlowAgent(spec, context) {
+        const flowTypeID = await this.resolveFlowAgentTypeID(context);
+        const agentIDsByName = await this.buildAgentNameIndex(context);
+        let counter = 0;
+        const result = ConvertTaskGraphToAgentSpec(spec.graph, {
+            // Deterministic within one call, and unique because AgentSpecSync assigns real keys on
+            // insert — these only have to correlate steps to paths inside this payload.
+            AgentID: `workflow-${Date.now()}-${counter}`,
+            NextID: () => `wf-node-${++counter}`,
+            ResolveAgentID: (name) => agentIDsByName.get(name.trim().toLowerCase()) ?? null,
+            FlowAgentTypeID: flowTypeID,
+            Name: spec.name,
+        });
+        if (!result.Success || !result.Spec) {
+            throw new Error(result.ErrorMessage ?? 'The workflow graph could not be converted to an agent.');
+        }
+        if (result.Losses.length > 0) {
+            LogError(`[WorkflowAgentWriter] "${spec.name}" saved with losses:\n${FormatSaveAsWorkflowLosses(result.Losses)}`);
+        }
+        result.Spec.Description = spec.description ?? result.Spec.Description;
+        // A Draft or Paused workflow persists as an Inactive agent, so nothing can invoke it before
+        // its author has turned it on — the schedule side makes the same choice for the same reason.
+        result.Spec.Status = spec.status === 'Active' ? 'Active' : 'Inactive';
+        const sync = AgentSpecSync.FromRawSpec(result.Spec, context.ContextUser, context.Provider);
+        // AgentSpecSyncResult uses camelCase — it predates the PascalCase-public convention and is
+        // consumed by MCP tools, so it is left alone rather than renamed under this change.
+        const saved = await sync.SaveToDatabase();
+        if (!saved?.success) {
+            throw new Error(`Could not save the workflow's agent "${spec.name}".`);
+        }
+        return saved.agentId;
+    }
+    /** Resolves the Flow agent type, so the persisted agent is a Flow rather than a Loop. */
+    async resolveFlowAgentTypeID(context) {
+        const result = await RunView.FromMetadataProvider(context.Provider).RunView({ EntityName: 'MJ: AI Agent Types', ExtraFilter: `Name='Flow'`, Fields: ['ID'], ResultType: 'simple' }, context.ContextUser);
+        const id = result.Results?.[0]?.ID;
+        if (!id)
+            throw new Error("The 'Flow' agent type was not found — has the metadata seed been pushed?");
+        return id;
+    }
+    /** Name → ID for every agent, lowercased so a spec's human-entered name still resolves. */
+    async buildAgentNameIndex(context) {
+        const result = await RunView.FromMetadataProvider(context.Provider).RunView({ EntityName: 'MJ: AI Agents', Fields: ['ID', 'Name'], ResultType: 'simple' }, context.ContextUser);
+        return new Map((result.Results ?? []).map((a) => [a.Name.trim().toLowerCase(), a.ID]));
+    }
+};
+WorkflowAgentWriter = __decorate([
+    RegisterClass(WorkflowAgentWriterBase, WORKFLOW_AGENT_WRITER_KEY)
+], WorkflowAgentWriter);
+export { WorkflowAgentWriter };
+/** Prevents tree-shaking of the registered writer. */
+export function LoadWorkflowAgentWriter() {
+    void WorkflowAgentWriter;
+}
+//# sourceMappingURL=workflow-agent-writer.js.map

package/dist/workflow-agent-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-agent-writer.js","sourceRoot":"","sources":["../src/workflow-agent-writer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "@memberjunction/ai-agent-manager",
   "type": "module",
-  "version": "5.51.0",
+  "version": "6.1.0-edge.1",
   "description": "Core interfaces and types for the MemberJunction Agent Manager system",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc && tsc-alias -f",
-    "watch": "tsc -w",
-    "clean": "rimraf dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "keywords": [
     "memberjunction",
     "agent-manager",
@@ -21,14 +14,14 @@
   "author": "MemberJunction",
   "license": "ISC",
   "dependencies": {
-    "@memberjunction/ai-agents": "5.51.0",
-    "@memberjunction/ai-core-plus": "5.51.0",
-    "@memberjunction/ai-engine-base": "5.51.0",
-    "@memberjunction/aiengine": "5.51.0",
-    "@memberjunction/core": "5.51.0",
-    "@memberjunction/core-entities": "5.51.0",
-    "@memberjunction/global": "5.51.0",
-    "@memberjunction/templates": "5.51.0"
+    "@memberjunction/ai-agents": "6.1.0-edge.1",
+    "@memberjunction/ai-core-plus": "6.1.0-edge.1",
+    "@memberjunction/ai-engine-base": "6.1.0-edge.1",
+    "@memberjunction/aiengine": "6.1.0-edge.1",
+    "@memberjunction/core": "6.1.0-edge.1",
+    "@memberjunction/core-entities": "6.1.0-edge.1",
+    "@memberjunction/global": "6.1.0-edge.1",
+    "@memberjunction/templates": "6.1.0-edge.1"
   },
   "devDependencies": {
     "@types/node": "^24.10.11",
@@ -38,5 +31,12 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/MemberJunction/MJ"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias -f",
+    "watch": "tsc -w",
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/src/index.ts

@@ -13,3 +13,4 @@ export * from './agent-spec-sync';
 export * from './agents/architect-agent';
 export * from './agents/builder-agent';
 export * from './agents/planning-designer-agent';
+export * from './workflow-agent-writer';

package/src/workflow-agent-writer.ts

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Persists a workflow's graph as a Flow agent, via `AgentSpecSync`.
+ *
+ * This is the host side of the seam `WorkflowSpecSync` declares. It lives here, in the agent-manager,
+ * because `AgentSpecSync` is the **one place that writes an agent** — it already owns atomic
+ * multi-entity writes and the mutation audit, and a second writer would be a second set of rules
+ * about what a valid agent record is.
+ *
+ * The conversion itself is `ConvertTaskGraphToAgentSpec`, shipped in Phase 4. That it is reusable
+ * here without modification is the practical payoff of the convergence: "save a runtime graph as a
+ * workflow" and "persist a workflow's graph" turn out to be the same operation, because after Phase 4
+ * they are the same model.
+ *
+ * @module @memberjunction/ai-agent-manager
+ */
+import { LogError, RunView, UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import {
+    ConvertTaskGraphToAgentSpec,
+    FormatSaveAsWorkflowLosses,
+    type WorkflowSpec,
+} from '@memberjunction/ai-core-plus';
+import { AgentSpecSync } from './agent-spec-sync';
+
+/** ClassFactory key under which hosts resolve the writer. */
+export const WORKFLOW_AGENT_WRITER_KEY = 'WorkflowAgentWriter';
+
+/** Base so hosts can resolve an implementation without importing this package directly. */
+export abstract class WorkflowAgentWriterBase {
+    public abstract PersistFlowAgent(
+        spec: WorkflowSpec,
+        context: { ContextUser: UserInfo; Provider: IMetadataProvider },
+    ): Promise<string>;
+}
+
+@RegisterClass(WorkflowAgentWriterBase, WORKFLOW_AGENT_WRITER_KEY)
+export class WorkflowAgentWriter extends WorkflowAgentWriterBase {
+    /**
+     * Converts the workflow's graph to a Flow `AgentSpec` and persists it.
+     *
+     * **Losses are logged, not swallowed.** The converter reports what it could not carry across —
+     * human steps, unresolvable agents, run-specific inputs. Dropping that silently would hand
+     * someone a workflow missing an approval they believed they had saved, and they would only find
+     * out by running it. The save still proceeds: a workflow that is 90% right and says so is more
+     * useful than a refusal, and the losses are surfaced to the caller by the operation above.
+     */
+    public async PersistFlowAgent(
+        spec: WorkflowSpec,
+        context: { ContextUser: UserInfo; Provider: IMetadataProvider },
+    ): Promise<string> {
+        const flowTypeID = await this.resolveFlowAgentTypeID(context);
+        const agentIDsByName = await this.buildAgentNameIndex(context);
+
+        let counter = 0;
+        const result = ConvertTaskGraphToAgentSpec(spec.graph, {
+            // Deterministic within one call, and unique because AgentSpecSync assigns real keys on
+            // insert — these only have to correlate steps to paths inside this payload.
+            AgentID: `workflow-${Date.now()}-${counter}`,
+            NextID: () => `wf-node-${++counter}`,
+            ResolveAgentID: (name) => agentIDsByName.get(name.trim().toLowerCase()) ?? null,
+            FlowAgentTypeID: flowTypeID,
+            Name: spec.name,
+        });
+
+        if (!result.Success || !result.Spec) {
+            throw new Error(result.ErrorMessage ?? 'The workflow graph could not be converted to an agent.');
+        }
+        if (result.Losses.length > 0) {
+            LogError(
+                `[WorkflowAgentWriter] "${spec.name}" saved with losses:\n${FormatSaveAsWorkflowLosses(result.Losses)}`,
+            );
+        }
+
+        result.Spec.Description = spec.description ?? result.Spec.Description;
+        // A Draft or Paused workflow persists as an Inactive agent, so nothing can invoke it before
+        // its author has turned it on — the schedule side makes the same choice for the same reason.
+        result.Spec.Status = spec.status === 'Active' ? 'Active' : 'Inactive';
+
+        const sync = AgentSpecSync.FromRawSpec(result.Spec, context.ContextUser, context.Provider);
+        // AgentSpecSyncResult uses camelCase — it predates the PascalCase-public convention and is
+        // consumed by MCP tools, so it is left alone rather than renamed under this change.
+        const saved = await sync.SaveToDatabase();
+        if (!saved?.success) {
+            throw new Error(`Could not save the workflow's agent "${spec.name}".`);
+        }
+        return saved.agentId;
+    }
+
+    /** Resolves the Flow agent type, so the persisted agent is a Flow rather than a Loop. */
+    private async resolveFlowAgentTypeID(context: { ContextUser: UserInfo; Provider: IMetadataProvider }): Promise<string> {
+        const result = await RunView.FromMetadataProvider(context.Provider).RunView<{ ID: string }>(
+            { EntityName: 'MJ: AI Agent Types', ExtraFilter: `Name='Flow'`, Fields: ['ID'], ResultType: 'simple' },
+            context.ContextUser,
+        );
+        const id = result.Results?.[0]?.ID;
+        if (!id) throw new Error("The 'Flow' agent type was not found — has the metadata seed been pushed?");
+        return id;
+    }
+
+    /** Name → ID for every agent, lowercased so a spec's human-entered name still resolves. */
+    private async buildAgentNameIndex(
+        context: { ContextUser: UserInfo; Provider: IMetadataProvider },
+    ): Promise<Map<string, string>> {
+        const result = await RunView.FromMetadataProvider(context.Provider).RunView<{ ID: string; Name: string }>(
+            { EntityName: 'MJ: AI Agents', Fields: ['ID', 'Name'], ResultType: 'simple' },
+            context.ContextUser,
+        );
+        return new Map((result.Results ?? []).map((a) => [a.Name.trim().toLowerCase(), a.ID]));
+    }
+}
+
+/** Prevents tree-shaking of the registered writer. */
+export function LoadWorkflowAgentWriter(): void {
+    void WorkflowAgentWriter;
+}