@memberjunction/server 5.37.0 → 5.39.0

package/src/resolvers/IntegrationProgressResolver.ts

@@ -0,0 +1,220 @@
+/**
+ * IntegrationProgressResolver — GraphQL subscription surface for long-running
+ * integration events (plan.md §11).
+ *
+ * Exposes a SINGLE @Subscription topic carrying structured progress notifications
+ * for every kind of integration run — metadata refresh, connector creation, sync,
+ * and RSU — so a UI can stream live updates instead of polling
+ * IntegrationTailRunEvents. Filtering by `runID`, `companyIntegrationID`, and `kind`
+ * happens in the subscription filter, exactly like PipelineProgressResolver.
+ *
+ * Wiring through the MJ event system: server-side producers (the
+ * IntegrationProgressEmitter, the connector-creation pipeline, the sync engine,
+ * the RSU pipeline) call the exported {@link PublishIntegrationProgress} helper,
+ * which forwards onto the same `PubSubManager` PubSub infrastructure that backs
+ * PipelineProgress and cache-invalidation events — NOT a parallel mechanism.
+ */
+import { Resolver, Subscription, Root, ObjectType, Field, Int, Arg } from 'type-graphql';
+import { LogError } from '@memberjunction/core';
+import type {
+    IntegrationRunKind,
+    IntegrationProgressEventType,
+    IntegrationProgressLevel,
+} from '@memberjunction/integration-progress-artifacts';
+import { PubSubManager } from '../generic/PubSubManager.js';
+
+/**
+ * The single PubSub topic all integration progress notifications ride. Mirrors
+ * PIPELINE_PROGRESS_TOPIC — one topic, filtered per-subscriber by run/connector/kind.
+ */
+export const INTEGRATION_PROGRESS_TOPIC = 'INTEGRATION_PROGRESS';
+
+/**
+ * Logical channels (the "topic enum" of plan.md §11) a subscriber can scope to.
+ * These map 1:1 onto a subset of {@link IntegrationRunKind} so a UI can subscribe
+ * to, e.g., only sync progress without parsing every notification. Expressed as a
+ * string union (per the union-types-over-enums convention) and surfaced over
+ * GraphQL as a plain String argument/field.
+ */
+export type IntegrationProgressTopic =
+    | 'MetadataRefresh'
+    | 'ConnectorCreation'
+    | 'Sync'
+    | 'RSU';
+
+/**
+ * Maps an {@link IntegrationRunKind} (the vocabulary the emitter writes) onto the
+ * coarser {@link IntegrationProgressTopic} channel a subscriber filters by. Kinds
+ * without a dedicated channel resolve to `undefined` and only match unscoped
+ * subscriptions.
+ */
+const RUN_KIND_TO_TOPIC: Readonly<Record<IntegrationRunKind, IntegrationProgressTopic | undefined>> = {
+    Discovery: 'MetadataRefresh',
+    Enrichment: 'MetadataRefresh',
+    ConnectorCreation: 'ConnectorCreation',
+    SyncRun: 'Sync',
+    RSU: 'RSU',
+    TableCreation: 'RSU',
+    Other: undefined,
+};
+
+/** Resolve the logical channel for a run kind (helper kept tiny + testable). */
+export function IntegrationProgressTopicForKind(kind: IntegrationRunKind): IntegrationProgressTopic | undefined {
+    return RUN_KIND_TO_TOPIC[kind];
+}
+
+/**
+ * A single integration progress notification pushed to the subscription topic.
+ * Carries the structured shape plan.md §11 asks for — the subsystem-specific
+ * `data` payload is serialized into `DataJSON` so the GraphQL field stays a scalar.
+ */
+@ObjectType()
+export class IntegrationProgressNotification {
+    /** The run this event belongs to (matches manifest.runID). */
+    @Field(() => String)
+    RunID: string;
+
+    /** The connector (CompanyIntegration) the run is for, when known. */
+    @Field(() => String, { nullable: true })
+    CompanyIntegrationID?: string;
+
+    /** What kind of run produced this event (IntegrationRunKind, as a string). */
+    @Field(() => String)
+    Kind: string;
+
+    /** The logical channel this notification belongs to (IntegrationProgressTopic). */
+    @Field(() => String, { nullable: true })
+    Topic?: string;
+
+    /** The progress event type (IntegrationProgressEventType, as a string). */
+    @Field(() => String)
+    EventType: string;
+
+    /** Monotonic sequence number within the run. */
+    @Field(() => Int)
+    Seq: number;
+
+    /** Free-form human message (optional). */
+    @Field(() => String, { nullable: true })
+    Message?: string;
+
+    /** Stage name within the run (optional). */
+    @Field(() => String, { nullable: true })
+    Stage?: string;
+
+    /** Severity level (info/warn/error/debug). */
+    @Field(() => String, { nullable: true })
+    Level?: string;
+
+    /** Subsystem-specific structured payload, JSON-serialized. */
+    @Field(() => String, { nullable: true })
+    DataJSON?: string;
+}
+
+/**
+ * Arguments the emitter/pipeline pass to {@link PublishIntegrationProgress}. The
+ * helper derives `Topic` and serializes `Data`, so callers pass the raw event shape.
+ */
+export interface PublishIntegrationProgressArgs {
+    RunID: string;
+    Kind: IntegrationRunKind;
+    EventType: IntegrationProgressEventType;
+    Seq: number;
+    CompanyIntegrationID?: string;
+    Message?: string;
+    Stage?: string;
+    Level?: IntegrationProgressLevel;
+    Data?: Record<string, unknown>;
+}
+
+/** Predicate used by the @Subscription filter — exported so it is unit-testable. */
+export function MatchesIntegrationSubscription(
+    payload: IntegrationProgressNotification,
+    args: { runID?: string; companyIntegrationID?: string; topic?: string }
+): boolean {
+    if (args.runID && payload.RunID !== args.runID) return false;
+    if (args.companyIntegrationID && payload.CompanyIntegrationID !== args.companyIntegrationID) return false;
+    if (args.topic && payload.Topic !== args.topic) return false;
+    return true;
+}
+
+/**
+ * Build the notification payload from publish args. Pure + side-effect free so the
+ * shape (including JSON serialization + topic derivation) can be asserted in tests
+ * without touching PubSub.
+ */
+export function BuildIntegrationProgressNotification(
+    args: PublishIntegrationProgressArgs
+): IntegrationProgressNotification {
+    return {
+        RunID: args.RunID,
+        CompanyIntegrationID: args.CompanyIntegrationID,
+        Kind: args.Kind,
+        Topic: IntegrationProgressTopicForKind(args.Kind),
+        EventType: args.EventType,
+        Seq: args.Seq,
+        Message: args.Message,
+        Stage: args.Stage,
+        Level: args.Level,
+        DataJSON: serializeData(args.Data),
+    };
+}
+
+/** JSON-serialize the subsystem payload, swallowing cyclic/serialization failures. */
+function serializeData(data?: Record<string, unknown>): string | undefined {
+    if (data == null) return undefined;
+    try {
+        return JSON.stringify(data);
+    } catch (e) {
+        LogError(`IntegrationProgressResolver: failed to serialize data payload: ${e}`);
+        return undefined;
+    }
+}
+
+/**
+ * Publish an integration progress event onto the subscription topic. This is the
+ * entry point server-side producers (IntegrationProgressEmitter, pipelines, sync
+ * engine, RSU) call to push live updates to subscribed clients. Uses the shared
+ * PubSubManager — the same infrastructure as PipelineProgress and cache events.
+ *
+ * Returns the published notification (handy for tests / logging); returns
+ * undefined and logs if publishing fails (never throws into the producer path).
+ */
+export function PublishIntegrationProgress(
+    args: PublishIntegrationProgressArgs
+): IntegrationProgressNotification | undefined {
+    try {
+        const notification = BuildIntegrationProgressNotification(args);
+        PubSubManager.Instance.Publish(INTEGRATION_PROGRESS_TOPIC, { ...notification });
+        return notification;
+    } catch (e) {
+        LogError(`PublishIntegrationProgress failed: ${e}`);
+        return undefined;
+    }
+}
+
+@Resolver()
+export class IntegrationProgressResolver {
+    /**
+     * Subscribe to integration progress notifications. With no arguments the
+     * subscriber receives every integration event on this server; pass any of
+     * `runID`, `companyIntegrationID`, or `topic` to scope the stream.
+     */
+    @Subscription(() => IntegrationProgressNotification, {
+        topics: INTEGRATION_PROGRESS_TOPIC,
+        filter: ({ payload, args }: {
+            payload: IntegrationProgressNotification;
+            args: { runID?: string; companyIntegrationID?: string; topic?: string };
+        }) => MatchesIntegrationSubscription(payload, args),
+    })
+    IntegrationProgress(
+        @Root() notification: IntegrationProgressNotification,
+        @Arg('runID', () => String, { nullable: true }) _runID?: string,
+        @Arg('companyIntegrationID', () => String, { nullable: true }) _companyIntegrationID?: string,
+        @Arg('topic', () => String, { nullable: true }) _topic?: string
+    ): IntegrationProgressNotification {
+        return notification;
+    }
+}
+
+export default IntegrationProgressResolver;

package/src/resolvers/MCPResolver.ts

@@ -7,7 +7,7 @@
 
 import { Resolver, Mutation, Query, Subscription, Arg, Ctx, Root, Field, Int, ObjectType, InputType, PubSub, registerEnumType } from 'type-graphql';
 import { PubSubEngine } from 'type-graphql';
-import { LogError, LogStatus, UserInfo, Metadata, RunView } from '@memberjunction/core';
+import { LogError, LogStatus, LogStatusEx, UserInfo, Metadata, RunView } from '@memberjunction/core';
 import {
     MCPClientManager,
     MCPSyncToolsResult,
@@ -705,25 +705,25 @@ export class MCPResolver extends ResolverBase {
 
         try {
             // Check API key scope authorization
-            LogStatus(`MCPResolver: [${ToolName}] Step 1 - Checking API key authorization...`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 1 - Checking API key authorization...`, verboseOnly: true });
             await this.CheckAPIKeyScopeAuthorization('mcp:execute', ConnectionID, ctx.userPayload);
-            LogStatus(`MCPResolver: [${ToolName}] Step 1 complete - Authorization passed (${Date.now() - startTime}ms)`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 1 complete - Authorization passed (${Date.now() - startTime}ms)`, verboseOnly: true });
 
             // Get the MCP client manager instance and ensure it's initialized
-            LogStatus(`MCPResolver: [${ToolName}] Step 2 - Initializing MCP client manager...`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 2 - Initializing MCP client manager...`, verboseOnly: true });
             const manager = MCPClientManager.Instance;
             const publicUrl = this.getPublicUrl();
             await manager.initialize(user, { publicUrl });
-            LogStatus(`MCPResolver: [${ToolName}] Step 2 complete - Manager initialized (${Date.now() - startTime}ms)`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 2 complete - Manager initialized (${Date.now() - startTime}ms)`, verboseOnly: true });
 
             // Connect if not already connected
             const isConnected = manager.isConnected(ConnectionID);
-            LogStatus(`MCPResolver: [${ToolName}] Step 3 - Connection status: ${isConnected ? 'already connected' : 'needs connection'}`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 3 - Connection status: ${isConnected ? 'already connected' : 'needs connection'}`, verboseOnly: true });
             if (!isConnected) {
                 LogStatus(`MCPResolver: [${ToolName}] Connecting to MCP server for connection ${ConnectionID}...`);
                 try {
                     await manager.connect(ConnectionID, { contextUser: user });
-                    LogStatus(`MCPResolver: [${ToolName}] Step 3 complete - Connected (${Date.now() - startTime}ms)`);
+                    LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 3 complete - Connected (${Date.now() - startTime}ms)`, verboseOnly: true });
                 } catch (connectError) {
                     // Check for OAuth authorization required
                     if (connectError instanceof OAuthAuthorizationRequiredError) {
@@ -763,12 +763,16 @@ export class MCPResolver extends ResolverBase {
             }
 
             // Parse input arguments
-            LogStatus(`MCPResolver: [${ToolName}] Step 4 - Parsing input arguments...`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 4 - Parsing input arguments...`, verboseOnly: true });
             let parsedArgs: Record<string, unknown> = {};
             if (InputArgs) {
                 try {
                     parsedArgs = JSON.parse(InputArgs);
-                    LogStatus(`MCPResolver: [${ToolName}] Parsed args: ${JSON.stringify(parsedArgs).substring(0, 200)}...`);
+                    if (configInfo.loggingSettings.graphql.logVariables) {
+                        LogStatus(`MCPResolver: [${ToolName}] Parsed args: ${JSON.stringify(parsedArgs)}`);
+                    } else {
+                        LogStatus(`MCPResolver: [${ToolName}] tool invoked`);
+                    }
                 } catch (parseError) {
                     LogError(`MCPResolver: [${ToolName}] Failed to parse InputArgs: ${parseError}`);
                     return {
@@ -777,18 +781,18 @@ export class MCPResolver extends ResolverBase {
                     };
                 }
             }
-            LogStatus(`MCPResolver: [${ToolName}] Step 4 complete - Args parsed (${Date.now() - startTime}ms)`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 4 complete - Args parsed (${Date.now() - startTime}ms)`, verboseOnly: true });
 
             // Call the tool
-            LogStatus(`MCPResolver: [${ToolName}] Step 5 - Calling tool on connection ${ConnectionID}...`);
-            LogStatus(`MCPResolver: [${ToolName}] Tool ID: ${ToolID}`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 5 - Calling tool on connection ${ConnectionID}...`, verboseOnly: true });
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Tool ID: ${ToolID}`, verboseOnly: true });
             const result: MCPToolCallResult = await manager.callTool(
                 ConnectionID,
                 ToolName,
                 { arguments: parsedArgs },
                 { contextUser: user }
             );
-            LogStatus(`MCPResolver: [${ToolName}] Step 5 complete - Tool call returned (${Date.now() - startTime}ms)`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 5 complete - Tool call returned (${Date.now() - startTime}ms)`, verboseOnly: true });
 
             // Format the result for the response - wrap in object for GraphQLJSONObject
             let formattedResult: Record<string, unknown> | null = null;
@@ -827,7 +831,7 @@ export class MCPResolver extends ResolverBase {
                 formattedResult = result.structuredContent as Record<string, unknown>;
             }
 
-            LogStatus(`MCPResolver: [${ToolName}] Step 6 complete - Result formatted (${Date.now() - startTime}ms)`);
+            LogStatusEx({ message: `MCPResolver: [${ToolName}] Step 6 complete - Result formatted (${Date.now() - startTime}ms)`, verboseOnly: true });
             LogStatus(`MCPResolver: [${ToolName}] Tool execution complete - Success: ${result.success}, Duration: ${result.durationMs}ms, Total time: ${Date.now() - startTime}ms`);
 
             return {

package/src/resolvers/QueryResolver.ts

@@ -1,9 +1,10 @@
 import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int, InputType } from 'type-graphql';
-import { RunQuery, QueryInfo, IRunQueryProvider, IMetadataProvider, RunQueryParams, LogError, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult } from '@memberjunction/core';
+import { RunQuery, IRunQueryProvider, IMetadataProvider, RunQueryParams, LogError, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { Metadata } from '@memberjunction/core';
+import { MJQueryEntity, QueryEngine } from '@memberjunction/core-entities';
 import { GetReadOnlyProvider } from '../util.js';
 import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 import { ResolverBase } from '../generic/ResolverBase.js';
@@ -149,9 +150,9 @@ export class RunQueriesWithCacheCheckOutput {
 
 @Resolver()
 export class RunQueryResolver extends ResolverBase {
-  private async findQuery(md: IMetadataProvider, QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
-    // Filter queries based on provided criteria
-    const queries = md.Queries.filter(q => {
+  private async findQuery(md: IMetadataProvider, QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<MJQueryEntity | null> {
+    const qe = QueryEngine.Instance;
+    const queries = qe.Queries.filter(q => {
       if (QueryID) {
         return q.ID.trim().toLowerCase() === QueryID.trim().toLowerCase();
       } else if (QueryName) {
@@ -169,8 +170,8 @@ export class RunQueryResolver extends ResolverBase {
 
     if (queries.length === 0) {
       if (refreshMetadataIfNotFound) {
-        // If we didn't find the query, refresh metadata and try again
-        await md.Refresh();
+        // If we didn't find the query, force-refresh QueryEngine and retry
+        await QueryEngine.Instance.Config(true);
         return this.findQuery(md, QueryID, QueryName, CategoryID, CategoryPath, false); // change the refresh flag to false so we don't loop infinitely
       } 
       else {

package/src/resolvers/QuerySystemUserResolver.ts

@@ -1,8 +1,8 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, RunView, UserInfo, CompositeKey, DatabaseProviderBase, LogStatus, QueryFieldInfo, QueryParameterInfo, QueryEntityInfo, QueryPermissionInfo } from '@memberjunction/core';
+import { LogError, UserInfo, CompositeKey, DatabaseProviderBase, LogStatus } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
-import { MJQueryCategoryEntity, MJQueryPermissionEntity } from '@memberjunction/core-entities';
+import { MJQueryCategoryEntity, MJQueryPermissionEntity, MJQueryFieldEntity, MJQueryParameterEntity, MJQueryEntityEntity, QueryEngine } from '@memberjunction/core-entities';
 import { MJQueryResolver, MJQuery_, MJQueryField_, MJQueryParameter_, MJQueryEntity_, MJQueryPermission_ } from '../generated/generated.js';
 import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
@@ -301,12 +301,9 @@ export class MJQueryResolverExtended extends MJQueryResolver {
 
                 if (input.Permissions && input.Permissions.length > 0) {
                     await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
-                    await record.RefreshRelatedMetadata(true); // force DB update since we just created new permissions
+
                 }
 
-                // Refresh metadata cache to include the newly created query
-                // This ensures subsequent operations can find the query without additional DB calls
-                await provider.Refresh();
 
                 return this.buildSuccessResult(record);
             }
@@ -365,7 +362,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
         };
     }
 
-    private mapFields(fields: QueryFieldInfo[]): MJQueryField_[] {
+    private mapFields(fields: MJQueryFieldEntity[]): MJQueryField_[] {
         return fields.map(f => ({
             ID: f.ID,
             QueryID: f.QueryID,
@@ -389,7 +386,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
         }) as MJQueryField_);
     }
 
-    private mapParameters(params: QueryParameterInfo[]): MJQueryParameter_[] {
+    private mapParameters(params: MJQueryParameterEntity[]): MJQueryParameter_[] {
         return params.map(p => ({
             ID: p.ID,
             QueryID: p.QueryID,
@@ -408,7 +405,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
         }) as MJQueryParameter_);
     }
 
-    private mapEntities(entities: QueryEntityInfo[]): MJQueryEntity_[] {
+    private mapEntities(entities: MJQueryEntityEntity[]): MJQueryEntity_[] {
         return entities.map(e => ({
             ID: e.ID,
             QueryID: e.QueryID,
@@ -422,7 +419,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
         }) as MJQueryEntity_);
     }
 
-    private mapPermissions(permissions: QueryPermissionInfo[]): MJQueryPermission_[] {
+    private mapPermissions(permissions: MJQueryPermissionEntity[]): MJQueryPermission_[] {
         return permissions.map(p => ({
             ID: p.ID,
             QueryID: p.QueryID,
@@ -528,25 +525,14 @@ export class MJQueryResolverExtended extends MJQueryResolver {
 
             // Handle permissions update if provided
             if (input.Permissions !== undefined) {
-                // Delete existing permissions
-                const rv = new RunView();
-                const existingPermissions = await rv.RunView<MJQueryPermissionEntity>({
-                    EntityName: 'MJ: Query Permissions',
-                    ExtraFilter: `QueryID='${queryID}'`,
-                    ResultType: 'entity_object'
-                }, context.userPayload.userRecord);
-
-                if (existingPermissions.Success && existingPermissions.Results) {
-                    for (const perm of existingPermissions.Results) {
-                        await perm.Delete();
-                    }
+                // Delete existing permissions (read from QueryEngine cache)
+                const existingPermissions = QueryEngine.Instance.GetQueryPermissions(queryID);
+                for (const perm of existingPermissions) {
+                    await perm.Delete();
                 }
 
                 // Create new permissions
                 await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
-                
-                // Refresh the metadata to get updated permissions
-                await queryEntity.RefreshRelatedMetadata(true);
             }
 
             return this.buildSuccessResult(queryEntity);

package/src/resolvers/RunAIAgentResolver.ts

@@ -9,6 +9,7 @@ import { AIEngine } from '@memberjunction/aiengine';
 import { ChatMessage, ChatMessageContent } from '@memberjunction/ai';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
+import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
 import { SafeJSONParse, UUIDsEqual } from '@memberjunction/global';
@@ -242,6 +243,13 @@ export class RunAIAgentResolver extends ResolverBase {
      */
     private createProgressCallback(pubSub: PubSubEngine, sessionId: string, userPayload: UserPayload, agentRunRef: { current: any }) {
         return (progress: any) => {
+            // Capture the agent run into the ref as soon as any progress event carries it (even
+            // "noise" steps), so the fire-and-forget liveness pulse can read its id/status mid-run
+            // rather than only after RunAgentInConversation returns.
+            if (progress.metadata?.agentRun) {
+                agentRunRef.current = progress.metadata.agentRun;
+            }
+
             // Only publish progress for significant steps (not initialization noise)
             const significantSteps = ['prompt_execution', 'action_execution', 'subagent_execution', 'decision_processing'];
             if (!significantSteps.includes(progress.step)) {
@@ -373,7 +381,10 @@ export class RunAIAgentResolver extends ResolverBase {
         sourceArtifactId?: string,
         sourceArtifactVersionId?: string,
         /** LATENCY OPT #2: Pre-resolved conversationId avoids redundant DB load in AgentRunner */
-        conversationId?: string
+        conversationId?: string,
+        /** Optional external ref the caller can read to observe the agent run as it becomes available
+         *  (used by the fire-and-forget liveness pulse to enrich heartbeats with the run id/status). */
+        runRef?: { current: MJAIAgentRunEntityExtended | null }
     ): Promise<AIAgentRunResult> {
         const startTime = Date.now();
         
@@ -407,8 +418,9 @@ export class RunAIAgentResolver extends ResolverBase {
             // singleton's transaction state with concurrent requests (e.g. conversation deletes).
             const agentRunner = new AgentRunner(p);
 
-            // Track agent run for streaming (use ref to update later)
-            const agentRunRef = { current: null as any };
+            // Track agent run for streaming (use ref to update later). Reuse the caller-supplied
+            // ref when provided so the fire-and-forget liveness pulse can observe the run.
+            const agentRunRef = runRef ?? { current: null as any };
 
             console.log(`🚀 Starting agent execution with sessionId: ${sessionId}`);
 
@@ -1225,12 +1237,23 @@ export class RunAIAgentResolver extends ResolverBase {
         /** LATENCY OPT #2: Pre-resolved conversationId avoids redundant DB load in AgentRunner */
         conversationId?: string
     ): void {
+        // Ref the liveness pulse reads to enrich heartbeats once the run is created.
+        const runRef: { current: MJAIAgentRunEntityExtended | null } = { current: null };
+        const pulse = startLivenessPulse({
+            pubSub,
+            sessionId,
+            resolver: 'RunAIAgentResolver',
+            readStatus: () => runRef.current
+                ? { runId: runRef.current.ID, status: runRef.current.Status }
+                : undefined,
+        });
+
         // Execute in background - errors are handled within, not propagated
         this.executeAIAgent(
             p, dataSource, agentId, userPayload, messagesJson, sessionId, pubSub,
             data, payload, undefined, lastRunId, autoPopulateLastRunPayload,
             configurationId, conversationDetailId, createArtifacts, createNotification,
-            sourceArtifactId, sourceArtifactVersionId, conversationId
+            sourceArtifactId, sourceArtifactVersionId, conversationId, runRef
         ).catch((error: unknown) => {
             // Background execution failed unexpectedly (executeAIAgent has its own try-catch,
             // so this would only fire for truly unexpected errors).
@@ -1249,7 +1272,7 @@ export class RunAIAgentResolver extends ResolverBase {
                 result: JSON.stringify({ success: false, errorMessage })
             };
             this.PublishStreamingUpdate(pubSub, errorCompletionData, userPayload);
-        });
+        }).finally(() => pulse.stop());
     }
 
     /**
@@ -1298,13 +1321,13 @@ export class RunAIAgentResolver extends ResolverBase {
         // Reverse to get chronological order (oldest first)
         const details = detailsResult.Results.reverse();
 
-        // Get all message IDs for batch loading attachments
+        // Get all message IDs for batch loading artifacts
         const messageIds = details.map(d => d.ID);
 
-        // Batch load all attachments for these messages
-        const attachmentsByDetailId = await attachmentService.GetAttachmentsBatch(messageIds, contextUser, provider);
-
-        // Batch load input artifacts for these messages
+        // Batch load input artifacts for these messages. Since the backfill migration
+        // (V202605271400__Backfill_Attachment_Artifacts) converted all legacy
+        // ConversationDetailAttachment rows to artifact pairs, the artifact junction
+        // is the single source of truth — no separate attachment query needed.
         const inputArtifactsByDetailId = await this.loadInputArtifactsBatch(messageIds, contextUser, provider);
 
         // Build ChatMessage array with attachments and input artifacts
@@ -1312,69 +1335,9 @@ export class RunAIAgentResolver extends ResolverBase {
 
         for (const detail of details) {
             const role = this.mapDetailRoleToMessageRole(detail.Role);
-            const attachments = attachmentsByDetailId.get(detail.ID) || [];
-
-            // Get attachment data with content URLs (handles both inline and FileID storage)
-            const attachmentDataPromises = attachments.map(att =>
-                attachmentService.GetAttachmentData(att, contextUser, provider)
-            );
-            const attachmentDataResults = await Promise.all(attachmentDataPromises);
-
-            // Decide inline vs. tools per-attachment via the artifact-type registry
-            // and the pure RouteArtifact() function. See plans/artifact-attachment-unification.md.
-            //
-            // Note on the modality check: this resolver doesn't know which model will
-            // ultimately run, so RouteArtifact's modality predicate is passed as a no-op.
-            // Model-specific modality enforcement is the driver layer's responsibility;
-            // a follow-up PR can thread the active model through here to surface modality
-            // mismatches at the hard-error path described in plan §4.
             const validAttachments: AttachmentData[] = [];
 
-            for (const result of attachmentDataResults) {
-                if (!result) continue;
-                // Storage-unified attachments link forward to their artifact version
-                // via ArtifactVersionID; the artifact path handles delivery, so skip
-                // the attachment row here to avoid double-processing.
-                if (result.attachment.ArtifactVersionID) {
-                    continue;
-                }
-                const mime = result.attachment.MimeType || '';
-                const fileName = result.attachment.FileName ?? '';
-                const ext = fileName.includes('.') ? fileName.split('.').pop() : undefined;
-                const artifactType = ArtifactMetadataEngine.Instance.GetArtifactTypeByMimeType(mime, ext);
-
-                const decision = RouteArtifact({
-                    typeDefault: artifactType?.DefaultDeliveryMode ?? 'ToolsOnly',
-                    forceToolsOnly: false,
-                    mimeType: mime,
-                    sizeBytes: result.attachment.FileSizeBytes ?? 0,
-                    inlineSizeCap: INLINE_SIZE_CAP,
-                    modelSupportsModality: () => true,
-                    modelName: '<resolver>',
-                    artifactTypeName: artifactType?.Name ?? mime,
-                });
-
-                if (decision.delivery !== 'inline') {
-                    // Tools or error: skip inline embedding. The agent reaches the
-                    // bytes via artifact tools. Driver layer handles modality enforcement.
-                    if (decision.delivery === 'tools' && decision.annotation) {
-                        LogStatus(`[RunAIAgentResolver] ${decision.annotation}`);
-                    }
-                    continue;
-                }
-                validAttachments.push({
-                    type: ConversationUtility.GetAttachmentTypeFromMime(result.attachment.MimeType),
-                    mimeType: result.attachment.MimeType,
-                    fileName: result.attachment.FileName ?? undefined,
-                    sizeBytes: result.attachment.FileSizeBytes ?? undefined,
-                    width: result.attachment.Width ?? undefined,
-                    height: result.attachment.Height ?? undefined,
-                    durationSeconds: result.attachment.DurationSeconds ?? undefined,
-                    content: result.contentUrl
-                });
-            }
-
-            // Get input artifacts for this message — same routing logic, plus ForceToolsOnly.
+            // Get input artifacts for this message — routing via RouteArtifact.
             const inputArtifacts = inputArtifactsByDetailId.get(detail.ID) || [];
             for (const artifactVersion of inputArtifacts) {
                 const artifactMime = artifactVersion.MimeType || '';

package/src/resolvers/RunTestResolver.ts

@@ -16,6 +16,7 @@ import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { TestEngine } from '@memberjunction/testing-engine';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
+import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult } from '@memberjunction/testing-engine-base';
 
 // ===== GraphQL Types =====
@@ -254,12 +255,17 @@ export class RunTestResolver extends ResolverBase {
         userPayload: UserPayload,
         user: UserInfo
     ): void {
+        // Keep-alive pulse so a long-running test never trips the client idle timeout.
+        // The client captures the testRunId from progress events for reconciliation.
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+
         this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user)
             .catch((error: unknown) => {
                 const errorMessage = (error instanceof Error) ? error.message : 'Unknown background test execution error';
                 LogError(`🔥 Fire-and-forget test execution failed: ${errorMessage}`, undefined, error);
                 this.publishFireAndForgetError(pubSub, userPayload, testId, errorMessage);
-            });
+            })
+            .finally(() => pulse.stop());
     }
 
     /**
@@ -343,6 +349,12 @@ export class RunTestResolver extends ResolverBase {
         userPayload: UserPayload,
         user: UserInfo
     ): void {
+        // Keep-alive pulse so a long-running suite never trips the client idle timeout.
+        // (Suite reconciliation isn't wired: suite progress carries the per-test run id, not the
+        // Test Suite Run id, so the client has no handle to reconcile against — the pulse is the
+        // protection here.)
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+
         this.executeSuite(
             suiteId, verbose, environment, parallel, tags, variables,
             selectedTestIds, sequenceStart, sequenceEnd, pubSub, userPayload, user
@@ -350,7 +362,7 @@ export class RunTestResolver extends ResolverBase {
             const errorMessage = (error instanceof Error) ? error.message : 'Unknown background suite execution error';
             LogError(`🔥 Fire-and-forget suite execution failed: ${errorMessage}`, undefined, error);
             this.publishFireAndForgetSuiteError(pubSub, userPayload, suiteId, errorMessage);
-        });
+        }).finally(() => pulse.stop());
     }
 
     // ===== Result Building =====