@memberjunction/server 5.35.0 → 5.37.0

package/src/agents/skip-agent.ts

@@ -358,13 +358,25 @@ export class SkipProxyAgent extends BaseAgent {
         const skipMessage = response.messages?.filter(msg => msg.role === 'system').pop();
         const analysisText = response.analysis?.trim();
 
+        // Skip-Brain attaches actionableCommands as an extension field on the
+        // analysis_complete response (e.g. `client:capture-data-snapshot` when
+        // the Analysis Agent needs the user's current view). Forward to the
+        // next step so AgentRunner persists them to ConversationDetail.ActionableCommands
+        // — which the chat UI's actionable-commands.component reads to render buttons.
+        const responseExt = response as unknown as { actionableCommands?: unknown[] };
+        const actionableCommands = Array.isArray(responseExt.actionableCommands) && responseExt.actionableCommands.length > 0
+            ? (responseExt.actionableCommands as BaseAgentNextStep<ComponentSpec>['actionableCommands'])
+            : undefined;
+        LogStatus(`[SkipProxyAgent DEBUG] handleAnalysisComplete actionableCommands from response: ${JSON.stringify(responseExt.actionableCommands)}`);
+
         if (!hasComponentOptions) {
             if (analysisText || skipMessage?.content) {
                 return {
                     terminate: true,
                     step: 'Success',
                     message: analysisText || skipMessage!.content,
-                    newPayload: undefined
+                    newPayload: undefined,
+                    actionableCommands
                 };
             }
 
@@ -387,7 +399,8 @@ export class SkipProxyAgent extends BaseAgent {
             terminate: true,
             step: 'Success',
             message: skipMessage?.content || response.title || 'Analysis complete',
-            newPayload: componentSpec
+            newPayload: componentSpec,
+            actionableCommands
         };
     }
 

package/src/agents/skip-sdk.ts

@@ -24,7 +24,8 @@ import {
     SkipAPIArtifactType
 } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
-import { IMetadataProvider, UserInfo, LogStatus, LogError, Metadata, RunQuery, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
+import { IMetadataProvider, UserInfo, LogStatus, LogError, Metadata, RunQuery, RunView, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
+import { MJConversationDetailEntity } from '@memberjunction/core-entities';
 import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { gzip as gzipCompress, createGunzip } from 'zlib';
@@ -682,6 +683,16 @@ export class SkipSDK {
                 versions: entry.versions
             }));
 
+            // Also include INPUT artifacts (e.g., user-captured Data Snapshots
+            // attached to messages via the Analyze button or
+            // client:capture-data-snapshot actionable command). The query above
+            // only returns Direction='Output' artifacts produced BY Skip — but
+            // Skip also needs to see artifacts the user gave it as input.
+            const inputArtifacts = await this.buildInputArtifacts(contextUser, conversationId, artifactMap);
+            if (inputArtifacts.length > 0) {
+                artifacts.push(...inputArtifacts);
+            }
+
             return artifacts;
         } catch (error) {
             LogError(`Failed to build artifacts for conversation ${conversationId}: ${error}`);
@@ -689,6 +700,142 @@ export class SkipSDK {
         }
     }
 
+    /**
+     * Fetch INPUT artifacts attached to user messages in this conversation
+     * (Direction='Input' on ConversationDetailArtifact). Skip should see these
+     * so it can use captured Data Snapshots, user-uploaded files, etc., in
+     * its analysis.
+     *
+     * Deduplicates against `alreadyLoaded` (the Output artifacts) so the same
+     * artifact ID doesn't appear twice if it was both produced and re-attached.
+     */
+    private async buildInputArtifacts(
+        contextUser: UserInfo,
+        conversationId: string,
+        alreadyLoaded: Map<string, { artifact: any; artifactType: SkipAPIArtifactType; versions: SkipAPIArtifactVersion[] }>
+    ): Promise<SkipAPIArtifact[]> {
+        try {
+            const rv = new RunView();
+            // Pull conversation detail IDs in this conversation
+            const detailsResult = await rv.RunView<MJConversationDetailEntity>({
+                EntityName: 'MJ: Conversation Details',
+                ExtraFilter: `ConversationID='${conversationId}'`,
+                Fields: ['ID'],
+                ResultType: 'simple',
+            }, contextUser);
+            const detailIds = detailsResult.Success && detailsResult.Results
+                ? (detailsResult.Results as { ID: string }[]).map(r => r.ID)
+                : [];
+            if (detailIds.length === 0) return [];
+
+            // Junction rows where Direction='Input' for those details
+            const junctionResult = await rv.RunView({
+                EntityName: 'MJ: Conversation Detail Artifacts',
+                ExtraFilter: `ConversationDetailID IN ('${detailIds.join("','")}') AND Direction='Input'`,
+                Fields: ['ArtifactVersionID', 'ConversationDetailID'],
+                ResultType: 'simple',
+            }, contextUser);
+            const junctions = junctionResult.Success && junctionResult.Results
+                ? (junctionResult.Results as { ArtifactVersionID: string; ConversationDetailID: string }[])
+                : [];
+            if (junctions.length === 0) return [];
+
+            // Load each ArtifactVersion + its parent Artifact + ArtifactType
+            const versionIds = [...new Set(junctions.map(j => j.ArtifactVersionID))];
+            const versionsResult = await rv.RunView({
+                EntityName: 'MJ: Artifact Versions',
+                ExtraFilter: `ID IN ('${versionIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const versions = versionsResult.Success && versionsResult.Results
+                ? (versionsResult.Results as Record<string, any>[])
+                : [];
+            if (versions.length === 0) return [];
+
+            const artifactIds = [...new Set(versions.map(v => v.ArtifactID as string))];
+            const artifactsResult = await rv.RunView({
+                EntityName: 'MJ: Artifacts',
+                ExtraFilter: `ID IN ('${artifactIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const artifactRows = artifactsResult.Success && artifactsResult.Results
+                ? (artifactsResult.Results as Record<string, any>[])
+                : [];
+
+            const typeIds = [...new Set(artifactRows.map(a => a.TypeID as string))];
+            const typesResult = await rv.RunView({
+                EntityName: 'MJ: Artifact Types',
+                ExtraFilter: `ID IN ('${typeIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const typeRows = typesResult.Success && typesResult.Results
+                ? (typesResult.Results as Record<string, any>[])
+                : [];
+            const typeMap = new Map<string, Record<string, any>>(typeRows.map(t => [t.ID as string, t]));
+
+            // Build a junction lookup: artifactVersionId -> conversationDetailId
+            const versionToDetail = new Map(junctions.map(j => [j.ArtifactVersionID, j.ConversationDetailID]));
+
+            // Build SkipAPIArtifact entries
+            const inputArtifactMap = new Map<string, { artifact: any; artifactType: SkipAPIArtifactType; versions: SkipAPIArtifactVersion[] }>();
+            for (const v of versions) {
+                const aRow = artifactRows.find(a => UUIDsEqual(a.ID, v.ArtifactID));
+                if (!aRow) continue;
+                if (alreadyLoaded.has(aRow.ID as string)) continue; // dedup
+
+                const typeRow = typeMap.get(aRow.TypeID as string);
+                if (!typeRow) continue;
+
+                let entry = inputArtifactMap.get(aRow.ID as string);
+                if (!entry) {
+                    entry = {
+                        artifact: {
+                            id: aRow.ID,
+                            conversationId,
+                            name: aRow.Name,
+                            description: aRow.Description || '',
+                            sharingScope: 'None',
+                            comments: aRow.Comments || '',
+                            createdAt: new Date(aRow.__mj_CreatedAt),
+                            updatedAt: new Date(aRow.__mj_UpdatedAt),
+                        },
+                        artifactType: {
+                            id: typeRow.ID,
+                            name: typeRow.Name,
+                            description: typeRow.Description,
+                            contentType: typeRow.ContentType,
+                            enabled: true,
+                            createdAt: new Date(typeRow.__mj_CreatedAt),
+                            updatedAt: new Date(typeRow.__mj_UpdatedAt),
+                        },
+                        versions: [],
+                    };
+                    inputArtifactMap.set(aRow.ID as string, entry);
+                }
+                entry.versions.push({
+                    id: v.ID,
+                    artifactId: v.ArtifactID,
+                    conversationDetailID: versionToDetail.get(v.ID) ?? '',
+                    version: v.VersionNumber,
+                    configuration: v.Configuration || '',
+                    content: v.Content || '',
+                    comments: v.Comments || '',
+                    createdAt: new Date(v.__mj_CreatedAt),
+                    updatedAt: new Date(v.__mj_UpdatedAt),
+                });
+            }
+
+            return Array.from(inputArtifactMap.values()).map(entry => ({
+                ...entry.artifact,
+                artifactType: entry.artifactType,
+                versions: entry.versions,
+            }));
+        } catch (error) {
+            LogError(`Failed to load input artifacts for conversation ${conversationId}: ${error}`);
+            return [];
+        }
+    }
+
     /**
      * Build API keys for AI services
      */

package/src/generated/generated.ts

@@ -21885,9 +21885,8 @@ export class MJArtifactUse_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
-    @Field({nullable: true}) 
-    @MaxLength(255)
-    ArtifactVersion?: string;
+    @Field(() => Int) 
+    ArtifactVersion: number;
         
     @Field() 
     @MaxLength(100)
@@ -22067,9 +22066,8 @@ export class MJArtifactVersionAttribute_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
-    @Field({nullable: true}) 
-    @MaxLength(255)
-    ArtifactVersion?: string;
+    @Field(() => Int) 
+    ArtifactVersion: number;
         
 }
 
@@ -23718,9 +23716,8 @@ export class MJCollectionArtifact_ {
     @MaxLength(255)
     Collection: string;
         
-    @Field({nullable: true}) 
-    @MaxLength(255)
-    ArtifactVersion?: string;
+    @Field(() => Int) 
+    ArtifactVersion: number;
         
 }
 
@@ -32690,9 +32687,8 @@ export class MJConversationDetailArtifact_ {
     @Field() 
     ConversationDetail: string;
         
-    @Field({nullable: true}) 
-    @MaxLength(255)
-    ArtifactVersion?: string;
+    @Field(() => Int) 
+    ArtifactVersion: number;
         
 }
 
@@ -32902,9 +32898,8 @@ export class MJConversationDetailAttachment_ {
     @MaxLength(500)
     File?: string;
         
-    @Field({nullable: true}) 
-    @MaxLength(255)
-    ArtifactVersion?: string;
+    @Field(() => Int, {nullable: true}) 
+    ArtifactVersion?: number;
         
 }
 
@@ -51945,6 +51940,27 @@ export class MJList_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field({nullable: true, description: `Optional ID of the User View this list was materialized from. NULL for hand-built lists. When set, the list can be refreshed against this view via ListOperations.RefreshFromSource.`}) 
+    @MaxLength(36)
+    SourceViewID?: string;
+        
+    @Field({nullable: true, description: `JSON snapshot of the source filter at materialization time. When UseSnapshot=1, refreshes re-apply this snapshot rather than re-reading the live source view. Null when no snapshot was captured.`}) 
+    SourceFilterSnapshot?: string;
+        
+    @Field({nullable: true, description: `Timestamp (UTC) of the most recent successful RefreshFromSource. Null when the list has never been refreshed.`}) 
+    LastRefreshedAt?: Date;
+        
+    @Field({nullable: true, description: `User who triggered the most recent successful RefreshFromSource. Null when the list has never been refreshed.`}) 
+    @MaxLength(36)
+    LastRefreshedByUserID?: string;
+        
+    @Field({description: `Default refresh mode for this list. Additive only adds new members; Sync reconciles in both directions (may remove members no longer in the source — requires explicit drop-confirmation).`}) 
+    @MaxLength(20)
+    RefreshMode: string;
+        
+    @Field(() => Boolean, {description: `When 1, RefreshFromSource uses SourceFilterSnapshot as the source. When 0 (default), it re-reads the live SourceView.`}) 
+    UseSnapshot: boolean;
+        
     @Field() 
     @MaxLength(255)
     Entity: string;
@@ -51961,6 +51977,14 @@ export class MJList_ {
     @MaxLength(255)
     CompanyIntegration?: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(100)
+    SourceView?: string;
+        
+    @Field({nullable: true}) 
+    @MaxLength(100)
+    LastRefreshedByUser?: string;
+        
     @Field(() => [MJDuplicateRun_])
     MJDuplicateRuns_SourceListIDArray: MJDuplicateRun_[]; // Link to MJDuplicateRuns
     
@@ -52004,6 +52028,24 @@ export class CreateMJListInput {
     @Field({ nullable: true })
     CompanyIntegrationID: string | null;
 
+    @Field({ nullable: true })
+    SourceViewID: string | null;
+
+    @Field({ nullable: true })
+    SourceFilterSnapshot: string | null;
+
+    @Field({ nullable: true })
+    LastRefreshedAt: Date | null;
+
+    @Field({ nullable: true })
+    LastRefreshedByUserID: string | null;
+
+    @Field({ nullable: true })
+    RefreshMode?: string;
+
+    @Field(() => Boolean, { nullable: true })
+    UseSnapshot?: boolean;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -52038,6 +52080,24 @@ export class UpdateMJListInput {
     @Field({ nullable: true })
     CompanyIntegrationID?: string | null;
 
+    @Field({ nullable: true })
+    SourceViewID?: string | null;
+
+    @Field({ nullable: true })
+    SourceFilterSnapshot?: string | null;
+
+    @Field({ nullable: true })
+    LastRefreshedAt?: Date | null;
+
+    @Field({ nullable: true })
+    LastRefreshedByUserID?: string | null;
+
+    @Field({ nullable: true })
+    RefreshMode?: string;
+
+    @Field(() => Boolean, { nullable: true })
+    UseSnapshot?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -76926,6 +76986,9 @@ export class MJUserView_ {
     @Field(() => [MJUserViewRun_])
     MJUserViewRuns_UserViewIDArray: MJUserViewRun_[]; // Link to MJUserViewRuns
     
+    @Field(() => [MJList_])
+    MJLists_SourceViewIDArray: MJList_[]; // Link to MJLists
+    
 }
 
 //****************************************************************************
@@ -77173,6 +77236,16 @@ export class MJUserViewResolverBase extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJList_])
+    async MJLists_SourceViewIDArray(@Root() mjuserview_: MJUserView_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Lists', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwLists')} WHERE ${provider.QuoteIdentifier('SourceViewID')}='${mjuserview_.ID}' ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Lists', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, undefined, undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Lists', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJUserView_)
     async CreateMJUserView(
         @Arg('input', () => CreateMJUserViewInput) input: CreateMJUserViewInput,
@@ -77579,6 +77652,9 @@ export class MJUser_ {
     @Field(() => [MJAIAgent_])
     MJAIAgents_OwnerUserIDArray: MJAIAgent_[]; // Link to MJAIAgents
     
+    @Field(() => [MJList_])
+    MJLists_LastRefreshedByUserIDArray: MJList_[]; // Link to MJLists
+    
 }
 
 //****************************************************************************
@@ -78714,6 +78790,16 @@ export class MJUserResolverBase extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJList_])
+    async MJLists_LastRefreshedByUserIDArray(@Root() mjuser_: MJUser_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Lists', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwLists')} WHERE ${provider.QuoteIdentifier('LastRefreshedByUserID')}='${mjuser_.ID}' ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Lists', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, undefined, undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Lists', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJUser_)
     async CreateMJUser(
         @Arg('input', () => CreateMJUserInput) input: CreateMJUserInput,

package/src/resolvers/AdhocQueryResolver.ts

@@ -1,8 +1,9 @@
 import { Arg, Ctx, Query, Resolver, Field, Int, InputType } from 'type-graphql';
-import { LogError } from '@memberjunction/core';
+import { DatabasePlatform, LogError } from '@memberjunction/core';
 import { SQLExpressionValidator } from '@memberjunction/global';
+import { RenderPipeline } from '@memberjunction/generic-database-provider';
 import { AppContext } from '../types.js';
-import { GetReadOnlyDataSource } from '../util.js';
+import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { RunQueryResultType } from './QueryResolver.js';
 import sql from 'mssql';
@@ -18,6 +19,12 @@ class AdhocQueryInput {
 
     @Field(() => Int, { nullable: true, description: 'Query timeout in seconds. Defaults to 30.' })
     TimeoutSeconds?: number;
+
+    @Field(() => Int, { nullable: true, description: 'Maximum number of rows to return; applied at the database via the render pipeline.' })
+    MaxRows?: number;
+
+    @Field(() => Int, { nullable: true, description: 'Zero-based offset for pagination. When > 0, the row cap switches to OFFSET/FETCH pagination.' })
+    StartRow?: number;
 }
 
 /**
@@ -56,28 +63,68 @@ export class AdhocQueryResolver extends ResolverBase {
                 return this.buildErrorResult('No read-only data source available for ad-hoc query execution');
             }
 
-            // 3. Execute with timeout
+            // 3. Resolve platform from the read-only provider for the render pipeline.
+            let platform: DatabasePlatform = 'sqlserver';
+            try {
+                const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: false });
+                if (provider?.PlatformKey) platform = provider.PlatformKey;
+            } catch {
+                // Provider not configured — keep the default platform.
+            }
+            const contextUser = context.userPayload?.userRecord;
+
+            // 4. Route the SQL through RenderPipeline so composition tokens
+            // resolve, comments and templates are processed, and the row cap
+            // is applied at the database (via TOP / LIMIT / OFFSET-FETCH).
+            const startRow = input.StartRow ?? 0;
+            const maxRows = input.MaxRows;
+            const usePaging =
+                maxRows != null &&
+                Number.isInteger(maxRows) &&
+                maxRows > 0 &&
+                Number.isInteger(startRow) &&
+                startRow > 0;
+            let executableSql: string;
+            try {
+                const rendered = RenderPipeline.Run(input.SQL, {
+                    Platform: platform,
+                    ContextUser: contextUser,
+                    ...(usePaging
+                        ? { Paging: { StartRow: startRow, MaxRows: maxRows! } }
+                        : maxRows != null && maxRows > 0
+                            ? { MaxRows: maxRows }
+                            : {}),
+                });
+                executableSql = rendered.FinalSQL;
+            } catch (renderErr) {
+                const renderMsg = renderErr instanceof Error ? renderErr.message : String(renderErr);
+                return this.buildErrorResult(`Ad-hoc query rendering failed: ${renderMsg}`);
+            }
+
+            // 5. Execute with timeout
             const timeoutMs = (input.TimeoutSeconds ?? 30) * 1000;
             const request = new sql.Request(readOnlyDS);
 
             const result = await Promise.race([
-                request.query(input.SQL),
+                request.query(executableSql),
                 new Promise<never>((_, reject) =>
                     setTimeout(() => reject(new Error('Query timeout exceeded')), timeoutMs)
                 )
             ]);
             const executionTimeMs = Date.now() - startTime;
 
-            // 4. Return as RunQueryResultType
+            // 6. Return as RunQueryResultType
+            const recordset = result.recordset ?? [];
+
             return {
                 QueryID: '',
                 QueryName: 'Ad-Hoc Query',
                 Success: true,
-                Results: JSON.stringify(result.recordset ?? []),
-                RowCount: result.recordset?.length ?? 0,
-                TotalRowCount: result.recordset?.length ?? 0,
-                PageNumber: undefined,
-                PageSize: undefined,
+                Results: JSON.stringify(recordset),
+                RowCount: recordset.length,
+                TotalRowCount: recordset.length,
+                PageNumber: maxRows != null && maxRows > 0 ? Math.floor(startRow / maxRows) + 1 : undefined,
+                PageSize: maxRows ?? undefined,
                 ExecutionTime: executionTimeMs,
                 ErrorMessage: ''
             };