screenpipe-mcp 0.8.1 → 0.8.3

package/dist/index.js

@@ -69,7 +69,7 @@ const SCREENPIPE_API = `http://localhost:${port}`;
 // Initialize server
 const server = new index_js_1.Server({
     name: "screenpipe",
-    version: "0.7.0",
+    version: "0.8.3",
 }, {
     capabilities: {
         tools: {},
@@ -81,14 +81,18 @@ const server = new index_js_1.Server({
 const BASE_TOOLS = [
     {
         name: "search-content",
-        description: "Search screenpipe's recorded content: screen text (OCR), audio transcriptions, and UI elements. " +
+        description: "Search screenpipe's recorded content: screen text (accessibility APIs, with OCR fallback), audio transcriptions, and UI elements. " +
             "Returns timestamped results with app context. " +
             "Call with no parameters to get recent activity. " +
             "Use the 'screenpipe://context' resource for current time when building time-based queries.\n\n" +
-            "DEEP LINKS: When referencing specific moments in results, create clickable timeline links:\n" +
-            "Format: [readable time](screenpipe://timeline?timestamp=ISO8601_TIMESTAMP)\n" +
-            "Example: [10:30 AM](screenpipe://timeline?timestamp=2024-01-15T18:30:00Z)\n" +
-            "Users can click these links to jump directly to that moment in their timeline.",
+            "SEARCH STRATEGY: First search with ONLY time params (start_time/end_time) — no q, no app_name, no content_type. " +
+            "This gives ground truth of what's recorded. Scan results to find correct app_name values, then narrow with filters using exact observed values. " +
+            "App names are case-sensitive and may differ from user input (e.g. 'Discord' vs 'Discord.exe'). " +
+            "The q param searches captured text (accessibility/OCR), NOT app names. NEVER report 'no data' after one filtered search — verify with unfiltered time-only search first.\n\n" +
+            "DEEP LINKS: When referencing specific moments, create clickable links using IDs from search results:\n" +
+            "- OCR results (PREFERRED): [10:30 AM — Chrome](screenpipe://frame/12345) — use content.frame_id from the result\n" +
+            "- Audio results: [meeting at 3pm](screenpipe://timeline?timestamp=2024-01-15T15:00:00Z) — use exact timestamp from result\n" +
+            "NEVER fabricate frame IDs or timestamps — only use values from actual search results.",
         annotations: {
             title: "Search Content",
             readOnlyHint: true,
@@ -102,8 +106,8 @@ const BASE_TOOLS = [
                 },
                 content_type: {
                     type: "string",
-                    enum: ["all", "ocr", "audio", "ui"],
-                    description: "Content type filter: 'ocr' (screen text), 'audio' (transcriptions), 'ui' (legacy UI monitoring), 'all'. Default: 'all'. For keyboard/mouse/accessibility events, use search-ui-events tool instead.",
+                    enum: ["all", "ocr", "audio", "input", "accessibility"],
+                    description: "Content type filter: 'ocr' (screen text via OCR, legacy fallback), 'audio' (transcriptions), 'input' (clicks, keystrokes, clipboard, app switches), 'accessibility' (accessibility tree text, preferred for screen content), 'all'. Default: 'all'.",
                     default: "all",
                 },
                 limit: {
@@ -193,45 +197,115 @@ const BASE_TOOLS = [
         },
     },
     {
-        name: "search-ui-events",
-        description: "Search UI input events captured via accessibility APIs (macOS). " +
-            "This is the third modality alongside vision (OCR) and audio. " +
-            "Captures: mouse clicks, keyboard text input, scroll events, app/window switches, clipboard operations. " +
-            "Events include app context, element info (accessibility labels), and precise timestamps. " +
-            "Great for understanding user workflow, what was typed, clicked, or copied.",
+        name: "list-meetings",
+        description: "List detected meetings with duration, app, and attendees. " +
+            "Returns meetings detected via app focus (Zoom, Meet, Teams) and audio. " +
+            "Only available when screenpipe runs in smart transcription mode.",
         annotations: {
-            title: "Search UI Events (Accessibility)",
+            title: "List Meetings",
             readOnlyHint: true,
         },
         inputSchema: {
             type: "object",
             properties: {
-                q: {
+                start_time: {
                     type: "string",
-                    description: "Search query for text content, app name, window title. Optional - omit to return recent events.",
+                    format: "date-time",
+                    description: "ISO 8601 UTC start filter (e.g., 2024-01-15T10:00:00Z)",
                 },
-                event_type: {
+                end_time: {
                     type: "string",
-                    enum: ["click", "text", "scroll", "key", "app_switch", "window_focus", "clipboard"],
-                    description: "Filter by event type. 'text' = aggregated keyboard input, 'click' = mouse clicks with element context, 'app_switch'/'window_focus' = app usage tracking, 'clipboard' = copy/paste events.",
+                    format: "date-time",
+                    description: "ISO 8601 UTC end filter (e.g., 2024-01-15T18:00:00Z)",
+                },
+                limit: {
+                    type: "integer",
+                    description: "Max results. Default: 20",
+                    default: 20,
+                },
+                offset: {
+                    type: "integer",
+                    description: "Skip N results for pagination. Default: 0",
+                    default: 0,
+                },
+            },
+        },
+    },
+    {
+        name: "activity-summary",
+        description: "Get a lightweight compressed activity overview for a time range (~200-500 tokens). " +
+            "Returns app usage (name, frame count, minutes), recent accessibility texts, and audio speaker summary. " +
+            "Use this FIRST for broad questions like 'what was I doing?' before drilling into search-content or search-elements. " +
+            "Much cheaper than search-content for getting an overview.",
+        annotations: {
+            title: "Activity Summary",
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_time: {
+                    type: "string",
+                    format: "date-time",
+                    description: "Start of time range in ISO 8601 UTC (e.g., 2024-01-15T10:00:00Z)",
+                },
+                end_time: {
+                    type: "string",
+                    format: "date-time",
+                    description: "End of time range in ISO 8601 UTC (e.g., 2024-01-15T18:00:00Z)",
                 },
                 app_name: {
                     type: "string",
-                    description: "Filter by application name (e.g., 'Google Chrome', 'Slack', 'Code')",
+                    description: "Optional app name filter (e.g., 'Google Chrome', 'VS Code')",
                 },
-                window_name: {
+            },
+            required: ["start_time", "end_time"],
+        },
+    },
+    {
+        name: "search-elements",
+        description: "Search structured UI elements (accessibility tree nodes and OCR text blocks). " +
+            "Returns ~100-500 bytes per element — much lighter than search-content for targeted lookups. " +
+            "Each element has: id, frame_id, source (accessibility/ocr), role (AXButton, AXStaticText, AXLink, etc.), text, bounds, depth.\n\n" +
+            "Use for: finding specific buttons, links, text fields, or UI components. " +
+            "Prefer this over search-content when you need structural UI detail rather than full screen text.",
+        annotations: {
+            title: "Search Elements",
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                q: {
                     type: "string",
-                    description: "Filter by window title",
+                    description: "Full-text search query across element text. Optional.",
+                },
+                frame_id: {
+                    type: "integer",
+                    description: "Filter to elements from a specific frame",
+                },
+                source: {
+                    type: "string",
+                    enum: ["accessibility", "ocr"],
+                    description: "Filter by element source: 'accessibility' (structured tree) or 'ocr' (text blocks)",
+                },
+                role: {
+                    type: "string",
+                    description: "Filter by element role (e.g., 'AXButton', 'AXStaticText', 'AXLink', 'AXTextField', 'line')",
                 },
                 start_time: {
                     type: "string",
                     format: "date-time",
-                    description: "ISO 8601 UTC start time (e.g., 2024-01-15T10:00:00Z)",
+                    description: "ISO 8601 UTC start time",
                 },
                 end_time: {
                     type: "string",
                     format: "date-time",
-                    description: "ISO 8601 UTC end time (e.g., 2024-01-15T18:00:00Z)",
+                    description: "ISO 8601 UTC end time",
+                },
+                app_name: {
+                    type: "string",
+                    description: "Filter by app name",
                 },
                 limit: {
                     type: "integer",
@@ -247,27 +321,23 @@ const BASE_TOOLS = [
         },
     },
     {
-        name: "get-ui-event-stats",
-        description: "Get aggregated statistics of UI events by app and event type. " +
-            "Useful for understanding app usage patterns, productivity analysis, or finding which apps were used most.",
+        name: "frame-context",
+        description: "Get accessibility text, parsed tree nodes, and extracted URLs for a specific frame. " +
+            "Falls back to OCR data for legacy frames without accessibility data. " +
+            "Use after finding a frame_id from search-content or search-elements to get full structural detail and URLs.",
         annotations: {
-            title: "UI Event Statistics",
+            title: "Frame Context",
             readOnlyHint: true,
         },
         inputSchema: {
             type: "object",
             properties: {
-                start_time: {
-                    type: "string",
-                    format: "date-time",
-                    description: "ISO 8601 UTC start time for stats period",
-                },
-                end_time: {
-                    type: "string",
-                    format: "date-time",
-                    description: "ISO 8601 UTC end time for stats period",
+                frame_id: {
+                    type: "integer",
+                    description: "The frame ID to get context for (from search results)",
                 },
             },
+            required: ["frame_id"],
         },
     },
 ];
@@ -337,63 +407,63 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                         mimeType: "text/markdown",
                         text: `# Screenpipe Search Guide
 
-## Three Data Modalities
+## Data Modalities
 
-Screenpipe captures three types of data:
-1. **Vision (OCR)** - Screen text from screenshots
-2. **Audio** - Transcribed speech from microphone/system audio
-3. **UI Events (Accessibility)** - Keyboard input, mouse clicks, app switches, clipboard (macOS)
+Screenpipe captures four types of data:
+1. **Accessibility** - Screen text via accessibility APIs (primary, preferred for screen content)
+2. **OCR** - Screen text from screenshots (legacy fallback for apps without accessibility support)
+3. **Audio** - Transcribed speech from microphone/system audio
+4. **Input** - Keyboard input, mouse clicks, app switches, clipboard (macOS)
 
 ## Quick Start
 - **Get recent activity**: Call search-content with no parameters
-- **Search text**: \`{"q": "search term", "content_type": "ocr"}\`
-- **Get keyboard input**: Use search-ui-events with \`event_type: "text"\`
-- **Track app usage**: Use get-ui-event-stats for aggregated data
+- **Search screen text**: \`{"q": "search term", "content_type": "all"}\`
+- **Get keyboard input**: \`{"content_type": "input"}\`
+- **Get audio only**: \`{"content_type": "audio"}\`
 
-## search-content (Vision + Audio)
+## search-content
 | Parameter | Description | Default |
 |-----------|-------------|---------|
 | q | Search query | (none - returns all) |
-| content_type | ocr/audio/ui/all | all |
+| content_type | all/ocr/audio/input/accessibility | all |
 | limit | Max results | 10 |
 | start_time | ISO 8601 UTC | (no filter) |
 | end_time | ISO 8601 UTC | (no filter) |
 | app_name | Filter by app | (no filter) |
 | include_frames | Include screenshots | false |
 
-## search-ui-events (Accessibility Data)
-| Parameter | Description | Default |
-|-----------|-------------|---------|
-| q | Search text content, app, window | (none) |
-| event_type | click/text/scroll/key/app_switch/window_focus/clipboard | (all types) |
-| app_name | Filter by application | (no filter) |
-| limit | Max results | 50 |
+## Search Strategy (MANDATORY)
+1. First search: ONLY use time params (start_time/end_time). No q, no app_name, no content_type. This gives ground truth of what's recorded.
+2. Scan results to find correct app_name values and content patterns.
+3. Only THEN narrow with filters using exact observed values. App names are case-sensitive and may differ from user input (e.g. "Discord" vs "Discord.exe").
+4. The q param searches captured text (accessibility/OCR), NOT app names — an app can be visible without its name in the captured text.
+5. NEVER report "no data found" after one filtered search. Verify with unfiltered time-only search first.
 
-### Event Types
-- \`text\`: Aggregated keyboard input (what was typed)
-- \`click\`: Mouse clicks with element context (accessibility labels)
-- \`app_switch\`: When user switched applications
-- \`window_focus\`: When window focus changed
-- \`clipboard\`: Copy/paste operations
-- \`scroll\`: Scroll events with delta values
+## Progressive Disclosure (Token-Efficient Strategy)
+1. **Start with activity-summary** (~200 tokens) for broad questions ("what was I doing?")
+2. **Narrow with search-content** (~500-1000 tokens) using filters from step 1
+3. **Drill into search-elements** (~200 tokens each) for structural UI detail (buttons, links)
+4. **Fetch frame-context** for URLs and accessibility tree of specific frames
+5. **Screenshots** (include_frames=true) only when text isn't enough
 
 ## Tips
 1. Read screenpipe://context first to get current timestamps
-2. Use search-ui-events for "what did I type?" queries
-3. Use get-ui-event-stats to understand app usage patterns
-4. Combine search-content (what was on screen) with search-ui-events (what was done)
+2. Use activity-summary before search-content for broad overview questions
+3. Use search-elements instead of search-content for targeted UI lookups (10x lighter)
+4. Use content_type=input for "what did I type?" queries
+5. Use content_type=accessibility for accessibility tree text
+6. For large aggregations (e.g. "what apps did I use today?"), paginate with offset or suggest the user run raw SQL via \`curl -X POST http://localhost:3030/raw_sql\` for efficient GROUP BY queries
 
-## Timeline Deep Links
-When showing search results to users, create clickable links to specific moments:
+## Deep Links (Clickable References)
+When showing search results to users, create clickable links so they can jump to that exact moment.
 
-**Format:** \`[readable time](screenpipe://timeline?timestamp=ISO8601_TIMESTAMP)\`
+**ALWAYS prefer frame-based links for OCR results** (frame IDs are exact DB keys):
+- \`[10:30 AM — Chrome](screenpipe://frame/12345)\` — use \`content.frame_id\` from OCR results
 
-**Examples:**
-- \`[10:30 AM](screenpipe://timeline?timestamp=2024-01-15T18:30:00Z)\`
-- \`[yesterday at 3pm](screenpipe://timeline?timestamp=2024-01-14T15:00:00Z)\`
+**Use timestamp links only for audio results** (which have no frame_id):
+- \`[meeting at 3pm](screenpipe://timeline?timestamp=2024-01-15T15:00:00Z)\` — use exact \`timestamp\` from audio results
 
-Users can click these links to jump directly to that moment in their screenpipe timeline.
-Always use the exact timestamp from search results when creating these links.`,
+**NEVER fabricate frame IDs or timestamps.** Only use values copied from actual search results.`,
                     },
                 ],
             };
@@ -528,7 +598,7 @@ Current time: ${dateInfo.isoDate}
 Use search-content with:
 - app_name: "${app}"
 ${query ? `- q: "${query}"` : "- No query filter"}
-- content_type: "ocr"
+- content_type: "all"
 - limit: 50`,
                         },
                     },
@@ -636,8 +706,8 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             `${content.transcription || ""}` +
                             tagsStr);
                     }
-                    else if (result.type === "UI") {
-                        formattedResults.push(`[UI] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
+                    else if (result.type === "UI" || result.type === "Accessibility") {
+                        formattedResults.push(`[Accessibility] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
                             `${content.timestamp || ""}\n` +
                             `${content.text || ""}`);
                     }
@@ -806,123 +876,151 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     };
                 }
             }
-            case "search-ui-events": {
+            case "list-meetings": {
                 const params = new URLSearchParams();
                 for (const [key, value] of Object.entries(args)) {
                     if (value !== null && value !== undefined) {
-                        // Map event_type to the API parameter
                         params.append(key, String(value));
                     }
                 }
-                const response = await fetchAPI(`/ui-events?${params.toString()}`);
+                const response = await fetchAPI(`/meetings?${params.toString()}`);
                 if (!response.ok) {
                     throw new Error(`HTTP error: ${response.status}`);
                 }
-                const data = await response.json();
-                const events = data.data || [];
-                const pagination = data.pagination || {};
-                if (events.length === 0) {
+                const meetings = await response.json();
+                if (!Array.isArray(meetings) || meetings.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: "No UI events found. This feature requires:\n" +
-                                    "1. macOS with Accessibility permissions granted\n" +
-                                    "2. UI Events enabled in screenpipe settings\n" +
-                                    "Try: broader time range or different event_type filter.",
+                                text: "No meetings found. Make sure screenpipe is running in smart transcription mode.",
                             },
                         ],
                     };
                 }
-                const formattedEvents = [];
-                for (const event of events) {
-                    const parts = [
-                        `[${event.event_type?.toUpperCase() || "?"}]`,
-                        event.app_name || "?",
-                        event.window_title ? `| ${event.window_title}` : "",
-                    ];
-                    let details = "";
-                    if (event.event_type === "text" && event.text_content) {
-                        details = `Text: "${event.text_content}"`;
-                    }
-                    else if (event.event_type === "click") {
-                        details = `Click at (${event.x || 0}, ${event.y || 0})`;
-                        if (event.element?.label) {
-                            details += ` on "${event.element.label}"`;
-                        }
-                    }
-                    else if (event.event_type === "clipboard" && event.text_content) {
-                        details = `Clipboard: "${event.text_content.substring(0, 100)}${event.text_content.length > 100 ? "..." : ""}"`;
-                    }
-                    else if (event.event_type === "app_switch" || event.event_type === "window_focus") {
-                        details = `Switched to: ${event.app_name}${event.window_title ? ` - ${event.window_title}` : ""}`;
-                    }
-                    else if (event.event_type === "scroll") {
-                        details = `Scroll: dx=${event.delta_x || 0}, dy=${event.delta_y || 0}`;
-                    }
-                    formattedEvents.push(`${parts.join(" ")}\n` +
-                        `${event.timestamp || ""}\n` +
-                        `${details}`);
-                }
-                const header = `UI Events: ${events.length}/${pagination.total || "?"}` +
-                    (pagination.total > events.length ? ` (use offset=${(pagination.offset || 0) + events.length} for more)` : "");
+                const formatted = meetings.map((m) => {
+                    const start = m.meeting_start;
+                    const end = m.meeting_end || "ongoing";
+                    const app = m.meeting_app;
+                    const title = m.title ? ` — ${m.title}` : "";
+                    const attendees = m.attendees ? `\nAttendees: ${m.attendees}` : "";
+                    return `[${m.detection_source}] ${app}${title}\n  ${start} → ${end}${attendees}`;
+                });
                 return {
                     content: [
                         {
                             type: "text",
-                            text: header + "\n\n" + formattedEvents.join("\n---\n"),
+                            text: `Meetings: ${meetings.length}\n\n${formatted.join("\n---\n")}`,
                         },
                     ],
                 };
             }
-            case "get-ui-event-stats": {
+            case "activity-summary": {
                 const params = new URLSearchParams();
-                if (args.start_time)
-                    params.append("start_time", String(args.start_time));
-                if (args.end_time)
-                    params.append("end_time", String(args.end_time));
-                const response = await fetchAPI(`/ui-events/stats?${params.toString()}`);
+                for (const [key, value] of Object.entries(args)) {
+                    if (value !== null && value !== undefined) {
+                        params.append(key, String(value));
+                    }
+                }
+                const response = await fetchAPI(`/activity-summary?${params.toString()}`);
                 if (!response.ok) {
                     throw new Error(`HTTP error: ${response.status}`);
                 }
-                const stats = await response.json();
-                if (!stats || stats.length === 0) {
+                const data = await response.json();
+                // Format apps
+                const appsLines = (data.apps || []).map((a) => `  ${a.name}: ${a.minutes} min (${a.frame_count} frames)`);
+                // Format audio
+                const speakerLines = (data.audio_summary?.speakers || []).map((s) => `  ${s.name}: ${s.segment_count} segments`);
+                // Format recent texts
+                const textLines = (data.recent_texts || []).map((t) => `  [${t.app_name}] ${t.text}`);
+                const summary = [
+                    `Activity Summary (${data.time_range?.start} → ${data.time_range?.end})`,
+                    `Total frames: ${data.total_frames}`,
+                    "",
+                    "Apps:",
+                    ...(appsLines.length ? appsLines : ["  (none)"]),
+                    "",
+                    `Audio: ${data.audio_summary?.segment_count || 0} segments`,
+                    ...(speakerLines.length ? speakerLines : []),
+                    "",
+                    "Recent texts:",
+                    ...(textLines.length ? textLines.slice(0, 10) : ["  (none)"]),
+                ].join("\n");
+                return { content: [{ type: "text", text: summary }] };
+            }
+            case "search-elements": {
+                const params = new URLSearchParams();
+                for (const [key, value] of Object.entries(args)) {
+                    if (value !== null && value !== undefined) {
+                        params.append(key, String(value));
+                    }
+                }
+                const response = await fetchAPI(`/elements?${params.toString()}`);
+                if (!response.ok) {
+                    throw new Error(`HTTP error: ${response.status}`);
+                }
+                const data = await response.json();
+                const elements = data.data || [];
+                const pagination = data.pagination || {};
+                if (elements.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: "No UI event statistics available. UI Events may not be enabled or no events have been captured yet.",
+                                text: "No elements found. Try: broader search, different role/source, or wider time range.",
                             },
                         ],
                     };
                 }
-                // Group by app
-                const byApp = {};
-                for (const stat of stats) {
-                    const app = stat.app_name || "Unknown";
-                    if (!byApp[app]) {
-                        byApp[app] = { app, events: {}, total: 0 };
-                    }
-                    byApp[app].events[stat.event_type] = stat.count;
-                    byApp[app].total += stat.count;
-                }
-                // Sort by total events
-                const sorted = Object.values(byApp).sort((a, b) => b.total - a.total);
-                const lines = sorted.map(({ app, events, total }) => {
-                    const eventDetails = Object.entries(events)
-                        .map(([type, count]) => `${type}: ${count}`)
-                        .join(", ");
-                    return `${app}: ${total} events (${eventDetails})`;
+                const formatted = elements.map((e) => {
+                    const boundsStr = e.bounds
+                        ? ` [${e.bounds.left.toFixed(2)},${e.bounds.top.toFixed(2)} ${e.bounds.width.toFixed(2)}x${e.bounds.height.toFixed(2)}]`
+                        : "";
+                    return `[${e.source}] ${e.role} (frame:${e.frame_id}, depth:${e.depth})${boundsStr}\n  ${e.text || "(no text)"}`;
                 });
+                const header = `Elements: ${elements.length}/${pagination.total || "?"}` +
+                    (pagination.total > elements.length
+                        ? ` (use offset=${(pagination.offset || 0) + elements.length} for more)`
+                        : "");
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `UI Event Statistics:\n\n${lines.join("\n")}`,
-                        },
-                    ],
+                    content: [{ type: "text", text: header + "\n\n" + formatted.join("\n---\n") }],
                 };
             }
+            case "frame-context": {
+                const frameId = args.frame_id;
+                if (!frameId) {
+                    return {
+                        content: [{ type: "text", text: "Error: frame_id is required" }],
+                    };
+                }
+                const response = await fetchAPI(`/frames/${frameId}/context`);
+                if (!response.ok) {
+                    throw new Error(`HTTP error: ${response.status}`);
+                }
+                const data = await response.json();
+                const lines = [
+                    `Frame ${data.frame_id} (source: ${data.text_source})`,
+                ];
+                if (data.urls?.length) {
+                    lines.push("", "URLs:", ...data.urls.map((u) => `  ${u}`));
+                }
+                if (data.nodes?.length) {
+                    lines.push("", `Nodes: ${data.nodes.length}`);
+                    for (const node of data.nodes.slice(0, 50)) {
+                        const indent = "  ".repeat(Math.min(node.depth, 5));
+                        lines.push(`${indent}[${node.role}] ${node.text}`);
+                    }
+                    if (data.nodes.length > 50) {
+                        lines.push(`  ... and ${data.nodes.length - 50} more nodes`);
+                    }
+                }
+                if (data.text) {
+                    // Truncate to avoid massive outputs
+                    const truncated = data.text.length > 2000 ? data.text.substring(0, 2000) + "..." : data.text;
+                    lines.push("", "Full text:", truncated);
+                }
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "screenpipe",
   "display_name": "Screenpipe",
-  "version": "0.8.0",
+  "version": "0.8.3",
   "description": "Search your screen recordings and audio transcriptions with AI",
   "long_description": "Screenpipe is a 24/7 screen and audio recorder that lets you search everything you've seen or heard. This extension connects Claude to your local screenpipe instance, enabling AI-powered search through your digital memory.",
   "author": {
@@ -33,6 +33,22 @@
     {
       "name": "export-video",
       "description": "Export screen recordings as MP4 video for a specific time range"
+    },
+    {
+      "name": "list-meetings",
+      "description": "List detected meetings with duration, app, and attendees"
+    },
+    {
+      "name": "activity-summary",
+      "description": "Lightweight compressed activity overview for a time range (apps, recent texts, audio summary)"
+    },
+    {
+      "name": "search-elements",
+      "description": "Search structured UI elements (accessibility tree nodes and OCR text blocks)"
+    },
+    {
+      "name": "frame-context",
+      "description": "Get accessibility text, parsed tree nodes, and extracted URLs for a specific frame"
     }
   ],
   "compatibility": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screenpipe-mcp",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "MCP server for screenpipe - search your screen recordings and audio transcriptions",
   "main": "dist/index.js",
   "bin": {