@memberjunction/server 6.1.0-edge.1 → 6.1.0-edge.2

package/src/services/TaskGraphActionRunner.ts

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview MJServer's implementation of the task-graph `TaskActionRunner` seam.
+ *
+ * The counterpart to {@link TaskGraphAgentRunner}: the dispatcher knows *when* an action-assigned
+ * node should run and nothing about how an action executes, so execution is injected. Keeping it
+ * here rather than in `@memberjunction/task-graph` is not tidiness — the action engine depends on
+ * the entity layer the dispatcher also builds on, and importing it there would make every consumer
+ * of durable execution load the action engine as well.
+ *
+ * @module @memberjunction/server
+ */
+import { ActionEngineServer } from '@memberjunction/actions';
+import { ActionParam } from '@memberjunction/actions-base';
+import { LogError } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
+import type { TaskActionRunner, TaskActionRunParams, TaskActionRunResult } from '@memberjunction/task-graph';
+
+export class TaskGraphActionRunner implements TaskActionRunner {
+    public async RunActionForTask(params: TaskActionRunParams): Promise<TaskActionRunResult> {
+        try {
+            await ActionEngineServer.Instance.Config(false, params.ContextUser);
+            const action = ActionEngineServer.Instance.Actions.find((a) => UUIDsEqual(a.ID, params.ActionID));
+            if (!action) {
+                return { Success: false, ErrorMessage: `Action ${params.ActionID} is not in the engine's metadata.` };
+            }
+
+            const result = await ActionEngineServer.Instance.RunAction({
+                Action: action,
+                ContextUser: params.ContextUser,
+                Params: this.buildParams(params),
+                // No Filters. A durable node is work that a filter ALREADY let through — the entity
+                // action's gate ran at dispatch time, on the change context that no longer exists by
+                // the time the dispatcher picks the task up. Re-evaluating here would ask a
+                // transition question with nothing to answer it, and fail closed on every retry.
+                Filters: [],
+            });
+
+            return {
+                Success: result.Success,
+                Output: this.buildOutput(result.Params),
+                ErrorMessage: result.Success ? undefined : result.Message,
+                // The engine already wrote the log; this is the only place its id is in hand. Without
+                // carrying it out, a workflow's action step has no path back to its own execution
+                // record — the one thing anyone wants when an action misbehaves.
+                ActionLogID: result.LogEntry?.ID,
+            };
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            LogError(`[TaskGraphActionRunner] Task ${params.TaskID} failed: ${message}`);
+            return { Success: false, ErrorMessage: message };
+        }
+    }
+
+    /**
+     * Projects the action's parameters onto the flat result a workflow step is expected to produce.
+     *
+     * **Why not return `result.Params` as-is.** That is an `ActionParam[]`, and every consumer of a
+     * step's output addresses fields BY NAME: an output mapping says `{"CurrentPrice": "stockPrice"}`,
+     * and a branch condition then reads `payload.stockPrice`. Handed an array, the mapping finds no
+     * `CurrentPrice`, writes nothing, and the condition evaluates against `undefined` — which is
+     * falsy rather than erroneous, so the workflow takes the other branch and reports success. That
+     * is exactly what the Demo workflow did: step 1 completed with an output payload of `{}` and
+     * every downstream branch was skipped, with nothing anywhere reporting a problem.
+     *
+     * Only `Output` and `Both` params are included. Echoing the inputs back would let a step's own
+     * parameters masquerade as its results, so an output mapping could "succeed" by reading the
+     * value the step was given rather than the one it produced.
+     */
+    private buildOutput(actionParams: ActionParam[]): Record<string, unknown> {
+        const output: Record<string, unknown> = {};
+        for (const p of actionParams ?? []) {
+            if (p.Type === 'Output' || p.Type === 'Both') output[p.Name] = p.Value;
+        }
+        return output;
+    }
+
+    /**
+     * Rebuilds the action's parameters from the task's stored payload.
+     *
+     * **The values here have been through redaction**, because `Task.InputPayload` is persistent,
+     * user-visible storage and nothing writes a raw `ActionParam[]` there. A parameter the binding
+     * marked as not-logged therefore arrives absent rather than secret — the action sees a missing
+     * value, which is the honest consequence of choosing not to persist it, and the reason durable
+     * dispatch is opt-in per binding rather than the default.
+     *
+     * Dependency outputs are merged underneath the task's own input so a node's explicit parameters
+     * always win over an upstream node that happened to emit the same key.
+     */
+    private buildParams(params: TaskActionRunParams): ActionParam[] {
+        const merged: Record<string, unknown> = {};
+        for (const [name, value] of params.DependencyOutputs) {
+            merged[name] = value;
+        }
+        if (params.InputPayload && typeof params.InputPayload === 'object') {
+            Object.assign(merged, params.InputPayload as Record<string, unknown>);
+        }
+        return Object.entries(merged).map(([Name, Value]) => ({ Name, Value, Type: 'Input' }));
+    }
+}

package/src/services/TaskGraphAgentRunner.ts

@@ -15,7 +15,7 @@
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ChatMessageRole } from '@memberjunction/ai';
 import { LogError } from '@memberjunction/core';
-import { MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
+import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended } from '@memberjunction/ai-core-plus';
 import type { TaskAgentRunner, TaskAgentRunParams, TaskAgentRunResult } from '@memberjunction/task-graph';
 
 export class TaskGraphAgentRunner implements TaskAgentRunner {
@@ -30,6 +30,10 @@ export class TaskGraphAgentRunner implements TaskAgentRunner {
                 agent,
                 conversationMessages: [{ role: ChatMessageRole.user, content: this.buildPrompt(params) }],
                 contextUser: params.ContextUser,
+                // Inherited from the graph, so a graph this run goes on to emit is one hop deeper
+                // rather than starting the chain over. Without it MAX_REINVOKE_DEPTH never fires.
+                continuationDepth: params.ContinuationDepth ?? 0,
+                parentRun: await this.loadSubmittingRun(params),
             });
 
             const success = result?.success === true;
@@ -46,6 +50,36 @@ export class TaskGraphAgentRunner implements TaskAgentRunner {
         }
     }
 
+    /**
+     * The run that submitted this graph, as the entity `RunAgent` wants for `parentRun`.
+     *
+     * **Why this link is worth a load.** It sets `ParentRunID` on the spawned run, which turns a
+     * workflow's total cost into one indexed sum over `RootParentRunID` rather than a walk of the
+     * graph, and gives the run a "started by" trail someone can follow back. Without it every
+     * dispatched run looks like it began from nowhere.
+     *
+     * Undefined — never a throw — when there is no submitting run or it cannot be read. A graph
+     * submitted by a schedule, by MCP, or by a person genuinely has no parent run, and failing the
+     * step because its provenance is unavailable would trade real work for a bookkeeping detail.
+     */
+    private async loadSubmittingRun(params: TaskAgentRunParams): Promise<MJAIAgentRunEntityExtended | undefined> {
+        if (!params.SubmittingAgentRunID) return undefined;
+        try {
+            const run = await params.Provider.GetEntityObject<MJAIAgentRunEntityExtended>(
+                'MJ: AI Agent Runs',
+                params.ContextUser,
+            );
+            return (await run.Load(params.SubmittingAgentRunID)) ? run : undefined;
+        } catch (e) {
+            LogError(
+                `[TaskGraphAgentRunner] Task ${params.TaskID}: submitting run ` +
+                `${params.SubmittingAgentRunID} could not be loaded; the spawned run will have no ` +
+                `parent link. ${e instanceof Error ? e.message : String(e)}`,
+            );
+            return undefined;
+        }
+    }
+
     /**
      * Builds the agent's instruction from the task's own input plus its dependencies' outputs.
      *

package/src/services/TaskGraphPromptRunner.ts

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview MJServer's implementation of the task-graph `TaskPromptRunner` seam.
+ *
+ * The third sibling of {@link TaskGraphAgentRunner} and {@link TaskGraphActionRunner}, and here for
+ * the same reason: the dispatcher knows *when* a prompt-assigned node should run and nothing about
+ * how a prompt executes. The AI engine depends on the entity layer the dispatcher also builds on, so
+ * importing it into `@memberjunction/task-graph` would make every consumer of durable execution load
+ * the prompt engine too.
+ *
+ * **Why prompt nodes matter enough to have their own runner.** The `User Onboarding Flow Agent`
+ * ships with six of them. Until this existed, every one of its steps was refused at submission and
+ * the agent could not run at all — the refusal was correct (a persisted step nothing can execute
+ * waits forever) but it made a shipped workflow unusable rather than merely unfinished.
+ *
+ * @module @memberjunction/server
+ */
+import { AIPromptRunner } from '@memberjunction/ai-prompts';
+import { AIEngine } from '@memberjunction/aiengine';
+import { AIPromptParams } from '@memberjunction/ai-core-plus';
+import { LogError } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
+import type { TaskPromptRunner, TaskPromptRunParams, TaskPromptRunResult } from '@memberjunction/task-graph';
+
+/** The placeholder a workflow prompt uses to receive the payload (plan §5.7). */
+const CURRENT_PAYLOAD_PLACEHOLDER = '_CURRENT_PAYLOAD';
+
+export class TaskGraphPromptRunner implements TaskPromptRunner {
+    public async RunPromptForTask(params: TaskPromptRunParams): Promise<TaskPromptRunResult> {
+        try {
+            await AIEngine.Instance.Config(false, params.ContextUser);
+            const prompt = AIEngine.Instance.Prompts.find((p) => UUIDsEqual(p.ID, params.PromptID));
+            if (!prompt) {
+                return { Success: false, ErrorMessage: `Prompt ${params.PromptID} is not in the engine's metadata.` };
+            }
+
+            const promptParams = new AIPromptParams();
+            promptParams.prompt = prompt;
+            promptParams.contextUser = params.ContextUser;
+            promptParams.data = this.buildData(params);
+
+            const result = await new AIPromptRunner().ExecutePrompt(promptParams);
+            if (!result?.success) {
+                return {
+                    Success: false,
+                    ErrorMessage: result?.errorMessage ?? 'The prompt did not return a result.',
+                    PromptRunID: result?.promptRun?.ID,
+                };
+            }
+
+            const parsed = this.parseResponse(result.result);
+            return {
+                Success: true,
+                Output: parsed.payload,
+                PromptRunID: result.promptRun?.ID,
+                ChatMessage: parsed.chatMessage,
+            };
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            LogError(`[TaskGraphPromptRunner] Task ${params.TaskID} failed: ${message}`);
+            return { Success: false, ErrorMessage: message };
+        }
+    }
+
+    /**
+     * What the prompt's template can see.
+     *
+     * The payload arrives under a **placeholder name** rather than being spread across the top level,
+     * so a workflow author writes `{{ _CURRENT_PAYLOAD }}` and gets the whole thing — and a payload
+     * key can never collide with a template parameter and silently win.
+     *
+     * `flowContext` carries what the step knows about its own position: what its prerequisites
+     * produced. Without it a prompt is reasoning about the payload alone and cannot refer to the step
+     * immediately before it.
+     */
+    private buildData(params: TaskPromptRunParams): Record<string, unknown> {
+        const payload = params.InputPayload && typeof params.InputPayload === 'object'
+            ? params.InputPayload as Record<string, unknown>
+            : {};
+
+        const dependencyOutputs: Record<string, unknown> = {};
+        for (const [taskID, output] of params.DependencyOutputs) dependencyOutputs[taskID] = output;
+
+        return {
+            ...(params.TemplateParameters ?? {}),
+            // JSON, not the object. A template writes `{{ _CURRENT_PAYLOAD }}` and expects to SEE
+            // the payload; handing the renderer an object yields "[object Object]", and the model
+            // then answers about a value it was never shown. That failure is invisible from the
+            // outside — the prompt run succeeds, the response is well-formed, and it is about
+            // nothing. It is what kept the Content Pipeline reviewer rejecting a draft it could not
+            // read, on every iteration, forever.
+            [CURRENT_PAYLOAD_PLACEHOLDER]: JSON.stringify(payload, null, 2),
+            flowContext: JSON.stringify({ dependencyOutputs }, null, 2),
+        };
+    }
+
+    /**
+     * Reads the model's response as a payload update, and notices when it wants to stop.
+     *
+     * **A prompt is the only node kind that can end the workflow early**, because it is the only one
+     * doing open-ended reasoning: it can conclude the remaining steps are unnecessary. That is
+     * expressed as a Chat-shaped response, and the dispatcher honours it by skipping what remains and
+     * settling the parent Complete — rather than treating an early finish as an abandoned graph.
+     *
+     * Non-JSON is not an error. A prompt that answers in prose has still answered; it simply carries
+     * no structured update, so it becomes a message rather than a payload merge.
+     */
+    private parseResponse(raw: unknown): { payload?: Record<string, unknown>; chatMessage?: string } {
+        if (raw == null) return {};
+
+        if (typeof raw === 'object') {
+            return this.interpret(raw as Record<string, unknown>);
+        }
+
+        if (typeof raw === 'string') {
+            const text = raw.trim();
+            const fenced = text.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+            try {
+                const parsed: unknown = JSON.parse(fenced);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    return this.interpret(parsed as Record<string, unknown>);
+                }
+            } catch {
+                // Prose, not JSON — see above.
+            }
+            return { chatMessage: text };
+        }
+
+        return {};
+    }
+
+    /** Separates "here is an update" from "we are done, tell them this". */
+    private interpret(obj: Record<string, unknown>): { payload?: Record<string, unknown>; chatMessage?: string } {
+        const nextStep = obj['nextStep'] as { type?: string } | undefined;
+        const wantsChat = nextStep?.type === 'Chat' || obj['taskComplete'] === true;
+        const message = typeof obj['message'] === 'string' ? obj['message'] : undefined;
+
+        if (wantsChat && message) {
+            // The payload still merges: a prompt that both concluded and produced data should not
+            // lose the data because it also had something to say.
+            return { payload: obj, chatMessage: message };
+        }
+        return { payload: obj };
+    }
+}

package/src/telephony/RingCentralTelephonyService.ts

@@ -19,7 +19,7 @@
 
 import { RunView, UserInfo, IMetadataProvider, Metadata, LogError, LogStatus } from '@memberjunction/core';
 import type { MJAIBridgeAgentIdentityEntity, MJAIBridgeProviderEntity } from '@memberjunction/core-entities';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserCache } from '@memberjunction/generic-database-provider';
 import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
 import { CreateBridgeRealtimeSession } from '@memberjunction/ai-agents';
 import {

package/src/telephony/TwilioTelephonyRouter.ts

@@ -20,7 +20,7 @@ import { Router, urlencoded, type Request, type Response } from 'express';
 import { WebSocketServer, type WebSocket } from 'ws';
 import { RegisterMediaUpgradeRoute } from './media-upgrade-router.js';
 import { LogError, LogStatus, UserInfo, IMetadataProvider, Metadata } from '@memberjunction/core';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserCache } from '@memberjunction/generic-database-provider';
 import {
     verifyTwilioSignature,
     resolveInboundCall,

package/src/telephony/VonageTelephonyRouter.ts

@@ -26,7 +26,7 @@ import { WebSocketServer, type WebSocket } from 'ws';
 import type { IncomingMessage } from 'node:http';
 import { RegisterMediaUpgradeRoute } from './media-upgrade-router.js';
 import { LogError, LogStatus, UserInfo, IMetadataProvider, Metadata } from '@memberjunction/core';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserCache } from '@memberjunction/generic-database-provider';
 import {
     verifyVonageSignature,
     verifyVonageJwt,