nodebench-mcp 2.28.0 → 2.30.0

package/dist/tools/openclawTools.js

@@ -7,6 +7,7 @@
  *
  * Domain: openclaw (domain #40)
  */
+import { getDb } from "../db.js";
 export const openclawTools = [
     // ═══ SESSION MANAGEMENT ═══
     {
@@ -1014,4 +1015,783 @@ export const openclawTools = [
         },
     },
 ];
+const VIEW_MANIFEST = [
+    { viewId: "research", title: "Home", description: "Landing page and research hub — overview, signals, briefing, deals, changes.", paths: ["/", "/research"], actions: ["switchTab", "search"], dataEndpoints: ["forYouFeed", "morningDigest"], tags: ["home", "research", "signals", "briefing"], requiresAuth: false },
+    { viewId: "for-you-feed", title: "For You", description: "Personalized feed ranked by relevance.", paths: ["/for-you"], actions: ["engageItem", "filterByTag"], dataEndpoints: ["forYouFeed"], tags: ["feed", "personalized", "discovery"], requiresAuth: false },
+    { viewId: "documents", title: "My Workspace", description: "Document management — create, browse, search.", paths: ["/documents"], actions: ["createDocument", "searchDocuments"], dataEndpoints: ["documents"], tags: ["documents", "workspace"], requiresAuth: true },
+    { viewId: "agents", title: "Assistants", description: "AI assistants — templates, conversations, status.", paths: ["/agents"], actions: ["startAgent", "viewAgentHistory"], dataEndpoints: ["agentTemplates", "activeAgents"], tags: ["agents", "assistants", "chat"], requiresAuth: false },
+    { viewId: "calendar", title: "Calendar", description: "Events, agenda, scheduling.", paths: ["/calendar"], actions: ["createEvent", "navigateDate"], dataEndpoints: ["events"], tags: ["calendar", "events"], requiresAuth: true },
+    { viewId: "signals", title: "Signals", description: "Real-time research signals stream.", paths: ["/signals"], actions: ["filterSignals"], dataEndpoints: ["signals"], tags: ["signals", "intelligence"], requiresAuth: false },
+    { viewId: "funding", title: "Funding", description: "Deal flow, investment rounds, sector analysis.", paths: ["/funding"], actions: ["filterByStage", "filterBySector"], dataEndpoints: ["fundingBrief"], tags: ["funding", "deals", "investment"], requiresAuth: false },
+    { viewId: "benchmarks", title: "Benchmarks", description: "Model evaluation workbench — leaderboard, scenarios.", paths: ["/benchmarks"], actions: ["runEval", "compareModels"], dataEndpoints: ["leaderboard", "scenarios"], tags: ["benchmarks", "evaluation"], requiresAuth: false },
+    { viewId: "github-explorer", title: "GitHub", description: "Repository explorer — repos, PRs, code.", paths: ["/github"], actions: ["searchCode", "viewPR"], dataEndpoints: ["repos"], tags: ["github", "code"], requiresAuth: true },
+    { viewId: "entity", title: "Entity Profile", description: "Deep profile for a company, person, or topic.", paths: ["/entity/:name"], actions: ["browseRelated", "viewTimeline"], dataEndpoints: ["entityProfile"], tags: ["entity", "profile"], requiresAuth: false },
+    { viewId: "dogfood", title: "Quality Review", description: "QA scores, screenshots, governance.", paths: ["/dogfood"], actions: ["runQA", "viewScreenshots"], dataEndpoints: ["qaResults"], tags: ["quality", "review"], requiresAuth: true },
+    { viewId: "activity", title: "Activity", description: "Public activity feed.", paths: ["/activity"], actions: ["filterActivity"], dataEndpoints: ["activity"], tags: ["activity", "feed"], requiresAuth: false },
+    { viewId: "spreadsheets", title: "Spreadsheets", description: "Spreadsheet editor.", paths: ["/spreadsheets"], actions: ["createSpreadsheet"], dataEndpoints: ["spreadsheets"], tags: ["spreadsheets", "data"], requiresAuth: true },
+    { viewId: "roadmap", title: "Roadmap", description: "Interactive product roadmap.", paths: ["/roadmap"], actions: ["navigatePhase"], dataEndpoints: [], tags: ["roadmap", "milestones"], requiresAuth: false },
+    { viewId: "timeline", title: "Timeline", description: "Chronological timeline.", paths: ["/timeline"], actions: ["scrollToDate"], dataEndpoints: [], tags: ["timeline", "history"], requiresAuth: false },
+    { viewId: "showcase", title: "Showcase", description: "Feature demo gallery.", paths: ["/showcase"], actions: [], dataEndpoints: [], tags: ["showcase", "demo"], requiresAuth: false },
+    { viewId: "footnotes", title: "Sources", description: "Citation library with verification.", paths: ["/footnotes"], actions: ["searchSources"], dataEndpoints: ["citations"], tags: ["sources", "citations"], requiresAuth: false },
+    { viewId: "analytics-hitl", title: "Review Queue", description: "Human-in-the-loop review.", paths: ["/analytics/hitl"], actions: ["approveItem", "flagItem"], dataEndpoints: ["reviewQueue"], tags: ["analytics", "review"], requiresAuth: true },
+    { viewId: "analytics-components", title: "Performance Analytics", description: "Component performance metrics.", paths: ["/analytics/components"], actions: [], dataEndpoints: ["componentMetrics"], tags: ["analytics", "performance"], requiresAuth: true },
+    { viewId: "analytics-recommendations", title: "Feedback", description: "Recommendation feedback dashboard.", paths: ["/analytics/recommendations"], actions: [], dataEndpoints: ["feedbackData"], tags: ["analytics", "feedback"], requiresAuth: true },
+    { viewId: "cost-dashboard", title: "Usage & Costs", description: "API usage and cost tracking.", paths: ["/cost"], actions: ["setAlert"], dataEndpoints: ["costData"], tags: ["costs", "usage"], requiresAuth: true },
+    { viewId: "industry-updates", title: "Industry News", description: "Curated industry updates.", paths: ["/industry"], actions: ["filterByTopic"], dataEndpoints: ["industryUpdates"], tags: ["industry", "news"], requiresAuth: false },
+    { viewId: "document-recommendations", title: "Suggestions", description: "AI document recommendations.", paths: ["/recommendations"], actions: ["dismiss", "save"], dataEndpoints: ["recommendations"], tags: ["recommendations", "discover"], requiresAuth: true },
+    { viewId: "agent-marketplace", title: "Agent Templates", description: "Browse agent templates.", paths: ["/marketplace"], actions: ["installTemplate"], dataEndpoints: ["templates"], tags: ["agents", "marketplace"], requiresAuth: true },
+    { viewId: "pr-suggestions", title: "PR Suggestions", description: "AI pull request suggestions.", paths: ["/pr-suggestions"], actions: ["applySuggestion"], dataEndpoints: ["prSuggestions"], tags: ["pull-requests", "code-review"], requiresAuth: true },
+    { viewId: "linkedin-posts", title: "LinkedIn Posts", description: "Post archive with engagement.", paths: ["/linkedin"], actions: ["searchPosts"], dataEndpoints: ["posts"], tags: ["linkedin", "social"], requiresAuth: true },
+    { viewId: "mcp-ledger", title: "Activity Log", description: "Tool call audit trail.", paths: ["/mcp-ledger"], actions: ["filterByTool", "filterByDate"], dataEndpoints: ["toolCalls"], tags: ["audit", "tools"], requiresAuth: true },
+];
+// ---------------------------------------------------------------------------
+// MCP Gateway helper — calls Convex backend via HTTP
+// ---------------------------------------------------------------------------
+async function callMcpGateway(fn, args = {}) {
+    const siteUrl = process.env.CONVEX_SITE_URL || process.env.VITE_CONVEX_URL;
+    const secret = process.env.MCP_SECRET;
+    if (!siteUrl || !secret) {
+        return { success: false, error: "Missing CONVEX_SITE_URL or MCP_SECRET. Cannot call backend." };
+    }
+    try {
+        const res = await fetch(`${siteUrl.replace(/\/$/, "")}/api/mcpGateway`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "x-mcp-secret": secret },
+            body: JSON.stringify({ fn, args }),
+        });
+        const data = await res.json();
+        return data;
+    }
+    catch (e) {
+        return { success: false, error: `Gateway call failed: ${e.message}` };
+    }
+}
+// Tool name → gateway function mapping (for invoke_view_tool routing)
+const TOOL_GATEWAY_MAP = {
+    nb_search_research: { gatewayFn: "hybridSearch", mapArgs: (a) => ({ query: String(a.query ?? ""), topK: Number(a.limit ?? 10) }) },
+    nb_get_signals: { gatewayFn: "getSignalTimeseries" },
+    nb_get_feed_items: { gatewayFn: "getPublicForYouFeed", mapArgs: (a) => ({ limit: Number(a.limit ?? 20) }) },
+    nb_list_documents: { gatewayFn: "mcpListDocuments" },
+    nb_create_document: { gatewayFn: "mcpCreateDocument" },
+    nb_search_documents: { gatewayFn: "mcpSearchDocuments" },
+    nb_get_funding_brief: { gatewayFn: "getDealFlow" },
+    nb_list_deals: { gatewayFn: "getDealFlow" },
+    nb_filter_by_stage: { gatewayFn: "getDealFlow", mapArgs: (a) => ({ stage: a.stage }) },
+    nb_list_repos: { gatewayFn: "getTrendingRepos", mapArgs: (a) => ({ limit: Number(a.limit ?? 20) }) },
+    nb_list_signals: { gatewayFn: "getSignalTimeseries" },
+    nb_get_signal_detail: { gatewayFn: "getSignalTimeseries" },
+};
+// Endpoint name → gateway function mapping (for query_view_data routing)
+const ENDPOINT_GATEWAY_MAP = {
+    forYouFeed: "getPublicForYouFeed",
+    morningDigest: "getLatestDashboardSnapshot",
+    signals: "getSignalTimeseries",
+    fundingBrief: "getDealFlow",
+    repos: "getTrendingRepos",
+    documents: "mcpListDocuments",
+    entityProfile: "getLatestPublicDossier",
+    citations: "getPublicThreads",
+};
+// Per-view tool map — what tools each view exposes (matches src/lib/viewToolMap.ts)
+const VIEW_TOOLS = {
+    research: [
+        { name: "nb_search_research", description: "Search research signals and briefings" },
+        { name: "nb_get_signals", description: "Get latest research signals" },
+        { name: "nb_switch_research_tab", description: "Switch research hub tab" },
+    ],
+    "for-you-feed": [
+        { name: "nb_get_feed_items", description: "Get personalized feed items" },
+        { name: "nb_engage_feed_item", description: "Record engagement on feed item" },
+    ],
+    documents: [
+        { name: "nb_list_documents", description: "List workspace documents" },
+        { name: "nb_create_document", description: "Create new document" },
+        { name: "nb_search_documents", description: "Search document content" },
+    ],
+    agents: [
+        { name: "nb_list_agents", description: "List agent templates and active threads" },
+        { name: "nb_start_agent", description: "Start new agent conversation" },
+        { name: "nb_get_agent_status", description: "Get agent thread status" },
+    ],
+    calendar: [
+        { name: "nb_list_events", description: "List calendar events" },
+        { name: "nb_create_event", description: "Create calendar event" },
+    ],
+    funding: [
+        { name: "nb_get_funding_brief", description: "Get funding intelligence" },
+        { name: "nb_list_deals", description: "List funding deals" },
+        { name: "nb_filter_by_stage", description: "Filter by funding stage" },
+    ],
+    benchmarks: [
+        { name: "nb_get_leaderboard", description: "Get model leaderboard" },
+        { name: "nb_list_scenarios", description: "List eval scenarios" },
+    ],
+    "github-explorer": [
+        { name: "nb_list_repos", description: "List tracked repos" },
+        { name: "nb_get_pr_status", description: "Get PR status" },
+    ],
+    signals: [
+        { name: "nb_list_signals", description: "List public signals" },
+        { name: "nb_get_signal_detail", description: "Get signal details" },
+    ],
+    dogfood: [
+        { name: "nb_get_qa_results", description: "Get QA pipeline results" },
+        { name: "nb_view_screenshots", description: "Get route screenshots" },
+    ],
+};
+// In-memory write-through cache (hot reads, SQLite for durability)
+const agentViewSessions = new Map();
+function ensureTraverseTable() {
+    try {
+        const db = getDb();
+        db.exec(`CREATE TABLE IF NOT EXISTS traverse_sessions (
+      session_id TEXT PRIMARY KEY,
+      current_view TEXT NOT NULL,
+      history TEXT NOT NULL DEFAULT '[]',
+      interactions TEXT NOT NULL DEFAULT '[]',
+      started_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )`);
+    }
+    catch {
+        // SQLite not available — fall back to in-memory only
+    }
+}
+function persistSession(sessionId, session) {
+    agentViewSessions.set(sessionId, session);
+    try {
+        const db = getDb();
+        ensureTraverseTable();
+        db.prepare(`INSERT OR REPLACE INTO traverse_sessions (session_id, current_view, history, interactions, started_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)`).run(sessionId, session.currentView, JSON.stringify(session.history), JSON.stringify(session.interactions), session.startedAt, Date.now());
+    }
+    catch {
+        // SQLite write failed — session still in memory
+    }
+}
+function loadSession(sessionId) {
+    // Check in-memory cache first
+    const cached = agentViewSessions.get(sessionId);
+    if (cached)
+        return cached;
+    // Try SQLite
+    try {
+        const db = getDb();
+        ensureTraverseTable();
+        const row = db.prepare("SELECT * FROM traverse_sessions WHERE session_id = ?").get(sessionId);
+        if (row) {
+            const session = {
+                currentView: row.current_view,
+                history: JSON.parse(row.history),
+                interactions: JSON.parse(row.interactions),
+                startedAt: row.started_at,
+            };
+            agentViewSessions.set(sessionId, session);
+            return session;
+        }
+    }
+    catch {
+        // SQLite read failed
+    }
+    return undefined;
+}
+function loadAllSessions() {
+    // Load from SQLite to merge with in-memory
+    try {
+        const db = getDb();
+        ensureTraverseTable();
+        const rows = db.prepare("SELECT * FROM traverse_sessions ORDER BY updated_at DESC LIMIT 50").all();
+        for (const row of rows) {
+            if (!agentViewSessions.has(row.session_id)) {
+                agentViewSessions.set(row.session_id, {
+                    currentView: row.current_view,
+                    history: JSON.parse(row.history),
+                    interactions: JSON.parse(row.interactions),
+                    startedAt: row.started_at,
+                });
+            }
+        }
+    }
+    catch {
+        // SQLite not available
+    }
+    return Array.from(agentViewSessions.entries());
+}
+export const agentTraverseTools = [
+    // ═══ VIEW DISCOVERY ═══
+    {
+        name: "list_available_views",
+        description: "List all available views in the NodeBench AI frontend with titles, " +
+            "descriptions, actions, data endpoints, and tags. Use this to discover " +
+            "what the app offers before navigating. Returns a manifest of 27 views.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                search: {
+                    type: "string",
+                    description: "Filter views by keyword (matches title, description, tags)",
+                },
+                includeAuthOnly: {
+                    type: "boolean",
+                    description: "Include views that require authentication (default: true)",
+                },
+            },
+        },
+        handler: async (args) => {
+            let views = [...VIEW_MANIFEST];
+            if (args.search) {
+                const q = String(args.search).toLowerCase();
+                views = views.filter((v) => v.title.toLowerCase().includes(q) ||
+                    v.description.toLowerCase().includes(q) ||
+                    v.tags.some((t) => t.includes(q)));
+            }
+            if (args.includeAuthOnly === false) {
+                views = views.filter((v) => !v.requiresAuth);
+            }
+            return {
+                success: true,
+                views: views.map((v) => ({
+                    viewId: v.viewId,
+                    title: v.title,
+                    description: v.description,
+                    path: v.paths[0] ?? `/${v.viewId}`,
+                    actions: v.actions,
+                    dataEndpoints: v.dataEndpoints,
+                    tags: v.tags,
+                    requiresAuth: v.requiresAuth,
+                    hasViewTools: !!VIEW_TOOLS[v.viewId],
+                    viewToolCount: VIEW_TOOLS[v.viewId]?.length ?? 0,
+                })),
+                totalViews: views.length,
+                quickRef: {
+                    nextAction: "Pick a view and navigate to it with navigate_to_view.",
+                    nextTools: ["navigate_to_view", "get_view_capabilities"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    {
+        name: "get_view_capabilities",
+        description: "Get full capabilities for a specific view — actions, data endpoints, " +
+            "available per-view tools, tags, and auth requirements. Use this to " +
+            "understand what you can do on a view before interacting with it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                viewId: {
+                    type: "string",
+                    description: "View ID (e.g., 'research', 'funding', 'agents'). Use list_available_views to discover valid IDs.",
+                },
+            },
+            required: ["viewId"],
+        },
+        handler: async (args) => {
+            const viewId = String(args.viewId);
+            const entry = VIEW_MANIFEST.find((v) => v.viewId === viewId);
+            if (!entry) {
+                return {
+                    success: false,
+                    error: `Unknown view: ${viewId}`,
+                    availableViews: VIEW_MANIFEST.map((v) => v.viewId),
+                };
+            }
+            const viewTools = VIEW_TOOLS[viewId] ?? [];
+            return {
+                success: true,
+                view: entry,
+                viewTools,
+                viewToolCount: viewTools.length,
+                quickRef: {
+                    nextAction: `Navigate to ${entry.title} with navigate_to_view, or invoke per-view tools with invoke_view_tool.`,
+                    nextTools: ["navigate_to_view", "invoke_view_tool"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    // ═══ VIEW NAVIGATION ═══
+    {
+        name: "navigate_to_view",
+        description: "Navigate to a specific view in the NodeBench AI frontend. " +
+            "Creates a navigation intent (via Convex agentNavigation) and returns " +
+            "the target view's capabilities so you know what to expect. " +
+            "Tracks navigation in the session history for audit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                viewId: {
+                    type: "string",
+                    description: "Target view ID (e.g., 'research', 'funding', 'agents')",
+                },
+                reason: {
+                    type: "string",
+                    description: "Why you're navigating (logged for audit trail)",
+                },
+                sessionId: {
+                    type: "string",
+                    description: "Session ID for state tracking (optional — auto-creates if omitted)",
+                },
+            },
+            required: ["viewId"],
+        },
+        handler: async (args) => {
+            const viewId = String(args.viewId);
+            const reason = args.reason ?? "agent_navigation";
+            const sessionId = args.sessionId ?? `traverse_${Date.now()}`;
+            const entry = VIEW_MANIFEST.find((v) => v.viewId === viewId);
+            if (!entry) {
+                return {
+                    success: false,
+                    error: `Unknown view: ${viewId}`,
+                    availableViews: VIEW_MANIFEST.map((v) => v.viewId),
+                };
+            }
+            // Track in session state (SQLite-backed)
+            let session = loadSession(sessionId);
+            if (!session) {
+                session = { currentView: viewId, history: [], interactions: [], startedAt: Date.now() };
+            }
+            session.currentView = viewId;
+            session.history.push({ view: viewId, timestamp: Date.now(), reason });
+            persistSession(sessionId, session);
+            const viewTools = VIEW_TOOLS[viewId] ?? [];
+            return {
+                success: true,
+                navigated: true,
+                sessionId,
+                targetView: entry,
+                availableActions: entry.actions,
+                availableTools: viewTools.map((t) => t.name),
+                dataEndpoints: entry.dataEndpoints,
+                instructions: [
+                    `Navigated to ${entry.title} (${entry.description}).`,
+                    entry.actions.length > 0
+                        ? `Available actions: ${entry.actions.join(", ")}.`
+                        : "No view-specific actions on this view.",
+                    viewTools.length > 0
+                        ? `Per-view tools: ${viewTools.map((t) => t.name).join(", ")}. Use invoke_view_tool to call them.`
+                        : "No per-view tools on this view.",
+                ],
+                quickRef: {
+                    nextAction: viewTools.length > 0
+                        ? `Use invoke_view_tool to interact with ${entry.title}.`
+                        : `Read data from ${entry.title} using query_view_data.`,
+                    nextTools: viewTools.length > 0
+                        ? ["invoke_view_tool", "query_view_data", "get_view_state"]
+                        : ["query_view_data", "get_view_state", "navigate_to_view"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    // ═══ VIEW INTERACTION ═══
+    {
+        name: "invoke_view_tool",
+        description: "Invoke a per-view tool on the current or specified view. " +
+            "Each view exposes contextual tools (e.g., 'nb_search_research' on " +
+            "the research view, 'nb_list_deals' on funding). Call get_view_capabilities " +
+            "first to see available tools. Session-injected for audit trail.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tool: {
+                    type: "string",
+                    description: "Tool name (e.g., 'nb_search_research', 'nb_list_deals')",
+                },
+                args: {
+                    type: "object",
+                    description: "Arguments to pass to the tool",
+                    additionalProperties: true,
+                },
+                viewId: {
+                    type: "string",
+                    description: "View context (auto-detected from session if omitted)",
+                },
+                sessionId: {
+                    type: "string",
+                    description: "Session ID for state tracking",
+                },
+            },
+            required: ["tool"],
+        },
+        handler: async (args) => {
+            const toolName = String(args.tool);
+            const toolArgs = args.args ?? {};
+            const sessionId = args.sessionId ?? "default";
+            // Resolve view from session (SQLite-backed) or explicit arg
+            const session = loadSession(sessionId);
+            const viewId = args.viewId ?? session?.currentView ?? "research";
+            // Validate the tool exists for this view
+            const viewTools = VIEW_TOOLS[viewId] ?? [];
+            const toolDef = viewTools.find((t) => t.name === toolName);
+            if (!toolDef) {
+                // Try all views
+                const allToolNames = [];
+                for (const [vid, tools] of Object.entries(VIEW_TOOLS)) {
+                    for (const t of tools) {
+                        allToolNames.push(`${t.name} (${vid})`);
+                    }
+                }
+                return {
+                    success: false,
+                    error: `Tool "${toolName}" not found on view "${viewId}".`,
+                    availableOnThisView: viewTools.map((t) => t.name),
+                    allViewTools: allToolNames,
+                };
+            }
+            // Track interaction (SQLite-backed)
+            if (session) {
+                session.interactions.push({
+                    view: viewId,
+                    action: toolName,
+                    args: toolArgs,
+                    timestamp: Date.now(),
+                });
+                persistSession(sessionId, session);
+            }
+            // Route to real backend via MCP Gateway
+            const route = TOOL_GATEWAY_MAP[toolName];
+            let result;
+            if (route) {
+                const mappedArgs = route.mapArgs ? route.mapArgs(toolArgs) : toolArgs;
+                const gwResult = await callMcpGateway(route.gatewayFn, mappedArgs);
+                result = gwResult.success
+                    ? { data: gwResult.data, source: "convex_gateway", gatewayFn: route.gatewayFn }
+                    : { error: gwResult.error, source: "convex_gateway", gatewayFn: route.gatewayFn };
+            }
+            else {
+                result = {
+                    note: `Tool ${toolName} has no gateway mapping. Frontend-only interaction.`,
+                    source: "stub",
+                };
+            }
+            return {
+                success: true,
+                tool: toolName,
+                view: viewId,
+                description: toolDef.description,
+                args: toolArgs,
+                result,
+                quickRef: {
+                    nextAction: "Check results. Navigate to another view or invoke more tools.",
+                    nextTools: ["invoke_view_tool", "navigate_to_view", "get_view_state"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    {
+        name: "query_view_data",
+        description: "Query data from a view's data endpoints. Each view has named " +
+            "endpoints (e.g., 'forYouFeed', 'fundingBrief', 'documents'). " +
+            "Use get_view_capabilities to see available endpoints first.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                viewId: {
+                    type: "string",
+                    description: "View to query data from",
+                },
+                endpoint: {
+                    type: "string",
+                    description: "Data endpoint name (e.g., 'forYouFeed', 'fundingBrief')",
+                },
+                params: {
+                    type: "object",
+                    description: "Query parameters (view-specific)",
+                    additionalProperties: true,
+                },
+            },
+            required: ["viewId", "endpoint"],
+        },
+        handler: async (args) => {
+            const viewId = String(args.viewId);
+            const endpoint = String(args.endpoint);
+            const params = args.params ?? {};
+            const entry = VIEW_MANIFEST.find((v) => v.viewId === viewId);
+            if (!entry) {
+                return { success: false, error: `Unknown view: ${viewId}` };
+            }
+            if (!entry.dataEndpoints.includes(endpoint)) {
+                return {
+                    success: false,
+                    error: `Endpoint "${endpoint}" not found on view "${viewId}".`,
+                    availableEndpoints: entry.dataEndpoints,
+                };
+            }
+            // Route to real backend via MCP Gateway
+            const gatewayFn = ENDPOINT_GATEWAY_MAP[endpoint];
+            let result;
+            if (gatewayFn) {
+                const gwResult = await callMcpGateway(gatewayFn, params);
+                result = gwResult.success
+                    ? { data: gwResult.data, source: "convex_gateway", gatewayFn }
+                    : { error: gwResult.error, source: "convex_gateway", gatewayFn };
+            }
+            else {
+                result = {
+                    note: `Endpoint "${endpoint}" has no gateway mapping. ` +
+                        `Available mapped endpoints: ${Object.keys(ENDPOINT_GATEWAY_MAP).join(", ")}.`,
+                    source: "stub",
+                };
+            }
+            return {
+                success: true,
+                viewId,
+                endpoint,
+                params,
+                result,
+                quickRef: {
+                    nextAction: "Process the data. Navigate to another view or invoke view tools.",
+                    nextTools: ["invoke_view_tool", "navigate_to_view", "traverse_feed"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    // ═══ FEED TRAVERSAL (Moltbook pattern) ═══
+    {
+        name: "traverse_feed",
+        description: "Traverse content feeds with Moltbook-style sorting. " +
+            "Feed types: research, signals, documents, agents, funding, activity. " +
+            "Sort by: hot (engagement-weighted recency), new (chronological), " +
+            "top (highest score), rising (fastest growing). " +
+            "Supports limit and cursor-based pagination.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                feedType: {
+                    type: "string",
+                    enum: ["research", "signals", "documents", "agents", "funding", "activity"],
+                    description: "Which feed to traverse",
+                },
+                sort: {
+                    type: "string",
+                    enum: ["hot", "new", "top", "rising"],
+                    description: "Sort order (default: hot)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Items to return (default: 10, max: 50)",
+                },
+                cursor: {
+                    type: "string",
+                    description: "Pagination cursor from previous response",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter by tags",
+                },
+            },
+            required: ["feedType"],
+        },
+        handler: async (args) => {
+            const feedType = String(args.feedType);
+            const sort = args.sort ?? "hot";
+            const limit = Math.min(args.limit ?? 10, 50);
+            const cursor = args.cursor;
+            const tags = args.tags ?? [];
+            // Map feed type to view
+            const feedViewMap = {
+                research: "for-you-feed",
+                signals: "signals",
+                documents: "documents",
+                agents: "agents",
+                funding: "funding",
+                activity: "activity",
+            };
+            const targetView = feedViewMap[feedType] ?? "for-you-feed";
+            // Route feed traversal to real backend
+            const feedGatewayMap = {
+                research: "getPublicForYouFeed",
+                signals: "getSignalTimeseries",
+                documents: "mcpListDocuments",
+                funding: "getDealFlow",
+                activity: "getLatestDashboardSnapshot",
+            };
+            const feedGwFn = feedGatewayMap[feedType];
+            let feedResult;
+            if (feedGwFn) {
+                const gwResult = await callMcpGateway(feedGwFn, { limit, sort });
+                feedResult = gwResult.success
+                    ? { data: gwResult.data, source: "convex_gateway", gatewayFn: feedGwFn }
+                    : { error: gwResult.error, source: "convex_gateway", gatewayFn: feedGwFn };
+            }
+            else {
+                feedResult = { note: `No gateway mapping for feed type "${feedType}".`, source: "stub" };
+            }
+            return {
+                success: true,
+                feedType,
+                sort,
+                limit,
+                cursor: cursor ?? null,
+                tags,
+                targetView,
+                result: feedResult,
+                quickRef: {
+                    nextAction: "Process items. Use cursor for next page, or switch feed type.",
+                    nextTools: ["traverse_feed", "navigate_to_view", "invoke_view_tool"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    // ═══ SESSION STATE ═══
+    {
+        name: "get_view_state",
+        description: "Get the current agent traversal session state — which view you're on, " +
+            "navigation history, interaction log, and session duration. " +
+            "Use this for self-awareness and audit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sessionId: {
+                    type: "string",
+                    description: "Session ID (uses most recent if omitted)",
+                },
+            },
+        },
+        handler: async (args) => {
+            const sessionId = args.sessionId;
+            if (sessionId) {
+                const session = loadSession(sessionId);
+                if (!session) {
+                    return { success: false, error: `Session not found: ${sessionId}` };
+                }
+                return {
+                    success: true,
+                    sessionId,
+                    currentView: session.currentView,
+                    viewsVisited: session.history.length,
+                    history: session.history.slice(-10),
+                    interactions: session.interactions.slice(-10),
+                    durationMs: Date.now() - session.startedAt,
+                };
+            }
+            // Return summary of all sessions (loads from SQLite + in-memory)
+            const allSessions = loadAllSessions();
+            const sessions = allSessions.map(([id, s]) => ({
+                sessionId: id,
+                currentView: s.currentView,
+                viewsVisited: s.history.length,
+                interactions: s.interactions.length,
+                durationMs: Date.now() - s.startedAt,
+            }));
+            return {
+                success: true,
+                activeSessions: sessions.length,
+                sessions,
+                quickRef: {
+                    nextAction: "Review session state. Continue navigating or end session.",
+                    nextTools: ["navigate_to_view", "list_available_views"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+    {
+        name: "get_traversal_plan",
+        description: "Generate a traversal plan for accomplishing a goal across multiple views. " +
+            "Given a goal (e.g., 'find recent AI funding deals and create a summary document'), " +
+            "returns an ordered list of views to visit and actions to take on each.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                goal: {
+                    type: "string",
+                    description: "What you want to accomplish (natural language)",
+                },
+                constraints: {
+                    type: "object",
+                    properties: {
+                        maxViews: { type: "number", description: "Max views to visit (default: 5)" },
+                        requiresAuth: { type: "boolean", description: "Can use auth-required views?" },
+                        preferredViews: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Preferred views to include",
+                        },
+                    },
+                },
+            },
+            required: ["goal"],
+        },
+        handler: async (args) => {
+            const goal = String(args.goal).toLowerCase();
+            const maxViews = args.constraints?.maxViews ?? 5;
+            const requiresAuth = args.constraints?.requiresAuth ?? true;
+            const preferredViews = args.constraints?.preferredViews ?? [];
+            // Score each view by relevance to the goal
+            const scored = VIEW_MANIFEST
+                .filter((v) => requiresAuth || !v.requiresAuth)
+                .map((v) => {
+                let score = 0;
+                // Tag matching
+                for (const tag of v.tags) {
+                    if (goal.includes(tag))
+                        score += 3;
+                }
+                // Title matching
+                if (goal.includes(v.title.toLowerCase()))
+                    score += 5;
+                // Description keyword matching
+                const descWords = v.description.toLowerCase().split(/\s+/);
+                for (const word of descWords) {
+                    if (word.length > 3 && goal.includes(word))
+                        score += 1;
+                }
+                // Action matching
+                for (const action of v.actions) {
+                    if (goal.includes(action.toLowerCase()))
+                        score += 2;
+                }
+                // Preferred view bonus
+                if (preferredViews.includes(v.viewId))
+                    score += 10;
+                // Has data endpoints = more useful
+                score += v.dataEndpoints.length;
+                // Has view tools = more interactive
+                score += (VIEW_TOOLS[v.viewId]?.length ?? 0) * 0.5;
+                return { view: v, score };
+            })
+                .filter((s) => s.score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, maxViews);
+            const plan = scored.map((s, i) => ({
+                step: i + 1,
+                viewId: s.view.viewId,
+                title: s.view.title,
+                relevance: Math.round(s.score),
+                suggestedActions: s.view.actions.filter((a) => {
+                    const aLower = a.toLowerCase();
+                    return goal.includes(aLower) || goal.includes(aLower.replace(/([A-Z])/g, " $1").toLowerCase());
+                }),
+                availableTools: VIEW_TOOLS[s.view.viewId]?.map((t) => t.name) ?? [],
+                dataEndpoints: s.view.dataEndpoints,
+            }));
+            return {
+                success: true,
+                goal,
+                plan,
+                totalSteps: plan.length,
+                estimatedViews: plan.length,
+                instructions: [
+                    `Traversal plan for: "${args.goal}"`,
+                    `${plan.length} views to visit in order of relevance.`,
+                    "Use navigate_to_view for each step, then invoke_view_tool or query_view_data.",
+                ],
+                quickRef: {
+                    nextAction: plan.length > 0
+                        ? `Start with navigate_to_view("${plan[0].viewId}").`
+                        : "Refine your goal or use list_available_views to explore.",
+                    nextTools: ["navigate_to_view", "invoke_view_tool", "query_view_data"],
+                    methodology: "agent_traversal",
+                },
+            };
+        },
+    },
+];
 //# sourceMappingURL=openclawTools.js.map