notebooklm-mcp-ultimate 2.3.1 → 2.3.2

package/dist/tools/handlers/source-handlers.d.ts

@@ -1,12 +1,12 @@
 /**
  * Source Management Tool Handlers
  *
- * Implements handlers for source management tools.
+ * Browser-only implementations for source management.
+ * Only addDriveSource uses API (requires Drive picker).
  */
 import type { NotebookLibrary } from '../../library/notebook-library.js';
 import type { SessionManager } from '../../session/session-manager.js';
 import type { ProgressCallback } from '../../types.js';
-import * as sourceOps from '../../operations/source-operations.js';
 /**
  * Dependencies for source handlers
  */
@@ -24,50 +24,116 @@ export type SourceHandlers = ReturnType<typeof createSourceHandlers>;
 export declare function createSourceHandlers(deps: SourceHandlerDependencies): {
     handleListSources: (args: {
         notebook_id?: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult | {
+    }, sendProgress?: ProgressCallback) => Promise<{
+        success: boolean;
+        error: string;
+        notebookId?: undefined;
+        sources?: undefined;
+        method?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        notebookId: string | null;
+        sources?: undefined;
+        method?: undefined;
+    } | {
         success: boolean;
         sources: {
             title: string;
             id: string | undefined;
         }[];
         method: string;
+        notebookId: string | null;
+        error?: undefined;
     }>;
     handleAddURLSource: (args: {
         notebook_id?: string;
         url: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult | {
+    }, sendProgress?: ProgressCallback) => Promise<{
         success: boolean;
-        notebookId: string;
+        error: string;
+        notebookId: string | null;
+        method?: undefined;
+    } | {
+        success: boolean;
+        notebookId: string | null;
         method: string;
+        error?: undefined;
     }>;
     handleAddTextSource: (args: {
         notebook_id?: string;
         title: string;
         content: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult | {
+    }, sendProgress?: ProgressCallback) => Promise<{
+        success: boolean;
+        error: string;
+        notebookId: string | null;
+        method?: undefined;
+    } | {
         success: boolean;
-        notebookId: string;
+        notebookId: string | null;
         method: string;
+        error?: undefined;
     }>;
     handleAddYouTubeSource: (args: {
         notebook_id?: string;
         youtube_url: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult | {
+    }, sendProgress?: ProgressCallback) => Promise<{
         success: boolean;
-        notebookId: string;
+        error: string;
+        notebookId: string | null;
+        method?: undefined;
+    } | {
+        success: boolean;
+        notebookId: string | null;
         method: string;
+        error?: undefined;
     }>;
     handleAddDriveSource: (args: {
         notebook_id?: string;
         file_id: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult>;
+    }, sendProgress?: ProgressCallback) => Promise<{
+        notebookId: string | null;
+        success: boolean;
+        sources?: import("../../api/types.js").APISource[];
+        source?: import("../../api/types.js").APISource;
+        sourceId?: string;
+        error?: string;
+    }>;
     handleDeleteSource: (args: {
         notebook_id?: string;
         source_id: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult>;
+    }, sendProgress?: ProgressCallback) => Promise<{
+        success: boolean;
+        error: string;
+        notebookId: string | undefined;
+        method?: undefined;
+    } | {
+        success: boolean;
+        notebookId: string | undefined;
+        method: string;
+        error?: undefined;
+    }>;
     handleSummarizeSource: (args: {
         notebook_id?: string;
         source_id: string;
-    }, sendProgress?: ProgressCallback) => Promise<sourceOps.SourceOperationResult>;
+    }, sendProgress?: ProgressCallback) => Promise<{
+        success: boolean;
+        error: string;
+        notebookId: string | undefined;
+        source?: undefined;
+        method?: undefined;
+    } | {
+        success: boolean;
+        source: {
+            title: string;
+            type?: string;
+            addedDate?: string;
+            summary?: string;
+        };
+        notebookId: string | undefined;
+        method: string;
+        error?: undefined;
+    }>;
 };
 //# sourceMappingURL=source-handlers.d.ts.map

package/dist/tools/handlers/source-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-handlers.d.ts","sourceRoot":"","sources":["../../../src/tools/handlers/source-handlers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,SAAS,MAAM,uCAAuC,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,eAAe,CAAC;IACzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAErE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,yBAAyB;8BA+BtD;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,iBACf,gBAAgB;;;;;;;;+BAyDzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,iBAC5B,gBAAgB;;;;;gCAoDzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,iBAC/C,gBAAgB;;;;;mCAwDzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,iBACpC,gBAAgB;;;;;iCAoDzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,iBAChC,gBAAgB;+BA2BzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,iBAClC,gBAAgB;kCA2BzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,iBAClC,gBAAgB;EAgCtC"}
+{"version":3,"file":"source-handlers.d.ts","sourceRoot":"","sources":["../../../src/tools/handlers/source-handlers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIvD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,eAAe,CAAC;IACzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAErE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,yBAAyB;8BAwEtD;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,iBACf,gBAAgB;;;;;;;;;;;;;;;;;;;;;;+BA6CzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,iBAC5B,gBAAgB;;;;;;;;;;;gCAmCzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,iBAC/C,gBAAgB;;;;;;;;;;;mCAmCzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,iBACpC,gBAAgB;;;;;;;;;;;iCAmCzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,iBAChC,gBAAgB;;;;;;;;+BAyBzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,iBAClC,gBAAgB;;;;;;;;;;;kCA6CzB;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,iBAClC,gBAAgB;;;;;;;;;;;;;;;;;;EAwDtC"}

package/dist/tools/handlers/source-handlers.js

@@ -1,7 +1,8 @@
 /**
  * Source Management Tool Handlers
  *
- * Implements handlers for source management tools.
+ * Browser-only implementations for source management.
+ * Only addDriveSource uses API (requires Drive picker).
  */
 import { log } from '../../utils/logger.js';
 import * as sourceOps from '../../operations/source-operations.js';
@@ -11,261 +12,293 @@ import * as sourceOps from '../../operations/source-operations.js';
 export function createSourceHandlers(deps) {
     const { library, sessionManager } = deps;
     /**
-     * Build notebook URL from ID
+     * UUID regex pattern
      */
-    function buildNotebookUrl(notebookId) {
-        return `https://notebooklm.google.com/notebook/${notebookId}`;
+    const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    /**
+     * Extract notebook UUID from URL
+     */
+    function extractUuidFromUrl(url) {
+        const match = url.match(/\/notebook\/([0-9a-f-]{36})/i);
+        return match ? match[1] : null;
     }
     /**
-     * Get notebook ID, using active notebook if not specified
+     * Resolve notebook to full URL (browser needs full URL)
      */
-    function resolveNotebookId(notebookId) {
+    function resolveNotebookUrl(notebookId) {
+        // If UUID provided directly, build URL
+        if (notebookId && UUID_PATTERN.test(notebookId)) {
+            return `https://notebooklm.google.com/notebook/${notebookId}`;
+        }
+        // Get notebook from library (by alias or active)
+        const notebook = notebookId
+            ? library.getNotebook(notebookId)
+            : library.getActiveNotebook();
+        if (!notebook) {
+            log.warning('No notebook specified and no active notebook selected');
+            return null;
+        }
+        return notebook.url;
+    }
+    /**
+     * Get notebook alias for user-facing responses
+     */
+    function resolveNotebookAlias(notebookId) {
         if (notebookId) {
+            const notebook = library.getNotebook(notebookId);
+            return notebook?.id || notebookId;
+        }
+        return library.getActiveNotebook()?.id || null;
+    }
+    /**
+     * Resolve notebook ID to UUID (for API calls)
+     */
+    function resolveNotebookUuid(notebookId) {
+        if (notebookId && UUID_PATTERN.test(notebookId)) {
             return notebookId;
         }
-        const activeNotebook = library.getActiveNotebook();
-        if (!activeNotebook) {
-            log.warning('⚠️  No notebook specified and no active notebook selected');
+        const notebook = notebookId
+            ? library.getNotebook(notebookId)
+            : library.getActiveNotebook();
+        if (!notebook) {
             return null;
         }
-        return activeNotebook.id;
+        return extractUuidFromUrl(notebook.url);
     }
     /**
-     * Handle list_sources tool
+     * Handle list_sources tool (browser-only)
      */
     async function handleListSources(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl) {
             return {
                 success: false,
                 error: 'No notebook specified and no active notebook selected',
             };
         }
-        if (sendProgress) {
-            await sendProgress('📚 Listing sources...');
+        if (!sessionManager) {
+            return {
+                success: false,
+                error: 'Browser session manager not available',
+                notebookId: notebookAlias,
+            };
         }
-        // Try API first
-        const result = await sourceOps.listSources(notebookId);
-        // Fallback to browser if API fails and sessionManager available
-        if (!result.success && sessionManager) {
-            log.warning('⚠️  API failed, falling back to browser automation...');
-            if (sendProgress) {
-                await sendProgress('🔄 API failed, trying browser automation...');
-            }
-            try {
-                const notebookUrl = buildNotebookUrl(notebookId);
-                const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
-                const sources = await session.listSourcesViaUI();
-                log.success(`✅ Found ${sources.length} sources via browser automation`);
-                if (sendProgress) {
-                    await sendProgress(`✅ Found ${sources.length} sources via browser`);
-                }
-                return {
-                    success: true,
-                    sources: sources.map(s => ({
-                        title: s.title,
-                        id: s.id,
-                    })),
-                    method: 'browser',
-                };
-            }
-            catch (browserError) {
-                log.error(`❌ Browser fallback failed: ${browserError}`);
-            }
+        if (sendProgress)
+            await sendProgress('Listing sources via browser...');
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            const sources = await session.listSourcesViaUI();
+            log.success(`Found ${sources.length} sources via browser`);
+            if (sendProgress)
+                await sendProgress(`Found ${sources.length} sources`);
+            return {
+                success: true,
+                sources: sources.map(s => ({ title: s.title, id: s.id })),
+                method: 'browser',
+                notebookId: notebookAlias,
+            };
         }
-        if (result.success && sendProgress) {
-            await sendProgress(`✅ Found ${result.sources?.length || 0} sources`);
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias };
         }
-        return result;
     }
     /**
-     * Handle add_url_source tool
+     * Handle add_url_source tool (browser-only)
      */
     async function handleAddURLSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl || !sessionManager) {
             return {
                 success: false,
-                error: 'No notebook specified and no active notebook selected',
+                error: !notebookUrl ? 'No notebook specified' : 'Browser session not available',
+                notebookId: notebookAlias,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`🔗 Adding URL source: ${args.url}`);
-        }
-        // Try API first
-        const result = await sourceOps.addURLSource(notebookId, args.url);
-        // Fallback to browser if API fails and sessionManager available
-        if (!result.success && sessionManager) {
-            log.warning('⚠️  API failed, falling back to browser automation...');
-            if (sendProgress) {
-                await sendProgress('🔄 API failed, trying browser automation...');
-            }
-            try {
-                const notebookUrl = buildNotebookUrl(notebookId);
-                const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
-                const browserSuccess = await session.addURLSourceViaUI(args.url);
-                if (browserSuccess) {
-                    log.success('✅ URL source added via browser automation');
-                    if (sendProgress) {
-                        await sendProgress('✅ URL source added via browser');
-                    }
-                    return { success: true, notebookId, method: 'browser' };
-                }
-            }
-            catch (browserError) {
-                log.error(`❌ Browser fallback failed: ${browserError}`);
+        if (sendProgress)
+            await sendProgress(`Adding URL source: ${args.url}`);
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            const success = await session.addURLSourceViaUI(args.url);
+            if (success) {
+                log.success('URL source added via browser');
+                if (sendProgress)
+                    await sendProgress('URL source added');
+                return { success: true, notebookId: notebookAlias, method: 'browser' };
             }
+            return { success: false, error: 'Browser failed to add URL source', notebookId: notebookAlias };
         }
-        if (result.success && sendProgress) {
-            await sendProgress('✅ URL source added successfully');
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias };
         }
-        return result;
     }
     /**
-     * Handle add_text_source tool
+     * Handle add_text_source tool (browser-only)
      */
     async function handleAddTextSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl || !sessionManager) {
             return {
                 success: false,
-                error: 'No notebook specified and no active notebook selected',
+                error: !notebookUrl ? 'No notebook specified' : 'Browser session not available',
+                notebookId: notebookAlias,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`📝 Adding text source: ${args.title}`);
-        }
-        // Try API first
-        const result = await sourceOps.addTextSource(notebookId, args.title, args.content);
-        // Fallback to browser if API fails and sessionManager available
-        if (!result.success && sessionManager) {
-            log.warning('⚠️  API failed, falling back to browser automation...');
-            if (sendProgress) {
-                await sendProgress('🔄 API failed, trying browser automation...');
-            }
-            try {
-                const notebookUrl = buildNotebookUrl(notebookId);
-                const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
-                const browserSuccess = await session.addTextSourceViaUI(args.title, args.content);
-                if (browserSuccess) {
-                    log.success('✅ Text source added via browser automation');
-                    if (sendProgress) {
-                        await sendProgress('✅ Text source added via browser');
-                    }
-                    return { success: true, notebookId, method: 'browser' };
-                }
-            }
-            catch (browserError) {
-                log.error(`❌ Browser fallback failed: ${browserError}`);
+        if (sendProgress)
+            await sendProgress(`Adding text source: ${args.title}`);
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            const success = await session.addTextSourceViaUI(args.title, args.content);
+            if (success) {
+                log.success('Text source added via browser');
+                if (sendProgress)
+                    await sendProgress('Text source added');
+                return { success: true, notebookId: notebookAlias, method: 'browser' };
             }
+            return { success: false, error: 'Browser failed to add text source', notebookId: notebookAlias };
         }
-        if (result.success && sendProgress) {
-            await sendProgress('✅ Text source added successfully');
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias };
         }
-        return result;
     }
     /**
-     * Handle add_youtube_source tool
+     * Handle add_youtube_source tool (browser-only)
      */
     async function handleAddYouTubeSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl || !sessionManager) {
             return {
                 success: false,
-                error: 'No notebook specified and no active notebook selected',
+                error: !notebookUrl ? 'No notebook specified' : 'Browser session not available',
+                notebookId: notebookAlias,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`🎥 Adding YouTube source: ${args.youtube_url}`);
-        }
-        // Try API first
-        const result = await sourceOps.addYouTubeSource(notebookId, args.youtube_url);
-        // Fallback to browser if API fails and sessionManager available
-        if (!result.success && sessionManager) {
-            log.warning('⚠️  API failed, falling back to browser automation...');
-            if (sendProgress) {
-                await sendProgress('🔄 API failed, trying browser automation...');
-            }
-            try {
-                const notebookUrl = buildNotebookUrl(notebookId);
-                const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
-                const browserSuccess = await session.addYouTubeSourceViaUI(args.youtube_url);
-                if (browserSuccess) {
-                    log.success('✅ YouTube source added via browser automation');
-                    if (sendProgress) {
-                        await sendProgress('✅ YouTube source added via browser');
-                    }
-                    return { success: true, notebookId, method: 'browser' };
-                }
-            }
-            catch (browserError) {
-                log.error(`❌ Browser fallback failed: ${browserError}`);
+        if (sendProgress)
+            await sendProgress(`Adding YouTube source: ${args.youtube_url}`);
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            const success = await session.addYouTubeSourceViaUI(args.youtube_url);
+            if (success) {
+                log.success('YouTube source added via browser');
+                if (sendProgress)
+                    await sendProgress('YouTube source added');
+                return { success: true, notebookId: notebookAlias, method: 'browser' };
             }
+            return { success: false, error: 'Browser failed to add YouTube source', notebookId: notebookAlias };
         }
-        if (result.success && sendProgress) {
-            await sendProgress('✅ YouTube source added successfully');
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias };
         }
-        return result;
     }
     /**
-     * Handle add_drive_source tool
+     * Handle add_drive_source tool (API-only - requires Drive picker)
      */
     async function handleAddDriveSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUuid = resolveNotebookUuid(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUuid) {
             return {
                 success: false,
                 error: 'No notebook specified and no active notebook selected',
+                notebookId: notebookAlias,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`📁 Adding Google Drive source: ${args.file_id}`);
-        }
-        const result = await sourceOps.addDriveSource(notebookId, args.file_id);
-        if (result.success && sendProgress) {
-            await sendProgress('✅ Google Drive source added successfully');
-        }
-        return result;
+        if (sendProgress)
+            await sendProgress(`Adding Google Drive source: ${args.file_id}`);
+        const result = await sourceOps.addDriveSource(notebookUuid, args.file_id);
+        if (result.success && sendProgress)
+            await sendProgress('Google Drive source added');
+        return { ...result, notebookId: notebookAlias };
     }
     /**
-     * Handle delete_source tool
+     * Handle delete_source tool (browser-only)
      */
     async function handleDeleteSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl || !sessionManager) {
             return {
                 success: false,
-                error: 'No notebook specified and no active notebook selected',
+                error: !notebookUrl ? 'No notebook specified' : 'Browser session not available',
+                notebookId: notebookAlias ?? undefined,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`🗑️  Deleting source: ${args.source_id}`);
+        if (sendProgress)
+            await sendProgress(`Deleting source: ${args.source_id}`);
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            // source_id can be title or ID - use as title for browser
+            let sourceTitle = args.source_id;
+            // If it looks like an API source ID (sources/xxx), find the actual title
+            if (args.source_id.startsWith('sources/')) {
+                const sources = await session.listSourcesViaUI();
+                const match = sources.find(s => s.id?.includes(args.source_id.replace('sources/', '')));
+                if (match)
+                    sourceTitle = match.title;
+            }
+            const success = await session.deleteSourceViaUI(sourceTitle, sendProgress);
+            if (success) {
+                log.success('Source deleted via browser');
+                return { success: true, notebookId: notebookAlias ?? undefined, method: 'browser' };
+            }
+            return { success: false, error: 'Failed to delete source', notebookId: notebookAlias ?? undefined };
         }
-        const result = await sourceOps.deleteSource(notebookId, args.source_id);
-        if (result.success && sendProgress) {
-            await sendProgress('✅ Source deleted successfully');
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias ?? undefined };
         }
-        return result;
     }
     /**
-     * Handle summarize_source tool
+     * Handle summarize_source tool (browser-only)
      */
     async function handleSummarizeSource(args, sendProgress) {
-        const notebookId = resolveNotebookId(args.notebook_id);
-        if (!notebookId) {
+        const notebookUrl = resolveNotebookUrl(args.notebook_id);
+        const notebookAlias = resolveNotebookAlias(args.notebook_id);
+        if (!notebookUrl || !sessionManager) {
             return {
                 success: false,
-                error: 'No notebook specified and no active notebook selected',
+                error: !notebookUrl ? 'No notebook specified' : 'Browser session not available',
+                notebookId: notebookAlias ?? undefined,
             };
         }
-        if (sendProgress) {
-            await sendProgress(`📄 Getting source summary: ${args.source_id}`);
+        if (sendProgress)
+            await sendProgress(`Getting source details: ${args.source_id}`);
+        try {
+            const session = await sessionManager.getOrCreateSession(undefined, notebookUrl);
+            // source_id can be title or ID - use as title for browser
+            let sourceTitle = args.source_id;
+            // If it looks like an API source ID (sources/xxx), find the actual title
+            if (args.source_id.startsWith('sources/')) {
+                const sources = await session.listSourcesViaUI();
+                const match = sources.find(s => s.id?.includes(args.source_id.replace('sources/', '')));
+                if (match)
+                    sourceTitle = match.title;
+            }
+            const details = await session.getSourceDetailsViaUI(sourceTitle);
+            if (details) {
+                log.success('Source details retrieved via browser');
+                if (sendProgress)
+                    await sendProgress('Source details retrieved');
+                return {
+                    success: true,
+                    source: details,
+                    notebookId: notebookAlias ?? undefined,
+                    method: 'browser',
+                };
+            }
+            return { success: false, error: 'Source not found', notebookId: notebookAlias ?? undefined };
         }
-        const result = await sourceOps.summarizeSource(notebookId, args.source_id);
-        if (result.success && sendProgress) {
-            await sendProgress('✅ Source summary retrieved');
+        catch (error) {
+            log.error(`Browser failed: ${error}`);
+            return { success: false, error: `Browser failed: ${error}`, notebookId: notebookAlias ?? undefined };
         }
-        return result;
     }
     return {
         handleListSources,