@memberjunction/server 5.28.0 → 5.29.0

package/src/resolvers/FileResolver.ts

@@ -368,9 +368,21 @@ export class FileResolver extends FileResolverBase {
     return { account, provider };
   }
 
+  /**
+   * Legacy file upload path — used by the `<mj-files-file-upload>` Angular component.
+   * Creates a File entity record in the database AND generates a pre-authenticated upload URL.
+   * The client then PUTs the file binary directly to that URL.
+   *
+   * Driver initialization: uses `buildUserContext()` (no storage account). The driver
+   * initializes from environment variables (e.g. STORAGE_AZURE_ACCOUNT_NAME, STORAGE_DROPBOX_ACCESS_TOKEN).
+   *
+   * Input: `ProviderID` identifies which storage provider to use.
+   * Returns: `{ File, UploadUrl, NameExists }` — the persisted File record, upload URL, and duplicate check.
+   *
+   * @see CreatePreAuthUploadUrl for the enterprise storage-account-based path (used by File Browser).
+   */
   @Mutation(() => CreateFilePayload)
   async CreateFile(@Arg('input', () => CreateMJFileInput) input: CreateMJFileInput, @Ctx() context: AppContext, @PubSub() pubSub: PubSubEngine) {
-    // Check to see if there's already an object with that name
     const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
@@ -389,12 +401,15 @@ export class FileResolver extends FileResolverBase {
 
     // Create the upload URL and get the record updates (provider key, content type, etc)
     const userContext = this.buildUserContext(context);
-    const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity, userContext);
+    const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity as unknown as { ID: string; Name: string; ProviderID: string; ContentType?: string; ProviderKey?: string }, userContext);
 
     // Save the file record with the updated input
     const mapper = new FieldMapper();
-    fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }), true, true);
-    await fileEntity.Save();
+    fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }), true, false);
+    const saved = await fileEntity.Save();
+    if (!saved) {
+      console.error('[CreateFile] File save failed:', fileEntity.LatestResult?.CompleteMessage);
+    }
     const File = mapper.MapFields({ ...fileEntity.GetAll() });
 
     return { File, UploadUrl, NameExists };
@@ -534,6 +549,20 @@ export class FileResolver extends FileResolverBase {
     return downloadUrl;
   }
 
+  /**
+   * Enterprise file upload path — used by the File Browser UI.
+   * Generates a pre-authenticated upload URL only (does NOT create a File entity record).
+   * The client handles the upload directly to the storage provider via the returned URL.
+   *
+   * Driver initialization: uses `buildExtendedUserContext()` with a FileStorageAccount entity.
+   * Credentials are loaded from the Credential Engine (encrypted in the database), with
+   * automatic token refresh for OAuth providers like Dropbox and Box.com.
+   *
+   * Input: `AccountID` identifies which storage account (and its linked provider/credentials) to use.
+   * Returns: `{ UploadUrl, ProviderKey }` — the pre-authenticated URL and optional provider key.
+   *
+   * @see CreateFile for the legacy path that also creates a File entity record.
+   */
   @Mutation(() => CreatePreAuthUploadUrlPayload)
   async CreatePreAuthUploadUrl(@Arg('input', () => CreatePreAuthUploadUrlInput) input: CreatePreAuthUploadUrlInput, @Ctx() context: AppContext) {
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });

package/src/resolvers/MCPResolver.ts

@@ -5,7 +5,7 @@
  * including tool synchronization with progress streaming and OAuth management.
  */
 
-import { Resolver, Mutation, Query, Subscription, Arg, Ctx, Root, Field, ObjectType, InputType, PubSub, registerEnumType } from 'type-graphql';
+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 {
@@ -455,6 +455,96 @@ export class MCPOAuthEventNotification {
     RequiresReauthorization?: boolean;
 }
 
+/**
+ * Summary of an MCP Server Tool record — only the fields needed for
+ * paginated card/list display. Heavy fields (InputSchema, OutputSchema,
+ * Annotations) are intentionally excluded to keep responses small.
+ */
+@ObjectType()
+export class MCPToolSummary {
+    @Field()
+    ID: string;
+
+    @Field()
+    MCPServerID: string;
+
+    @Field()
+    ToolName: string;
+
+    @Field({ nullable: true })
+    ToolTitle?: string;
+
+    @Field({ nullable: true })
+    ToolDescription?: string;
+
+    @Field()
+    Status: string;
+
+    /**
+     * MCP Server display name (from the vwMCPServerTools view — column name is "MCPServer").
+     */
+    @Field({ nullable: true })
+    ServerName?: string;
+}
+
+/**
+ * Paginated result for MCPToolSummary listings.
+ */
+@ObjectType()
+export class MCPToolPageResult {
+    @Field(() => [MCPToolSummary])
+    items: MCPToolSummary[];
+
+    @Field(() => Int)
+    totalCount: number;
+
+    @Field()
+    hasMore: boolean;
+}
+
+/**
+ * Count-per-server aggregate.
+ */
+@ObjectType()
+export class MCPToolServerCount {
+    @Field()
+    serverID: string;
+
+    @Field()
+    serverName: string;
+
+    @Field(() => Int)
+    count: number;
+}
+
+/**
+ * Count-per-category aggregate. Category is derived from the ToolName
+ * prefix (substring before first underscore).
+ */
+@ObjectType()
+export class MCPToolCategoryCount {
+    @Field()
+    category: string;
+
+    @Field(() => Int)
+    count: number;
+}
+
+/**
+ * Top-level counts payload for MCP tool group/badge displays.
+ */
+@ObjectType()
+export class MCPToolCountsResult {
+    @Field(() => Int)
+    totalCount: number;
+
+    @Field(() => [MCPToolServerCount])
+    countByServer: MCPToolServerCount[];
+
+    @Field(() => [MCPToolCategoryCount])
+    countByCategory: MCPToolCategoryCount[];
+}
+
 /**
  * MCP Resolver for GraphQL operations
  */
@@ -1325,6 +1415,212 @@ export class MCPResolver extends ResolverBase {
         };
     }
 
+    /**
+     * Returns a paginated list of MCP tool summaries filtered by optional
+     * server, category, and free-text search. Uses narrow Fields + simple
+     * ResultType to keep payload sizes manageable at thousands of tools.
+     *
+     * @param skip Number of rows to skip (for pagination)
+     * @param take Page size
+     * @param searchText Free-text filter against ToolName, ToolTitle, ToolDescription
+     * @param serverID Optional MCPServerID filter
+     * @param category Optional category filter (ToolName prefix before first underscore)
+     * @param ctx GraphQL context
+     */
+    @Query(() => MCPToolPageResult)
+    async GetMCPToolsPage(
+        @Arg('skip', () => Int) skip: number,
+        @Arg('take', () => Int) take: number,
+        @Arg('searchText', { nullable: true }) searchText: string | null,
+        @Arg('serverID', { nullable: true }) serverID: string | null,
+        @Arg('category', { nullable: true }) category: string | null,
+        @Ctx() ctx: AppContext
+    ): Promise<MCPToolPageResult> {
+        const user = ctx.userPayload.userRecord;
+        if (!user) {
+            return { items: [], totalCount: 0, hasMore: false };
+        }
+
+        try {
+            const extraFilter = this.buildMCPToolsFilter(searchText, serverID, category);
+            const rv = new RunView();
+
+            const result = await rv.RunView<{
+                ID: string;
+                MCPServerID: string;
+                ToolName: string;
+                ToolTitle: string | null;
+                ToolDescription: string | null;
+                Status: string;
+                MCPServer: string | null;
+            }>({
+                EntityName: 'MJ: MCP Server Tools',
+                ExtraFilter: extraFilter,
+                OrderBy: 'ToolName ASC',
+                Fields: ['ID', 'MCPServerID', 'ToolName', 'ToolTitle', 'ToolDescription', 'Status', 'MCPServer'],
+                StartRow: skip,
+                MaxRows: take,
+                IgnoreMaxRows: false,
+                ResultType: 'simple'
+            }, user);
+
+            if (!result.Success) {
+                LogError(`MCPResolver: GetMCPToolsPage failed: ${result.ErrorMessage}`);
+                return { items: [], totalCount: 0, hasMore: false };
+            }
+
+            const rows = result.Results || [];
+            // RunView's TotalRowCount can be capped when MaxRows is applied. Do an explicit
+            // count query (ignoring MaxRows) so the client sees the true filtered match total.
+            let totalCount = result.TotalRowCount ?? rows.length;
+            try {
+                const countResult = await rv.RunView<{ ID: string }>({
+                    EntityName: 'MJ: MCP Server Tools',
+                    ExtraFilter: extraFilter,
+                    Fields: ['ID'],
+                    IgnoreMaxRows: true,
+                    ResultType: 'simple'
+                }, user);
+                if (countResult.Success) {
+                    totalCount = countResult.Results.length;
+                }
+            } catch {
+                // fall back to the initial totalCount on any error
+            }
+            const items: MCPToolSummary[] = rows.map(r => ({
+                ID: r.ID,
+                MCPServerID: r.MCPServerID,
+                ToolName: r.ToolName,
+                ToolTitle: r.ToolTitle ?? undefined,
+                ToolDescription: r.ToolDescription ?? undefined,
+                Status: r.Status,
+                ServerName: r.MCPServer ?? undefined
+            }));
+
+            return {
+                items,
+                totalCount,
+                hasMore: skip + items.length < totalCount
+            };
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            LogError(`MCPResolver: GetMCPToolsPage exception: ${errorMsg}`);
+            return { items: [], totalCount: 0, hasMore: false };
+        }
+    }
+
+    /**
+     * Returns aggregate counts for MCP tools — total, per-server, and per-category
+     * (category = ToolName prefix before the first underscore). Used to render
+     * group headers with badges like "Zapier (1,247 tools)".
+     *
+     * @param serverID Optional MCPServerID filter (counts scoped to that server)
+     * @param searchText Optional free-text filter (same semantics as GetMCPToolsPage)
+     * @param ctx GraphQL context
+     */
+    @Query(() => MCPToolCountsResult)
+    async GetMCPToolCounts(
+        @Arg('serverID', { nullable: true }) serverID: string | null,
+        @Arg('searchText', { nullable: true }) searchText: string | null,
+        @Ctx() ctx: AppContext
+    ): Promise<MCPToolCountsResult> {
+        const user = ctx.userPayload.userRecord;
+        if (!user) {
+            return { totalCount: 0, countByServer: [], countByCategory: [] };
+        }
+
+        try {
+            // Build filter WITHOUT the category constraint — counts need the full
+            // matching set so we can bucket by server and by category ourselves.
+            const extraFilter = this.buildMCPToolsFilter(searchText, serverID, null);
+            const rv = new RunView();
+
+            // Fetch minimal fields for ALL matching rows. IgnoreMaxRows so we
+            // don't silently truncate at entity caps when counting.
+            const result = await rv.RunView<{
+                MCPServerID: string;
+                ToolName: string;
+                MCPServer: string | null;
+            }>({
+                EntityName: 'MJ: MCP Server Tools',
+                ExtraFilter: extraFilter,
+                Fields: ['MCPServerID', 'ToolName', 'MCPServer'],
+                IgnoreMaxRows: true,
+                ResultType: 'simple'
+            }, user);
+
+            if (!result.Success) {
+                LogError(`MCPResolver: GetMCPToolCounts failed: ${result.ErrorMessage}`);
+                return { totalCount: 0, countByServer: [], countByCategory: [] };
+            }
+
+            const rows = result.Results || [];
+            const totalCount = rows.length;
+
+            // Bucket by server
+            const serverMap = new Map<string, { serverID: string; serverName: string; count: number }>();
+            // Bucket by category (ToolName prefix before first underscore)
+            const categoryMap = new Map<string, number>();
+
+            for (const r of rows) {
+                const sid = r.MCPServerID;
+                const sname = r.MCPServer ?? '';
+                const existing = serverMap.get(sid);
+                if (existing) {
+                    existing.count++;
+                } else {
+                    serverMap.set(sid, { serverID: sid, serverName: sname, count: 1 });
+                }
+
+                const underscore = r.ToolName.indexOf('_');
+                const cat = underscore > 0 ? r.ToolName.substring(0, underscore) : r.ToolName;
+                categoryMap.set(cat, (categoryMap.get(cat) ?? 0) + 1);
+            }
+
+            const countByServer = Array.from(serverMap.values()).sort((a, b) => b.count - a.count);
+            const countByCategory = Array.from(categoryMap.entries())
+                .map(([category, count]) => ({ category, count }))
+                .sort((a, b) => b.count - a.count);
+
+            return { totalCount, countByServer, countByCategory };
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            LogError(`MCPResolver: GetMCPToolCounts exception: ${errorMsg}`);
+            return { totalCount: 0, countByServer: [], countByCategory: [] };
+        }
+    }
+
+    /**
+     * Builds the ExtraFilter string for MCP Server Tools queries. All user
+     * inputs are single-quote-escaped to prevent SQL injection.
+     */
+    private buildMCPToolsFilter(
+        searchText: string | null | undefined,
+        serverID: string | null | undefined,
+        category: string | null | undefined
+    ): string {
+        const clauses: string[] = [];
+
+        if (serverID && serverID.trim().length > 0) {
+            const safe = serverID.replace(/'/g, "''");
+            clauses.push(`MCPServerID='${safe}'`);
+        }
+
+        if (category && category.trim().length > 0) {
+            const safe = category.replace(/'/g, "''");
+            clauses.push(`ToolName LIKE '${safe}\\_%' ESCAPE '\\'`);
+        }
+
+        if (searchText && searchText.trim().length > 0) {
+            const safe = searchText.replace(/'/g, "''");
+            clauses.push(
+                `(ToolName LIKE '%${safe}%' OR ToolTitle LIKE '%${safe}%' OR ToolDescription LIKE '%${safe}%')`
+            );
+        }
+
+        return clauses.join(' AND ');
+    }
+
     /**
      * Gets the public URL for OAuth callbacks
      */

package/src/resolvers/RunAIAgentResolver.ts

@@ -2,7 +2,7 @@ import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubE
 import { AppContext, UserPayload } from '../types.js';
 import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo, IMetadataProvider } from '@memberjunction/core';
 import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity, MJConversationDetailArtifactEntity, MJArtifactVersionEntity, MJAIAgentRequestEntity } from '@memberjunction/core-entities';
-import { AgentRunner } from '@memberjunction/ai-agents';
+import { AgentRunner, ArtifactToolManager } from '@memberjunction/ai-agents';
 import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
 import { ChatMessage, ChatMessageContent } from '@memberjunction/ai';
@@ -1310,43 +1310,100 @@ export class RunAIAgentResolver extends ResolverBase {
             );
             const attachmentDataResults = await Promise.all(attachmentDataPromises);
 
-            // Filter out nulls and convert to AttachmentData format
-            const validAttachments: AttachmentData[] = attachmentDataResults
-                .filter((result): result is NonNullable<typeof result> => result !== null)
-                .map(result => ({
-                    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 and convert to AttachmentData
+            // Filter out nulls and convert to AttachmentData format.
+            // IMPORTANT: Skip large document attachments that are handled by artifact tools.
+            // These file types (PDF, Excel, Word) are accessible via ArtifactToolManager
+            // and embedding their multi-MB base64 content in the conversation causes
+            // context overflow on follow-up messages when conversation history is replayed.
+            // Images are kept inline since LLMs handle them natively via multimodal.
+            const ARTIFACT_TOOL_MIME_PREFIXES = [
+                'application/pdf',
+                'application/vnd.openxmlformats-officedocument', // .docx, .xlsx, .pptx
+                'application/vnd.ms-excel', // .xls
+                'application/msword', // .doc
+            ];
+
+            const validAttachments: AttachmentData[] = [];
+
+            for (const result of attachmentDataResults) {
+                if (!result) continue;
+                const mime = result.attachment.MimeType || '';
+                const isArtifactToolType = ARTIFACT_TOOL_MIME_PREFIXES.some(prefix => mime.startsWith(prefix));
+                if (isArtifactToolType) {
+                    // Skip raw file embedding — the agent accesses the file via
+                    // artifact tools (manifest injected into prompt) and/or native
+                    // file input (resolved per-driver in AIPromptRunner).
+                    // Do NOT add a placeholder attachment: 'Document' maps to 'file_url'
+                    // content blocks, and drivers attempt base64 decoding of the text,
+                    // causing API errors.
+                } else {
+                    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 and convert to AttachmentData.
+            // Like regular attachments above, skip file-backed artifacts whose MIME
+            // types are handled by ArtifactToolManager — embedding their multi-MB
+            // base64 content in every conversation replay causes context overflow.
             const inputArtifacts = inputArtifactsByDetailId.get(detail.ID) || [];
             for (const artifactVersion of inputArtifacts) {
+                const artifactMime = artifactVersion.MimeType || '';
+                const isArtifactToolHandled = ARTIFACT_TOOL_MIME_PREFIXES.some(
+                    prefix => artifactMime.startsWith(prefix)
+                );
+
                 if (artifactVersion.ContentMode === 'File' && artifactVersion.FileID) {
-                    // File-backed artifact — download content and treat like a document attachment
-                    const fileContent = await this.downloadArtifactFileContent(artifactVersion, contextUser, provider);
-                    if (fileContent) {
+                    if (isArtifactToolHandled) {
+                        // Skip raw file embedding — the agent accesses the file via
+                        // artifact tools (manifest injected into prompt) and/or native
+                        // file input (resolved per-driver in AIPromptRunner).
+                        // Do NOT add a placeholder attachment here: 'Document' maps to
+                        // 'file_url' content blocks, and drivers attempt base64 decoding
+                        // of the placeholder text, causing API errors.
+                    } else {
+                        // Non-artifact-tool file types: embed normally
+                        const fileContent = await this.downloadArtifactFileContent(artifactVersion, contextUser, provider);
+                        if (fileContent) {
+                            validAttachments.push({
+                                type: ConversationUtility.GetAttachmentTypeFromMime(artifactMime),
+                                mimeType: artifactMime || 'application/octet-stream',
+                                fileName: artifactVersion.FileName || artifactVersion.Name || undefined,
+                                sizeBytes: artifactVersion.ContentSizeBytes || undefined,
+                                content: fileContent
+                            });
+                        }
+                    }
+                } else if (artifactVersion.Content) {
+                    // Text artifact — use BuildInlinePreview for large DataSnapshots
+                    // to preserve table structure instead of raw substring truncation.
+                    const textContent = artifactVersion.Content;
+                    const MAX_INLINE_ARTIFACT_CHARS = 10_000;
+
+                    if (textContent.length > MAX_INLINE_ARTIFACT_CHARS) {
+                        const preview = ArtifactToolManager.BuildInlinePreview(textContent, 5);
+                        validAttachments.push({
+                            type: 'Document' as AttachmentData['type'],
+                            mimeType: 'text/plain',
+                            fileName: undefined,
+                            content: `[Artifact: ${artifactVersion.Name || 'Untitled'} — ${textContent.length.toLocaleString()} chars, accessible via artifact tools]\n\nPreview (first 5 rows per table):\n${preview}`
+                        });
+                    } else {
                         validAttachments.push({
-                            type: ConversationUtility.GetAttachmentTypeFromMime(artifactVersion.MimeType || ''),
-                            mimeType: artifactVersion.MimeType || 'application/octet-stream',
-                            fileName: artifactVersion.FileName || artifactVersion.Name || undefined,
-                            sizeBytes: artifactVersion.ContentSizeBytes || undefined,
-                            content: fileContent
+                            type: 'Document' as AttachmentData['type'],
+                            mimeType: 'text/plain',
+                            fileName: artifactVersion.Name || 'artifact.txt',
+                            content: `[Artifact: ${artifactVersion.Name || 'Untitled'}]\n\n${textContent}`
                         });
                     }
-                } else if (artifactVersion.Content) {
-                    // Text artifact — include content directly as a text attachment
-                    validAttachments.push({
-                        type: 'Document' as AttachmentData['type'],
-                        mimeType: 'text/plain',
-                        fileName: artifactVersion.Name || 'artifact.txt',
-                        content: `[Artifact: ${artifactVersion.Name || 'Untitled'}]\n\n${artifactVersion.Content}`
-                    });
                 }
             }