noverload-mcp 0.6.0-beta.1 → 0.7.0

package/dist/client.d.ts

@@ -6,55 +6,55 @@ export interface ClientConfig {
 }
 export declare const ContentSchema: z.ZodObject<{
     id: z.ZodString;
-    userId: z.ZodString;
+    userId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     url: z.ZodString;
-    title: z.ZodNullable<z.ZodString>;
-    description: z.ZodNullable<z.ZodString>;
-    contentType: z.ZodEnum<["youtube", "x_twitter", "reddit", "article", "pdf"]>;
-    status: z.ZodEnum<["pending", "processing", "completed", "failed"]>;
-    summary: z.ZodNullable<z.ZodAny>;
-    keyInsights: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contentType: z.ZodDefault<z.ZodOptional<z.ZodEnum<["youtube", "x_twitter", "reddit", "article", "pdf"]>>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["pending", "processing", "completed", "failed"]>>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    keyInsights: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>>;
     rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     tokenCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     ogImage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     processingMetadata: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    createdAt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    updatedAt: z.ZodDefault<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     userId: string;
     url: string;
-    title: string | null;
-    description: string | null;
     contentType: "youtube" | "x_twitter" | "reddit" | "article" | "pdf";
     status: "pending" | "processing" | "completed" | "failed";
     keyInsights: string[] | null;
+    tags: string[];
     createdAt: string;
     updatedAt: string;
+    title?: string | null | undefined;
+    description?: string | null | undefined;
     summary?: any;
     rawText?: string | null | undefined;
     tokenCount?: number | null | undefined;
     ogImage?: string | null | undefined;
     processingMetadata?: any;
-    tags?: string[] | undefined;
 }, {
     id: string;
-    userId: string;
     url: string;
-    title: string | null;
-    description: string | null;
-    contentType: "youtube" | "x_twitter" | "reddit" | "article" | "pdf";
-    status: "pending" | "processing" | "completed" | "failed";
-    keyInsights: string[] | null;
-    createdAt: string;
-    updatedAt: string;
+    userId?: string | undefined;
+    title?: string | null | undefined;
+    description?: string | null | undefined;
+    contentType?: "youtube" | "x_twitter" | "reddit" | "article" | "pdf" | undefined;
+    status?: "pending" | "processing" | "completed" | "failed" | undefined;
     summary?: any;
+    keyInsights?: string[] | null | undefined;
     rawText?: string | null | undefined;
     tokenCount?: number | null | undefined;
     ogImage?: string | null | undefined;
     processingMetadata?: any;
     tags?: string[] | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
 }>;
 export declare const ActionSchema: z.ZodObject<{
     id: z.ZodString;
@@ -145,6 +145,16 @@ export declare class NoverloadClient {
         dateTo?: string;
         excludeDomains?: string[];
         enableConceptExpansion?: boolean;
+        searchMode?: "any" | "all" | "phrase";
+        fuzzyMatch?: boolean;
+    }): Promise<any>;
+    private searchContentV1;
+    searchContentV2(params: {
+        query: string;
+        mode?: "smart" | "semantic" | "fulltext" | "any" | "all" | "phrase";
+        limit?: number;
+        contentTypes?: string[];
+        includeContent?: boolean;
     }): Promise<any>;
     estimateSearchTokens(query: string, limit?: number): Promise<any>;
     synthesizeContent(params: {
@@ -155,10 +165,12 @@ export declare class NoverloadClient {
         findConnections?: boolean;
         maxSources?: number;
     }): Promise<any>;
+    private synthesizeContentV1;
     findSimilarContent(contentId: string, options?: {
         limit?: number;
         minSimilarity?: number;
     }): Promise<any>;
     batchGetContent(ids: string[], includeFullContent?: boolean): Promise<any>;
+    getEnrichedContent(ids: string[], includeFullContent?: boolean): Promise<any>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

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

package/dist/client.js

@@ -1,22 +1,23 @@
 import { z } from "zod";
 // Schema definitions matching your Noverload database
+// Made more flexible to handle API variations
 export const ContentSchema = z.object({
     id: z.string(),
-    userId: z.string(),
+    userId: z.string().optional().default(""), // Made optional with default
     url: z.string(),
-    title: z.string().nullable(),
-    description: z.string().nullable(),
-    contentType: z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"]),
-    status: z.enum(["pending", "processing", "completed", "failed"]),
-    summary: z.any().nullable(), // Can be string or object
-    keyInsights: z.array(z.string()).nullable(),
+    title: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    contentType: z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"]).optional().default("article"),
+    status: z.enum(["pending", "processing", "completed", "failed"]).optional().default("completed"),
+    summary: z.any().nullable().optional(), // Can be string or object
+    keyInsights: z.array(z.string()).nullable().optional().default(null),
     rawText: z.string().nullable().optional(), // Full content text
     tokenCount: z.number().nullable().optional(), // Estimated token count for raw_text
     ogImage: z.string().nullable().optional(),
     processingMetadata: z.any().nullable().optional(),
-    tags: z.array(z.string()).optional(), // Associated tags
-    createdAt: z.string(),
-    updatedAt: z.string(),
+    tags: z.array(z.string()).optional().default([]), // Associated tags with default
+    createdAt: z.string().optional().default(() => new Date().toISOString()),
+    updatedAt: z.string().optional().default(() => new Date().toISOString()),
 });
 export const ActionSchema = z.object({
     id: z.string(),
@@ -109,8 +110,27 @@ export class NoverloadClient {
         }
         const data = await response.json();
         // v2 returns { success, contents, pagination }
-        const contents = data.contents || data;
-        return z.array(ContentSchema).parse(contents);
+        const rawContents = data.contents || data;
+        // Transform and validate each item with defaults for missing fields
+        const transformedContents = Array.isArray(rawContents) ? rawContents.map((item) => ({
+            id: item.id || item._id || "",
+            userId: item.userId || item.user_id || "",
+            url: item.url || "",
+            title: item.title || null,
+            description: item.description || null,
+            contentType: item.contentType || item.content_type || "article",
+            status: item.status || "completed",
+            summary: item.summary || null,
+            keyInsights: item.keyInsights || item.key_insights || null,
+            rawText: item.rawText || item.raw_text || null,
+            tokenCount: item.tokenCount || item.token_count || null,
+            ogImage: item.ogImage || item.og_image || null,
+            processingMetadata: item.processingMetadata || item.processing_metadata || null,
+            tags: item.tags || [],
+            createdAt: item.createdAt || item.created_at || new Date().toISOString(),
+            updatedAt: item.updatedAt || item.updated_at || new Date().toISOString(),
+        })) : [];
+        return z.array(ContentSchema).parse(transformedContents);
     }
     async getContent(id) {
         const response = await this.request(`/api/mcp/v2/content?id=${id}`);
@@ -136,8 +156,27 @@ export class NoverloadClient {
         }
         const data = await response.json();
         // v2 returns { success, content }
-        const content = data.content || data;
-        return ContentSchema.parse(content);
+        const rawContent = data.content || data;
+        // Transform with defaults for missing fields
+        const transformedContent = {
+            id: rawContent.id || rawContent._id || "",
+            userId: rawContent.userId || rawContent.user_id || "",
+            url: rawContent.url || "",
+            title: rawContent.title || null,
+            description: rawContent.description || null,
+            contentType: rawContent.contentType || rawContent.content_type || "article",
+            status: rawContent.status || "completed",
+            summary: rawContent.summary || null,
+            keyInsights: rawContent.keyInsights || rawContent.key_insights || null,
+            rawText: rawContent.rawText || rawContent.raw_text || null,
+            tokenCount: rawContent.tokenCount || rawContent.token_count || null,
+            ogImage: rawContent.ogImage || rawContent.og_image || null,
+            processingMetadata: rawContent.processingMetadata || rawContent.processing_metadata || null,
+            tags: rawContent.tags || [],
+            createdAt: rawContent.createdAt || rawContent.created_at || new Date().toISOString(),
+            updatedAt: rawContent.updatedAt || rawContent.updated_at || new Date().toISOString(),
+        };
+        return ContentSchema.parse(transformedContent);
     }
     async saveContent(url) {
         if (this.config.readOnly) {
@@ -211,83 +250,162 @@ export class NoverloadClient {
         return z.array(GoalSchema).parse(data);
     }
     async searchContent(query, options) {
-        // Use the enhanced search endpoint
-        const params = new URLSearchParams({
-            q: query,
-            limit: (options?.limit || 10).toString(),
-        });
-        if (options?.includeFullContent)
-            params.append("includeFullContent", "true");
-        if (options?.contentTypes)
-            params.append("contentTypes", options.contentTypes.join(","));
-        if (options?.dateFrom)
-            params.append("dateFrom", options.dateFrom);
-        if (options?.dateTo)
-            params.append("dateTo", options.dateTo);
-        if (options?.tags)
-            params.append("tags", options.tags.join(","));
-        if (options?.excludeDomains)
-            params.append("excludeDomains", options.excludeDomains.join(","));
-        if (options?.enableConceptExpansion)
-            params.append("enableConceptExpansion", "true");
-        // Convert to v2 search format
-        const v2Body = {
-            query,
-            mode: "smart",
-            filters: {
-                contentTypes: options?.contentTypes,
-                dateRange: {
-                    from: options?.dateFrom,
-                    to: options?.dateTo,
+        // Try v2 search first with better configuration
+        try {
+            const v2Body = {
+                query,
+                mode: "smart", // Use smart mode for better results
+                filters: options?.contentTypes || options?.tags || options?.dateFrom ? {
+                    contentTypes: options?.contentTypes,
+                    dateRange: (options?.dateFrom || options?.dateTo) ? {
+                        from: options?.dateFrom,
+                        to: options?.dateTo,
+                    } : undefined,
+                    tags: options?.tags,
+                    domains: options?.excludeDomains ? {
+                        exclude: options.excludeDomains,
+                    } : undefined,
+                } : undefined,
+                options: {
+                    limit: options?.limit || 10,
+                    includeContent: options?.includeFullContent || false,
+                    fuzzy: options?.fuzzyMatch !== false, // Default to true for broader matches
                 },
-                tags: options?.tags,
-                domains: {
-                    exclude: options?.excludeDomains,
+                features: {
+                    expandConcepts: options?.enableConceptExpansion !== false, // Default to true
+                    semanticSearch: true, // Enable semantic search by default
                 },
-            },
+            };
+            const response = await this.request(`/api/mcp/v2/search`, {
+                method: "POST",
+                body: JSON.stringify(v2Body),
+            });
+            if (!response.ok) {
+                // Fall back to v1 search if v2 fails
+                console.warn(`v2 search failed with status ${response.status}, trying v1 fallback`);
+                return this.searchContentV1(query, options);
+            }
+            const data = await response.json();
+            // v2 returns { success, query, results, pagination, metadata }
+            const results = data?.results || [];
+            if (Array.isArray(results) && results.length > 0) {
+                return results.map((item) => ({
+                    id: item.id || item._id || "",
+                    userId: item.userId || item.user_id || "",
+                    url: item.url || "",
+                    title: item.title || "Untitled",
+                    description: item.description || (typeof item.summary === 'string' ? item.summary.slice(0, 500) : ""),
+                    contentType: item.contentType || item.content_type || "article",
+                    status: item.status || item.metadata?.processingStatus || "completed",
+                    summary: item.summary || null,
+                    keyInsights: item.keyInsights || item.key_insights || [],
+                    rawText: item.rawText || item.raw_text || item.fullContent || null,
+                    tokenCount: item.tokenCount || item.token_count || null,
+                    ogImage: item.ogImage || item.og_image || null,
+                    processingMetadata: item.processingMetadata || item.processing_metadata || null,
+                    tags: item.tags || [],
+                    createdAt: item.createdAt || item.created_at || item.metadata?.createdAt || new Date().toISOString(),
+                    updatedAt: item.updatedAt || item.updated_at || item.metadata?.updatedAt || new Date().toISOString(),
+                    relevanceScore: item.relevanceScore || item.score || 0,
+                }));
+            }
+            // If no results, try a fallback search with looser parameters
+            if (results.length === 0 && !options?.includeFullContent) {
+                console.log("No results found, trying broader search...");
+                return this.searchContentV1(query, options);
+            }
+            return [];
+        }
+        catch (error) {
+            console.error("v2 search error:", error);
+            // Fall back to v1 search
+            return this.searchContentV1(query, options);
+        }
+    }
+    // Fallback v1 search method for compatibility
+    async searchContentV1(query, options) {
+        try {
+            const params = new URLSearchParams({
+                q: query,
+                limit: (options?.limit || 10).toString(),
+            });
+            if (options?.includeFullContent)
+                params.append("includeFullContent", "true");
+            if (options?.contentTypes)
+                params.append("contentTypes", options.contentTypes.join(","));
+            if (options?.tags)
+                params.append("tags", options.tags.join(","));
+            const response = await this.request(`/api/mcp/search?${params}`);
+            if (!response.ok) {
+                console.error(`v1 search also failed: ${response.status}`);
+                return [];
+            }
+            const data = await response.json();
+            const results = Array.isArray(data) ? data : (data.results || []);
+            return results.map((item) => ({
+                id: item.id || item._id || "",
+                userId: item.userId || item.user_id || "",
+                url: item.url || "",
+                title: item.title || "Untitled",
+                description: item.description || "",
+                contentType: item.contentType || item.content_type || "article",
+                status: item.status || "completed",
+                summary: item.summary || null,
+                keyInsights: item.keyInsights || item.key_insights || [],
+                rawText: item.rawText || item.raw_text || null,
+                tokenCount: item.tokenCount || item.token_count || null,
+                ogImage: item.ogImage || item.og_image || null,
+                processingMetadata: item.processingMetadata || item.processing_metadata || null,
+                tags: item.tags || [],
+                createdAt: item.createdAt || item.created_at || new Date().toISOString(),
+                updatedAt: item.updatedAt || item.updated_at || new Date().toISOString(),
+            }));
+        }
+        catch (error) {
+            console.error("v1 search error:", error);
+            return [];
+        }
+    }
+    // New v2 search method with enhanced features
+    async searchContentV2(params) {
+        const body = {
+            query: params.query,
+            mode: params.mode || "smart",
+            filters: params.contentTypes ? {
+                contentTypes: params.contentTypes,
+            } : undefined,
             options: {
-                limit: options?.limit || 10,
-                includeContent: options?.includeFullContent || false,
+                limit: params.limit || 10,
+                includeContent: params.includeContent || false,
+                fuzzy: true,
             },
             features: {
-                expandConcepts: options?.enableConceptExpansion || false,
+                expandConcepts: true,
+                semanticSearch: true,
             },
         };
         const response = await this.request(`/api/mcp/v2/search`, {
             method: "POST",
-            body: JSON.stringify(v2Body),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text().catch(() => "Unknown error");
-            console.error(`Search failed: ${response.status} - ${errorText}`);
-            throw new Error("Search failed");
+            // Fall back to v1 search if v2 fails
+            console.warn(`v2 search failed with status ${response.status}, trying v1 fallback`);
+            return this.searchContentV1(params.query, {
+                limit: params.limit,
+                contentTypes: params.contentTypes,
+                includeFullContent: params.includeContent,
+            });
         }
         const data = await response.json();
-        // v2 returns { success, query, results, pagination, metadata }
-        const results = data?.results || [];
-        if (Array.isArray(results)) {
-            return results.map((item) => ({
-                id: item.id,
-                userId: item.userId || "",
-                url: item.url || "",
-                title: item.title,
-                description: item.description || (typeof item.summary === 'string' ? item.summary.slice(0, 500) : ""),
-                contentType: item.contentType || "article",
-                status: item.metadata?.processingStatus || "completed",
-                summary: item.summary, // Keep the full summary object
-                keyInsights: item.keyInsights || [],
-                rawText: item.rawText || item.fullContent || null, // Check both fields
-                ogImage: item.ogImage || null,
-                processingMetadata: item.processingMetadata || null,
-                tags: item.tags || [], // Include tags
-                createdAt: item.metadata?.createdAt || item.createdAt || new Date().toISOString(),
-                updatedAt: item.metadata?.updatedAt || item.updatedAt || new Date().toISOString(),
-                // Include relevance score for better sorting
-                relevanceScore: item.relevanceScore,
+        // Map results to include aiInsights field
+        if (data.results) {
+            data.results = data.results.map((item) => ({
+                ...item,
+                aiInsights: item.ai_insights || item.aiInsights || item.processingMetadata?.ai_insights || {},
             }));
         }
-        console.warn("No results found in search response");
-        return [];
+        return data;
     }
     // New methods for enhanced endpoints
     async estimateSearchTokens(query, limit = 10) {
@@ -308,32 +426,104 @@ export class NoverloadClient {
         return data.estimate || data;
     }
     async synthesizeContent(params) {
-        // Convert to v2 synthesis format
-        const v2Body = {
-            sources: {
-                contentIds: params.contentIds,
-                query: params.contentIds ? undefined : params.query,
-                limit: params.maxSources,
-            },
-            synthesis: {
-                mode: params.synthesisMode || "actionable",
-                depth: "standard",
-            },
-            output: {
-                includeContradictions: params.findContradictions,
-                includeConnections: params.findConnections,
-                includeQuotes: true,
-                includeActionPlan: params.synthesisMode === "actionable",
-            },
-        };
-        const response = await this.request("/api/mcp/v2/synthesis", {
-            method: "POST",
-            body: JSON.stringify(v2Body),
-        });
-        if (!response.ok) {
-            throw new Error("Failed to synthesize content");
+        try {
+            // If no content IDs provided, search for relevant content first
+            let sourceIds = params.contentIds;
+            if (!sourceIds || sourceIds.length === 0) {
+                // Search for content related to the query
+                const searchResults = await this.searchContent(params.query, {
+                    limit: params.maxSources || 5,
+                    enableConceptExpansion: true,
+                });
+                if (searchResults && searchResults.length > 0) {
+                    sourceIds = searchResults.map((item) => item.id).filter((id) => id);
+                }
+                if (!sourceIds || sourceIds.length === 0) {
+                    return {
+                        success: false,
+                        error: "No content found to synthesize. Please save some content first or provide specific content IDs.",
+                        synthesis: null,
+                    };
+                }
+            }
+            // Try v2 synthesis endpoint
+            const v2Body = {
+                sources: {
+                    contentIds: sourceIds,
+                    limit: params.maxSources || 5,
+                },
+                synthesis: {
+                    mode: params.synthesisMode || "actionable",
+                    depth: "standard",
+                },
+                output: {
+                    includeContradictions: params.findContradictions || false,
+                    includeConnections: params.findConnections !== false, // Default true
+                    includeQuotes: true,
+                    includeActionPlan: params.synthesisMode === "actionable",
+                },
+            };
+            const response = await this.request("/api/mcp/v2/synthesis", {
+                method: "POST",
+                body: JSON.stringify(v2Body),
+            });
+            if (!response.ok) {
+                // Try fallback v1 synthesis
+                console.warn(`v2 synthesis failed with status ${response.status}, trying v1 fallback`);
+                return this.synthesizeContentV1(params, sourceIds);
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.error("Synthesis error:", error);
+            // Try v1 fallback
+            return this.synthesizeContentV1(params, params.contentIds);
+        }
+    }
+    // Fallback v1 synthesis method
+    async synthesizeContentV1(params, contentIds) {
+        try {
+            // If we don't have content IDs, we need to search first
+            if (!contentIds || contentIds.length === 0) {
+                const searchResults = await this.searchContent(params.query, {
+                    limit: params.maxSources || 5,
+                });
+                if (!searchResults || searchResults.length === 0) {
+                    return {
+                        success: false,
+                        error: "No content found to synthesize",
+                        synthesis: null,
+                    };
+                }
+                contentIds = searchResults.map((item) => item.id).filter((id) => id);
+            }
+            // Try a simpler synthesis approach
+            const response = await this.request("/api/mcp/synthesis", {
+                method: "POST",
+                body: JSON.stringify({
+                    query: params.query,
+                    contentIds: contentIds,
+                    mode: params.synthesisMode || "actionable",
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "Unknown error");
+                return {
+                    success: false,
+                    error: `Synthesis failed: ${errorText}`,
+                    synthesis: null,
+                };
+            }
+            return response.json();
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Synthesis error: ${error}`,
+                synthesis: null,
+            };
         }
-        return response.json();
     }
     async findSimilarContent(contentId, options) {
         const params = new URLSearchParams();
@@ -365,5 +555,41 @@ export class NoverloadClient {
         }
         return response.json();
     }
+    async getEnrichedContent(ids, includeFullContent = false) {
+        try {
+            const response = await this.request("/api/mcp/v2/content", {
+                method: "POST",
+                body: JSON.stringify({
+                    operation: "get",
+                    contentIds: ids,
+                    enrich: {
+                        includeContent: includeFullContent,
+                        includeActions: false,
+                        includeConcepts: false,
+                        includeRelated: false,
+                    },
+                    tokenOptions: {
+                        requireConfirmation: false, // We handle confirmation in the tool
+                    },
+                }),
+            });
+            if (!response.ok) {
+                console.error(`Get enriched content failed: ${response.status}`);
+                return [];
+            }
+            const data = await response.json();
+            // Handle confirmation requirement
+            if (data.requiresConfirmation) {
+                // For now, return empty - the tool will handle the warning
+                console.log("Content requires confirmation:", data.message);
+                return [];
+            }
+            return data.contents || [];
+        }
+        catch (error) {
+            console.error("Get enriched content error:", error);
+            return [];
+        }
+    }
 }
 //# sourceMappingURL=client.js.map