@memberjunction/task-graph 0.0.0 → 6.1.0-edge.2

package/dist/types.d.ts

@@ -0,0 +1,328 @@
+/**
+ * @fileoverview Contracts for task-graph submission and durable execution.
+ * @module @memberjunction/task-graph
+ */
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+/**
+ * Mints a fresh metadata/data provider.
+ *
+ * The dispatcher runs outside any HTTP request and executes tasks concurrently, so it must never
+ * share one provider — and therefore one transaction scope — across parallel work. Rather than
+ * import MJServer (which would invert the dependency: MJServer depends on this package, not the
+ * reverse), the host supplies a factory. MJServer's implementation wraps the same
+ * `createPerRequestProviders` machinery that already mints a provider per request over the shared
+ * connection pool, which is proven cheap at request scale.
+ *
+ * Contract: every call returns a provider safe to use on its own transaction scope. Callers are
+ * responsible for nothing beyond using it — pooling and lifetime are the host's concern.
+ */
+export type ProviderFactory = {
+    CreateProvider(): Promise<IMetadataProvider>;
+};
+/**
+ * Runs one agent for one task node.
+ *
+ * Abstracted rather than taking `AgentRunner` directly so the dispatcher can be unit-tested without
+ * standing up the agent framework, and so a host with a different execution strategy (a queue, a
+ * remote worker) can supply its own.
+ */
+export type TaskAgentRunner = {
+    RunAgentForTask(params: TaskAgentRunParams): Promise<TaskAgentRunResult>;
+};
+/** Everything running one action for one task node needs. */
+export type TaskActionRunParams = {
+    TaskID: string;
+    ActionID: string;
+    /** Structured input from `Task.InputPayload` — for durable entity-action dispatch, the redacted params. */
+    InputPayload: unknown;
+    /** Outputs of this node's satisfied prerequisites, in the same shape agent nodes receive. */
+    DependencyOutputs: Map<string, unknown>;
+    Provider: IMetadataProvider;
+    ContextUser: UserInfo;
+};
+/** The outcome of one action node. */
+export type TaskActionRunResult = {
+    Success: boolean;
+    Output?: unknown;
+    ErrorMessage?: string;
+    /**
+     * The `MJ: Action Execution Logs` row this run produced.
+     *
+     * Carried so the step can record it, which is what lets a workflow's action offer "view the
+     * execution log" the way an ordinary agent run step does. Optional because a runner that
+     * cannot produce one is limited, not broken.
+     */
+    ActionLogID?: string;
+};
+/**
+ * Runs one action for one task node.
+ *
+ * The third execution shape, beside agents and people. Abstracted for the same reason
+ * {@link TaskAgentRunner} is: the dispatcher must stay unit-testable without standing up the action
+ * engine, and this package must not import it — `@memberjunction/actions` depends on the entity
+ * layer this one also builds on, and reaching for it here would make every consumer of durable
+ * execution load the action engine too.
+ *
+ * **A host with no action runner is not broken, it is limited.** Action nodes stay Pending on it,
+ * which is visible in the Tasks UI, rather than being marked failed — a task nobody in this
+ * deployment can run is not the same as a task that ran and did not work.
+ */
+export type TaskActionRunner = {
+    RunActionForTask(params: TaskActionRunParams): Promise<TaskActionRunResult>;
+};
+/** Everything running one prompt for one task node needs. */
+export type TaskPromptRunParams = {
+    TaskID: string;
+    PromptID: string;
+    /** Structured input from `Task.InputPayload`, after the node's input mapping. */
+    InputPayload: unknown;
+    /** Outputs of this node's satisfied prerequisites, in the same shape agent nodes receive. */
+    DependencyOutputs: Map<string, unknown>;
+    /** Template parameters declared on the node's configuration. */
+    TemplateParameters?: Record<string, string>;
+    Provider: IMetadataProvider;
+    ContextUser: UserInfo;
+};
+/** The outcome of one prompt node. */
+export type TaskPromptRunResult = {
+    Success: boolean;
+    /** The parsed JSON response, deep-merged into the payload by the dispatcher. */
+    Output?: unknown;
+    ErrorMessage?: string;
+    /** The `MJ: AI Prompt Runs` row, for provenance. */
+    PromptRunID?: string;
+    /**
+     * Set when the prompt asked to end the workflow and say something to a person.
+     *
+     * A prompt is the one node kind that can decide the workflow is *done* — it is the only one
+     * doing open-ended reasoning. The dispatcher honours it by skipping the remaining tasks and
+     * settling the parent Complete with this message, rather than treating an early finish as an
+     * abandoned graph.
+     */
+    ChatMessage?: string;
+};
+/**
+ * Runs one prompt for one task node.
+ *
+ * The fourth execution shape, and abstracted for the same reason as the others: this package must
+ * stay unit-testable without standing up the AI engine, and must not import it — the prompt runner
+ * lives in MJServer where the engine already does.
+ *
+ * **A host with no prompt runner is limited, not broken.** Prompt nodes stay Pending and visible,
+ * exactly like action nodes without an action runner.
+ */
+export type TaskPromptRunner = {
+    RunPromptForTask(params: TaskPromptRunParams): Promise<TaskPromptRunResult>;
+};
+/** What happened to a task or a graph, as a closed set a consumer can branch on. */
+export type TaskGraphFrameKind = 
+/** A task was claimed by an instance and is about to run. */
+'TaskStarted'
+/** A task finished successfully. */
+ | 'TaskCompleted'
+/** A task failed. `ErrorMessage` says why. */
+ | 'TaskFailed'
+/** A task was blocked because a prerequisite failed or became unreachable. */
+ | 'TaskBlocked'
+/**
+ * A task was NOT TAKEN because another branch of an exclusive fan-out won.
+ *
+ * Distinct from `TaskBlocked` on purpose: blocked means something went wrong upstream and the
+ * viewer should look for a cause; skipped means the workflow chose a different route and there
+ * is nothing to investigate. Rendering them the same would send people hunting for bugs that do
+ * not exist.
+ */
+ | 'TaskSkipped'
+/** A human task became actionable and is waiting on its assignee. */
+ | 'TaskAwaitingHuman'
+/** Every node has reached a terminal state; `Status` is the graph's rolled-up outcome. */
+ | 'GraphSettled';
+/**
+ * One thing that happened, addressed by the graph it happened in.
+ *
+ * **Addressed by `ParentTaskID`, deliberately not by session.** A durable graph outlives the tab
+ * that submitted it — it may be started by a schedule with no session at all, and a user who
+ * refreshes mid-run should still see the rest. Keying on the graph means "watch this workflow run"
+ * works for anyone permitted to read it, whenever they arrive.
+ *
+ * Frames are **semantic, not cache invalidations**: a consumer renders "step 3 of 7 running" from
+ * the frame itself rather than re-reading rows and diffing them to guess what changed.
+ */
+export type TaskGraphFrame = {
+    Kind: TaskGraphFrameKind;
+    /** The graph this happened in — the subscription key. */
+    ParentTaskID: string;
+    /**
+     * Who the graph belongs to, from the parent's durable metadata.
+     *
+     * Carried on the frame rather than looked up by the consumer because a consumer's delivery
+     * filter runs per frame and synchronously — a database round trip there would make watching a
+     * run cost more than running it. Absent means the graph predates ownership being recorded, and
+     * a consumer that authorizes on it should fail closed rather than broadcast.
+     */
+    OwnerUserID?: string | null;
+    /** The node it happened to. Absent on `GraphSettled`, which is about the graph itself. */
+    TaskID?: string;
+    /** Node name, so a consumer can label the frame without loading the row. */
+    TaskName?: string;
+    /** The task's (or, for `GraphSettled`, the graph's) status after the event. */
+    Status?: string;
+    /** Failure detail on `TaskFailed`. */
+    ErrorMessage?: string;
+    /** For a human task, who it is waiting on. */
+    AssignedUserID?: string;
+    /** How many nodes have reached a terminal state, and out of how many. */
+    CompletedCount?: number;
+    TotalCount?: number;
+};
+/**
+ * Receives dispatcher lifecycle frames.
+ *
+ * Optional, and a host that supplies none loses nothing but visibility — the dispatcher's behavior
+ * is identical either way. Abstracted for the same reason execution and continuation are: publishing
+ * to subscribers is a transport concern, and this package must not acquire a dependency on the
+ * transport layer to gain observability.
+ *
+ * Implementations MUST NOT throw and MUST NOT block: a frame is an announcement about work, never a
+ * step of it, so a broken observer must not be able to stall or fail a graph.
+ */
+export type TaskGraphObserver = {
+    OnFrame(frame: TaskGraphFrame): void;
+};
+/** Everything an executor needs to run a single task node. */
+export type TaskAgentRunParams = {
+    /** The task row being executed. */
+    TaskID: string;
+    /**
+     * The agent run that submitted this graph, when there was one.
+     *
+     * Becomes the spawned run's `ParentRunID`, which is what makes a workflow's total cost a single
+     * indexed sum over `RootParentRunID` instead of a walk. Null for a graph nobody's run submitted
+     * — a schedule, MCP, or a person — and that is a real case, not a missing value.
+     *
+     * Note this is a run→run link: the task graph sits BETWEEN the two conceptually but cannot be
+     * the parent, because the column points at a run. The graph is recovered through
+     * `Task.AgentRunID` and `Task.ParentID`.
+     */
+    SubmittingAgentRunID?: string | null;
+    /**
+     * How many continuation hops led to this run, from the graph's own metadata.
+     *
+     * Carried so the chain is BOUNDED. A flow that dispatches a graph containing itself recurses
+     * forever otherwise: each spawned run starts at depth zero, so `MAX_REINVOKE_DEPTH` compares
+     * against a permanent zero and never fires. The cap exists; this is what feeds it.
+     */
+    ContinuationDepth?: number;
+    /** Agent assigned to the task. */
+    AgentID: string;
+    /** Parsed `Task.InputPayload`, if any. */
+    InputPayload: unknown;
+    /** Parsed `OutputPayload` of each completed dependency, keyed by that task's ID. */
+    DependencyOutputs: Map<string, unknown>;
+    /** Provider minted for this task alone — never shared with a sibling. */
+    Provider: IMetadataProvider;
+    /** User the work runs as. */
+    ContextUser: UserInfo;
+};
+/** Outcome of running one task node. */
+export type TaskAgentRunResult = {
+    Success: boolean;
+    /** Structured output to persist to `Task.OutputPayload`. */
+    Output?: unknown;
+    /** Failure detail to persist to `Task.ErrorMessage`. */
+    ErrorMessage?: string;
+    /** The `MJ: AI Agent Runs` row that executed this task, for `Task.AgentRunID`. */
+    AgentRunID?: string;
+};
+/**
+ * Delivers a finished graph's outcome, per its `continuation` mode.
+ *
+ * Abstracted for the same reason agent execution is: the dispatcher knows *when* a graph has
+ * settled and *what* it produced, but posting into a conversation and starting a fresh agent turn
+ * are host concerns. Injecting them keeps this package free of both the conversation layer and the
+ * agent framework — a dependency on the latter would be circular, since agents submit graphs.
+ *
+ * A host that implements neither still gets correct behavior: the dispatcher logs the outcome and
+ * marks it delivered, so a graph never silently repeats its completion.
+ */
+export type TaskContinuationDeliverer = {
+    /** Posts the results into the conversation the graph answers. */
+    PostMessage(params: TaskContinuationParams): Promise<void>;
+    /**
+     * Starts the submitting agent a fresh turn carrying the outcome.
+     *
+     * Optional: a host with no agent framework loaded (a worker, a test) legitimately cannot do
+     * this, and the dispatcher degrades to `PostMessage` rather than dropping the completion.
+     */
+    Reinvoke?(params: TaskContinuationParams): Promise<void>;
+};
+/** Everything a continuation needs to say what happened. */
+export type TaskContinuationParams = {
+    ParentTaskID: string;
+    WorkflowName: string;
+    /** Conversation the graph answers, when it came from a conversational channel. */
+    ConversationDetailID: string | null;
+    /** The agent run that emitted the graph — the target of a `reinvoke`. */
+    SubmittedByAgentRunID: string | null;
+    /** How many continuation hops preceded this one, so a re-submitted graph can carry depth + 1. */
+    ReinvokeDepth: number;
+    /**
+     * Per-task outcome. Deliberately carries a `summary` and an `outputRef`, not inline payloads —
+     * a ten-task graph's full outputs would swamp the continuation turn's context window, and the
+     * agent can pull what it actually needs by task ID.
+     */
+    Tasks: Array<{
+        TaskID: string;
+        Name: string;
+        Status: string;
+        Summary?: string;
+        ErrorMessage?: string;
+    }>;
+    /** One-line human-readable roll-up. */
+    Summary: string;
+};
+/** Tuning knobs for the durable dispatcher. */
+export type TaskGraphDispatcherConfig = {
+    /**
+     * Identifies this dispatcher instance in `Task.ClaimedBy`. Must be stable for the process
+     * lifetime and distinct per instance — it is what lets reconciliation tell "my orphaned work"
+     * from "another instance's live work".
+     */
+    InstanceID: string;
+    /**
+     * How long a claim is honored before reconciliation may reclaim the task.
+     *
+     * Generous by default: the cost of a too-short TTL is a *duplicate execution* (a healthy but
+     * slow task gets reclaimed while still running), whereas the cost of a too-long TTL is merely
+     * delayed recovery after a crash. Long-running tasks extend it by heartbeat, so the TTL only
+     * has to exceed the heartbeat interval by a comfortable margin.
+     */
+    ClaimTTLSeconds: number;
+    /** How often an in-flight task extends its own claim. Must be well below `ClaimTTLSeconds`. */
+    HeartbeatIntervalSeconds: number;
+    /** Maximum tasks executed concurrently by this instance. */
+    MaxConcurrentTasks: number;
+    /**
+     * How often to look for claimable work.
+     *
+     * Five seconds is the right production default — a graph's steps are agent runs measured in
+     * seconds to minutes, so polling faster buys latency nobody perceives and costs a query per
+     * instance per tick. It is configurable rather than fixed because the correct value genuinely
+     * differs by host: a test harness driving a graph to completion should not wait five seconds per
+     * node, and a deployment running many short tasks may want tighter latency.
+     */
+    PollIntervalSeconds: number;
+    /** How often the reconciliation sweep runs. */
+    ReconciliationIntervalSeconds: number;
+};
+/** Defaults chosen so a heartbeat has several chances to land before a claim lapses. */
+export declare const DEFAULT_DISPATCHER_CONFIG: Omit<TaskGraphDispatcherConfig, 'InstanceID'>;
+/** Why a reconciliation sweep touched a task — logged loudly, never silently corrected. */
+export type ReconciliationAction = 'ExpiredClaimReleased' | 'OrphanedInProgressReleased' | 'StaleClaimCleared';
+/** One normalization the sweep performed. */
+export type ReconciliationEvent = {
+    TaskID: string;
+    Action: ReconciliationAction;
+    Detail: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,9 @@
+/** Defaults chosen so a heartbeat has several chances to land before a claim lapses. */
+export const DEFAULT_DISPATCHER_CONFIG = {
+    ClaimTTLSeconds: 300,
+    HeartbeatIntervalSeconds: 60,
+    MaxConcurrentTasks: 5,
+    PollIntervalSeconds: 5,
+    ReconciliationIntervalSeconds: 120,
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAmVA,wFAAwF;AACxF,MAAM,CAAC,MAAM,yBAAyB,GAAkD;IACpF,eAAe,EAAE,GAAG;IACpB,wBAAwB,EAAE,EAAE;IAC5B,kBAAkB,EAAE,CAAC;IACrB,mBAAmB,EAAE,CAAC;IACtB,6BAA6B,EAAE,GAAG;CACrC,CAAC"}

package/package.json

@@ -1,10 +1,38 @@
 {
   "name": "@memberjunction/task-graph",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @memberjunction/task-graph",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "type": "module",
+  "version": "6.1.0-edge.2",
+  "description": "MemberJunction: Task Graph - producer-agnostic submission and durable execution of dependency-ordered task graphs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "author": "MemberJunction.com",
+  "license": "ISC",
+  "dependencies": {
+    "@memberjunction/actions-base": "6.1.0-edge.2",
+    "@memberjunction/ai-agents": "6.1.0-edge.2",
+    "@memberjunction/ai-core-plus": "6.1.0-edge.2",
+    "@memberjunction/ai-prompts": "6.1.0-edge.2",
+    "@memberjunction/aiengine": "6.1.0-edge.2",
+    "@memberjunction/core": "6.1.0-edge.2",
+    "@memberjunction/core-entities": "6.1.0-edge.2",
+    "@memberjunction/global": "6.1.0-edge.2",
+    "@memberjunction/notifications": "6.1.0-edge.2"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.11",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/MJ"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias -f",
+    "watch": "tsc --watch",
+    "test": "vitest run"
+  }
+}