@nordsym/apiclaw 1.8.7 → 1.8.9

package/convex/agents.js

@@ -0,0 +1,809 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+// ============================================
+// AGENT NAME GENERATION
+// ============================================
+const ADJECTIVES = [
+    "Crimson", "Azure", "Golden", "Silver", "Obsidian",
+    "Emerald", "Sapphire", "Violet", "Amber", "Jade",
+    "Scarlet", "Cobalt", "Onyx", "Ruby", "Pearl",
+    "Shadow", "Storm", "Frost", "Blaze", "Thunder",
+    "Swift", "Silent", "Bright", "Dark", "Wild",
+    "Noble", "Fierce", "Cosmic", "Quantum", "Neural",
+];
+const NOUNS = [
+    "Phoenix", "Falcon", "Dragon", "Wolf", "Raven",
+    "Serpent", "Tiger", "Hawk", "Panther", "Lynx",
+    "Cipher", "Vector", "Prism", "Nexus", "Core",
+    "Agent", "Oracle", "Sentinel", "Phantom", "Vanguard",
+    "Forge", "Spark", "Pulse", "Echo", "Byte",
+    "Matrix", "Vertex", "Helix", "Nova", "Zenith",
+];
+function generateAgentName() {
+    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+    return `${adj} ${noun}`;
+}
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+// ============================================
+// MAIN AGENT QUERIES
+// ============================================
+/**
+ * Get main agent info for a workspace
+ */
+export const getMainAgent = query({
+    args: { token: v.string() },
+    handler: async (ctx, { token }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            return null;
+        }
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace) {
+            return null;
+        }
+        return {
+            workspaceId: workspace._id,
+            email: workspace.email,
+            mainAgentId: workspace.mainAgentId || null,
+            mainAgentName: workspace.mainAgentName || null,
+            aiBackend: workspace.aiBackend || null,
+            usageCount: workspace.usageCount,
+            createdAt: workspace.createdAt,
+        };
+    },
+});
+/**
+ * Rename the main agent
+ */
+/**
+ * Rename an agent by ID (patches agents table directly)
+ */
+export const renameAgent = mutation({
+    args: {
+        token: v.string(),
+        agentId: v.id("agents"),
+        name: v.string(),
+    },
+    handler: async (ctx, { token, agentId, name }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session)
+            throw new Error("Invalid session");
+        const agent = await ctx.db.get(agentId);
+        if (!agent || agent.workspaceId.toString() !== session.workspaceId.toString()) {
+            throw new Error("Agent not found or not in your workspace");
+        }
+        const trimmedName = name.trim();
+        if (trimmedName.length < 2 || trimmedName.length > 50) {
+            throw new Error("Name must be between 2 and 50 characters");
+        }
+        await ctx.db.patch(agentId, { name: trimmedName });
+        return { success: true, name: trimmedName };
+    },
+});
+export const renameMainAgent = mutation({
+    args: {
+        token: v.string(),
+        name: v.string(),
+    },
+    handler: async (ctx, { token, name }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            throw new Error("Invalid session");
+        }
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        // Validate name length
+        const trimmedName = name.trim();
+        if (trimmedName.length < 2 || trimmedName.length > 50) {
+            throw new Error("Name must be between 2 and 50 characters");
+        }
+        await ctx.db.patch(workspace._id, {
+            mainAgentName: trimmedName,
+            updatedAt: Date.now(),
+        });
+        return { success: true, name: trimmedName };
+    },
+});
+/**
+ * Initialize main agent (auto-generate name and ID if not set)
+ * Called on first API call
+ */
+export const ensureMainAgent = mutation({
+    args: { workspaceId: v.id("workspaces") },
+    handler: async (ctx, { workspaceId }) => {
+        const workspace = await ctx.db.get(workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        // Already initialized
+        if (workspace.mainAgentId && workspace.mainAgentName) {
+            return {
+                mainAgentId: workspace.mainAgentId,
+                mainAgentName: workspace.mainAgentName,
+                created: false,
+            };
+        }
+        const mainAgentId = workspace.mainAgentId || generateUUID();
+        const mainAgentName = workspace.mainAgentName || generateAgentName();
+        await ctx.db.patch(workspaceId, {
+            mainAgentId,
+            mainAgentName,
+            updatedAt: Date.now(),
+        });
+        return {
+            mainAgentId,
+            mainAgentName,
+            created: true,
+        };
+    },
+});
+// ============================================
+// SUBAGENT QUERIES
+// ============================================
+/**
+ * Get all subagents for a workspace
+ */
+export const getSubagents = query({
+    args: {
+        token: v.string(),
+        limit: v.optional(v.number()),
+    },
+    handler: async (ctx, { token, limit = 50 }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            return { subagents: [], total: 0 };
+        }
+        const subagents = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .order("desc")
+            .take(limit);
+        // Sort by lastActiveAt descending
+        const sorted = subagents.sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+        return {
+            subagents: sorted.map((s) => ({
+                id: s._id,
+                subagentId: s.subagentId,
+                name: s.name || s.subagentId,
+                callCount: s.callCount,
+                firstSeenAt: s.firstSeenAt,
+                lastActiveAt: s.lastActiveAt,
+            })),
+            total: subagents.length,
+        };
+    },
+});
+/**
+ * Get stats for a specific subagent
+ */
+export const getSubagentStats = query({
+    args: {
+        token: v.string(),
+        subagentId: v.string(),
+    },
+    handler: async (ctx, { token, subagentId }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            return null;
+        }
+        const subagent = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", session.workspaceId).eq("subagentId", subagentId))
+            .first();
+        if (!subagent) {
+            return null;
+        }
+        // Get recent logs for this subagent
+        const logs = await ctx.db
+            .query("apiLogs")
+            .withIndex("by_subagentId", (q) => q.eq("subagentId", subagentId))
+            .order("desc")
+            .take(100);
+        const successCount = logs.filter((l) => l.status === "success").length;
+        const errorCount = logs.filter((l) => l.status === "error").length;
+        const avgLatency = logs.length > 0
+            ? Math.round(logs.reduce((sum, l) => sum + l.latencyMs, 0) / logs.length)
+            : 0;
+        // Group by provider
+        const byProvider = {};
+        for (const log of logs) {
+            byProvider[log.provider] = (byProvider[log.provider] || 0) + 1;
+        }
+        return {
+            subagentId: subagent.subagentId,
+            name: subagent.name || subagent.subagentId,
+            callCount: subagent.callCount,
+            successCount,
+            errorCount,
+            successRate: logs.length > 0 ? Math.round((successCount / logs.length) * 100) : 0,
+            avgLatency,
+            firstSeenAt: subagent.firstSeenAt,
+            lastActiveAt: subagent.lastActiveAt,
+            byProvider: Object.entries(byProvider)
+                .map(([provider, count]) => ({ provider, count }))
+                .sort((a, b) => b.count - a.count),
+        };
+    },
+});
+/**
+ * Rename a subagent
+ */
+export const renameSubagent = mutation({
+    args: {
+        token: v.string(),
+        subagentId: v.string(),
+        name: v.string(),
+    },
+    handler: async (ctx, { token, subagentId, name }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            throw new Error("Invalid session");
+        }
+        const subagent = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", session.workspaceId).eq("subagentId", subagentId))
+            .first();
+        if (!subagent) {
+            throw new Error("Subagent not found");
+        }
+        const trimmedName = name.trim();
+        if (trimmedName.length < 1 || trimmedName.length > 100) {
+            throw new Error("Name must be between 1 and 100 characters");
+        }
+        await ctx.db.patch(subagent._id, { name: trimmedName });
+        return { success: true, name: trimmedName };
+    },
+});
+/**
+ * Track a subagent call (upsert subagent record)
+ * Called when X-APIClaw-Subagent header is present
+ */
+export const trackSubagentCall = mutation({
+    args: {
+        workspaceId: v.id("workspaces"),
+        subagentId: v.string(),
+    },
+    handler: async (ctx, { workspaceId, subagentId }) => {
+        const now = Date.now();
+        // Find existing subagent record
+        const existing = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", workspaceId).eq("subagentId", subagentId))
+            .first();
+        if (existing) {
+            // Increment call count
+            await ctx.db.patch(existing._id, {
+                callCount: existing.callCount + 1,
+                lastActiveAt: now,
+            });
+            return { id: existing._id, created: false };
+        }
+        // Create new subagent record
+        const id = await ctx.db.insert("subagents", {
+            workspaceId,
+            subagentId,
+            callCount: 1,
+            firstSeenAt: now,
+            lastActiveAt: now,
+        });
+        return { id, created: true };
+    },
+});
+// ============================================
+// AGGREGATE STATS
+// ============================================
+// ============================================
+// AGENT REGISTRATION & AI BACKEND TRACKING
+// ============================================
+/**
+ * Pre-register a task agent (subagent)
+ * Allows agents to be registered before they make their first call
+ */
+export const registerTaskAgent = mutation({
+    args: {
+        token: v.string(),
+        subagentId: v.string(),
+        name: v.optional(v.string()),
+        description: v.optional(v.string()),
+    },
+    handler: async (ctx, { token, subagentId, name, description }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            throw new Error("Invalid session");
+        }
+        // Validate subagentId
+        const trimmedId = subagentId.trim();
+        if (trimmedId.length < 1 || trimmedId.length > 100) {
+            throw new Error("Subagent ID must be between 1 and 100 characters");
+        }
+        const now = Date.now();
+        // Check if already exists
+        const existing = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", session.workspaceId).eq("subagentId", trimmedId))
+            .first();
+        if (existing) {
+            // Update existing record
+            await ctx.db.patch(existing._id, {
+                name: name || existing.name,
+                description: description || existing.description,
+                isRegistered: true,
+                lastActiveAt: now,
+            });
+            return { id: existing._id, created: false };
+        }
+        // Create new subagent record
+        const id = await ctx.db.insert("subagents", {
+            workspaceId: session.workspaceId,
+            subagentId: trimmedId,
+            name: name,
+            description: description,
+            callCount: 0,
+            isRegistered: true,
+            firstSeenAt: now,
+            lastActiveAt: now,
+        });
+        return { id, created: true };
+    },
+});
+/**
+ * Update AI backend for workspace or subagent
+ * Called when X-APIClaw-AI-Backend header is present
+ */
+export const updateAIBackend = mutation({
+    args: {
+        workspaceId: v.id("workspaces"),
+        subagentId: v.optional(v.string()),
+        aiBackend: v.string(),
+    },
+    handler: async (ctx, { workspaceId, subagentId, aiBackend }) => {
+        const now = Date.now();
+        if (subagentId) {
+            // Update subagent's AI backend
+            const subagent = await ctx.db
+                .query("subagents")
+                .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", workspaceId).eq("subagentId", subagentId))
+                .first();
+            if (subagent) {
+                await ctx.db.patch(subagent._id, {
+                    aiBackend,
+                    lastActiveAt: now,
+                });
+            }
+        }
+        else {
+            // Update workspace's main agent AI backend
+            await ctx.db.patch(workspaceId, {
+                aiBackend,
+                aiBackendLastSeen: now,
+                updatedAt: now,
+            });
+        }
+        return { success: true };
+    },
+});
+// ============================================
+// AGGREGATE STATS
+// ============================================
+/**
+ * Get agent overview for workspace (main + subagents summary)
+ */
+export const getAgentOverview = query({
+    args: { token: v.string() },
+    handler: async (ctx, { token }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            return null;
+        }
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace) {
+            return null;
+        }
+        // Get all subagents
+        const subagents = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .collect();
+        // Calculate totals
+        const totalSubagentCalls = subagents.reduce((sum, s) => sum + s.callCount, 0);
+        const mainAgentCalls = workspace.usageCount - totalSubagentCalls;
+        // Get most active subagents (top 5)
+        const topSubagents = subagents
+            .sort((a, b) => b.callCount - a.callCount)
+            .slice(0, 5)
+            .map((s) => ({
+            subagentId: s.subagentId,
+            name: s.name || s.subagentId,
+            callCount: s.callCount,
+            lastActiveAt: s.lastActiveAt,
+        }));
+        return {
+            mainAgent: {
+                id: workspace.mainAgentId || null,
+                name: workspace.mainAgentName || "Unnamed Agent",
+                callCount: Math.max(0, mainAgentCalls), // Ensure non-negative
+            },
+            subagents: {
+                total: subagents.length,
+                totalCalls: totalSubagentCalls,
+                topActive: topSubagents,
+            },
+            totalCalls: workspace.usageCount,
+        };
+    },
+});
+/**
+ * Delete a subagent
+ */
+export const deleteSubagent = mutation({
+    args: {
+        token: v.string(),
+        subagentId: v.string(),
+    },
+    handler: async (ctx, { token, subagentId }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            throw new Error("Invalid session");
+        }
+        const subagent = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", session.workspaceId).eq("subagentId", subagentId))
+            .first();
+        if (!subagent) {
+            throw new Error("Subagent not found");
+        }
+        await ctx.db.delete(subagent._id);
+        return { success: true };
+    },
+});
+/**
+ * Update subagent stats (call count, last active)
+ * Internal helper for tracking
+ */
+export const updateSubagentStats = mutation({
+    args: {
+        token: v.string(),
+        subagentId: v.string(),
+        incrementCalls: v.optional(v.number()),
+    },
+    handler: async (ctx, { token, subagentId, incrementCalls = 1 }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session) {
+            throw new Error("Invalid session");
+        }
+        const subagent = await ctx.db
+            .query("subagents")
+            .withIndex("by_workspaceId_subagentId", (q) => q.eq("workspaceId", session.workspaceId).eq("subagentId", subagentId))
+            .first();
+        if (!subagent) {
+            throw new Error("Subagent not found");
+        }
+        await ctx.db.patch(subagent._id, {
+            callCount: (subagent.callCount || 0) + incrementCalls,
+            lastActiveAt: Date.now(),
+        });
+        return { success: true, newCallCount: (subagent.callCount || 0) + incrementCalls };
+    },
+});
+// ============================================
+// AGENT IDENTITY (agents table — NOT agentSessions)
+// An agent = unique (fingerprint, mcpClient) pair
+// ============================================
+function generateSessionToken() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < 48; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+function generateReferralCode() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    let code = "CLAW-";
+    for (let i = 0; i < 6; i++) {
+        code += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return code;
+}
+/**
+ * Ensure agent exists for this (fingerprint, mcpClient) pair.
+ * Auto-provisions a free-tier workspace if none exists.
+ * Called on every MCP server startup.
+ */
+export const ensureAgent = mutation({
+    args: {
+        fingerprint: v.string(),
+        mcpClient: v.string(),
+        platform: v.optional(v.string()),
+        sessionToken: v.optional(v.string()),
+    },
+    handler: async (ctx, { fingerprint, mcpClient, platform, sessionToken }) => {
+        const now = Date.now();
+        console.log(`[ensureAgent] fingerprint=${fingerprint} mcpClient=${mcpClient} hasSessionToken=${!!sessionToken}`);
+        // 0. If sessionToken provided, resolve to authenticated workspace and link agent there
+        if (sessionToken) {
+            const session = await ctx.db
+                .query("agentSessions")
+                .withIndex("by_sessionToken", (q) => q.eq("sessionToken", sessionToken))
+                .first();
+            if (session) {
+                console.log(`[ensureAgent] sessionToken resolved → workspaceId=${session.workspaceId}`);
+                // Check if agent already exists for this fingerprint+client
+                const existing = await ctx.db
+                    .query("agents")
+                    .withIndex("by_fingerprint_client", (q) => q.eq("fingerprint", fingerprint).eq("mcpClient", mcpClient))
+                    .first();
+                if (existing) {
+                    // Re-link to authenticated workspace if mismatched
+                    if (existing.workspaceId.toString() !== session.workspaceId.toString()) {
+                        await ctx.db.patch(existing._id, {
+                            workspaceId: session.workspaceId,
+                            lastActiveAt: now,
+                            ...(platform ? { platform } : {}),
+                        });
+                    }
+                    else {
+                        await ctx.db.patch(existing._id, {
+                            lastActiveAt: now,
+                            ...(platform ? { platform } : {}),
+                        });
+                    }
+                    return {
+                        agentId: existing._id,
+                        workspaceId: session.workspaceId,
+                        sessionToken,
+                        isNew: false,
+                    };
+                }
+                // Create agent linked to authenticated workspace
+                const agentId = await ctx.db.insert("agents", {
+                    fingerprint,
+                    mcpClient,
+                    workspaceId: session.workspaceId,
+                    name: generateAgentName(),
+                    platform: platform || undefined,
+                    callCount: 0,
+                    firstSeenAt: now,
+                    lastActiveAt: now,
+                });
+                return {
+                    agentId,
+                    workspaceId: session.workspaceId,
+                    sessionToken,
+                    isNew: false,
+                };
+            }
+        }
+        // 1. Check if agent already exists
+        const existing = await ctx.db
+            .query("agents")
+            .withIndex("by_fingerprint_client", (q) => q.eq("fingerprint", fingerprint).eq("mcpClient", mcpClient))
+            .first();
+        if (existing) {
+            // Update last active + platform
+            await ctx.db.patch(existing._id, {
+                lastActiveAt: now,
+                ...(platform ? { platform } : {}),
+            });
+            // Find session for this workspace
+            const existingSession = await ctx.db
+                .query("agentSessions")
+                .withIndex("by_workspaceId", (q) => q.eq("workspaceId", existing.workspaceId))
+                .first();
+            return {
+                agentId: existing._id,
+                workspaceId: existing.workspaceId,
+                sessionToken: existingSession?.sessionToken || null,
+                isNew: false,
+            };
+        }
+        // 2. No agent exists — check if there's a workspace for this fingerprint (from another mcpClient)
+        const siblingAgent = await ctx.db
+            .query("agents")
+            .filter((q) => q.eq(q.field("fingerprint"), fingerprint))
+            .first();
+        let workspaceId;
+        if (siblingAgent) {
+            // Reuse existing workspace (same machine, different client)
+            workspaceId = siblingAgent.workspaceId;
+        }
+        else {
+            // 3. No workspace at all — auto-provision free tier
+            workspaceId = await ctx.db.insert("workspaces", {
+                email: "", // no email yet — added when user registers
+                status: "active",
+                tier: "free",
+                usageCount: 0,
+                usageLimit: 50,
+                weeklyUsageCount: 0,
+                weeklyUsageLimit: 50,
+                hourlyUsageCount: 0,
+                referralCode: generateReferralCode(),
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        // 4. Create agent record
+        const agentId = await ctx.db.insert("agents", {
+            fingerprint,
+            mcpClient,
+            workspaceId,
+            name: generateAgentName(),
+            platform: platform || undefined,
+            callCount: 0,
+            firstSeenAt: now,
+            lastActiveAt: now,
+        });
+        // 5. Create session
+        const newSessionToken = generateSessionToken();
+        await ctx.db.insert("agentSessions", {
+            workspaceId,
+            sessionToken: newSessionToken,
+            fingerprint,
+            lastUsedAt: now,
+            createdAt: now,
+        });
+        return {
+            agentId,
+            workspaceId,
+            sessionToken: newSessionToken,
+            isNew: true,
+        };
+    },
+});
+/**
+ * Link email to an existing workspace (called by register_owner + verifyMagicLink)
+ */
+export const linkEmailToWorkspace = mutation({
+    args: {
+        fingerprint: v.string(),
+        email: v.string(),
+    },
+    handler: async (ctx, { fingerprint, email }) => {
+        // Find agent by fingerprint → get workspace
+        const agent = await ctx.db
+            .query("agents")
+            .filter((q) => q.eq(q.field("fingerprint"), fingerprint))
+            .first();
+        if (agent) {
+            const workspace = await ctx.db.get(agent.workspaceId);
+            if (workspace && (!workspace.email || workspace.email === "")) {
+                // Add email to existing workspace
+                await ctx.db.patch(workspace._id, {
+                    email,
+                    updatedAt: Date.now(),
+                });
+                return { workspaceId: workspace._id, linked: true };
+            }
+        }
+        return { workspaceId: null, linked: false };
+    },
+});
+/**
+ * Increment call count for an agent
+ */
+export const incrementAgentCalls = mutation({
+    args: { agentId: v.id("agents") },
+    handler: async (ctx, { agentId }) => {
+        const agent = await ctx.db.get(agentId);
+        if (!agent)
+            return;
+        await ctx.db.patch(agentId, {
+            callCount: agent.callCount + 1,
+            lastActiveAt: Date.now(),
+        });
+    },
+});
+/**
+ * Get all agents for a workspace (for dashboard "My Agents")
+ */
+export const getWorkspaceAgents = query({
+    args: { token: v.string() },
+    handler: async (ctx, { token }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session)
+            return [];
+        const agents = await ctx.db
+            .query("agents")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .collect();
+        // Live-count outbound API calls for this workspace
+        const allLogs = await ctx.db
+            .query("apiLogs")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .collect();
+        const outboundCalls = allLogs.filter((l) => l.direction !== "inbound").length;
+        // Live-count searches for this workspace
+        const allSearches = await ctx.db
+            .query("searchLogs")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .collect();
+        const totalSearches = allSearches.length;
+        // If only one logical agent, give it all the counts.
+        // If multiple agents, distribute evenly (rare edge case — most workspaces have one).
+        const agentCount = agents.length || 1;
+        return agents.map((a) => ({
+            id: a._id,
+            fingerprint: a.fingerprint,
+            mcpClient: a.mcpClient,
+            name: a.name,
+            hostname: a.fingerprint.split(":")[0],
+            aiBackend: a.aiBackend,
+            platform: a.platform,
+            callCount: Math.round(outboundCalls / agentCount),
+            searchCount: Math.round(totalSearches / agentCount),
+            firstSeenAt: a.firstSeenAt,
+            lastActiveAt: a.lastActiveAt,
+        }));
+    },
+});
+/**
+ * Delete an agent record from the agents table (admin / cleanup)
+ */
+export const adminDeleteAgent = mutation({
+    args: { agentId: v.id("agents") },
+    handler: async (ctx, { agentId }) => {
+        await ctx.db.delete(agentId);
+        return { success: true };
+    },
+});
+/**
+ * Get total agent count (for landing page / admin)
+ */
+export const getTotalAgentCount = query({
+    args: {},
+    handler: async (ctx) => {
+        const agents = await ctx.db.query("agents").collect();
+        const byClient = {};
+        for (const a of agents) {
+            byClient[a.mcpClient] = (byClient[a.mcpClient] || 0) + 1;
+        }
+        return {
+            total: agents.length,
+            byClient,
+        };
+    },
+});
+//# sourceMappingURL=agents.js.map