clementine-agent 1.0.39 → 1.0.41

package/dist/agent/assistant.js

@@ -694,10 +694,29 @@ export class PersonalAssistant {
     /** Capture MCP server status from system init messages. */
     captureMcpStatus(message) {
         const sysMsg = message;
-        if (sysMsg.subtype === 'init' && sysMsg.mcp_servers) {
+        if (sysMsg.subtype !== 'init')
+            return;
+        if (sysMsg.mcp_servers) {
             this._lastMcpStatus = sysMsg.mcp_servers;
             this._lastMcpStatusTime = new Date().toISOString();
         }
+        // Auto-register Claude Desktop integrations from the authoritative tool
+        // list the SDK reports on init. Previously the claude-integrations file
+        // was written reactively — only after the agent successfully called an
+        // integration tool — which meant a freshly-connected Google Drive or
+        // Gmail was invisible until used. Now every session-init rewrites the
+        // list to match reality.
+        if (Array.isArray(sysMsg.tools) && sysMsg.tools.length > 0 && _mcpBridge) {
+            try {
+                const { added, updated } = _mcpBridge.registerClaudeIntegrationsFromToolList(sysMsg.tools);
+                if (added.length > 0 || updated.length > 0) {
+                    logger.info({ added, updated }, 'Registered Claude Desktop integrations from SDK tool inventory');
+                }
+            }
+            catch (err) {
+                logger.debug({ err }, 'Integration auto-registration failed (non-fatal)');
+            }
+        }
     }
     setUnleashedCompleteCallback(cb) {
         this.onUnleashedComplete = cb;
@@ -1046,12 +1065,40 @@ Delegate data-heavy work (SEO, analytics, bulk API calls for 3+ entities) to sub
 Never spawn a sub-agent with vague instructions like "handle this brief" — tell it exactly what to read, what to change, and where to write the result.
 `);
         }
-        // Inject Claude Desktop integration awareness (compact — ~20 tokens per integration)
+        // Inject Claude Desktop integration awareness. Two lists:
+        //  - Known-confirmed: integrations the agent has actually used before
+        //    (persisted in claude-integrations.json). High confidence.
+        //  - Possibly-available: common integrations the owner may have connected
+        //    at claude.ai level that we don't have a usage record for yet. The
+        //    integrations-file is written reactively — only entries with
+        //    successful tool uses get captured — so a freshly-connected
+        //    Google Drive / Gmail / Slack connector is invisible to us until we
+        //    try it. Hint the agent that it can try these blindly; the tool
+        //    call will either succeed or return an auth error, at which point
+        //    the record gets captured.
         try {
             const integrations = _mcpBridge?.getClaudeIntegrations() ?? [];
+            const knownNames = new Set(integrations.map(ig => ig.name));
             if (integrations.length > 0) {
                 const names = integrations.map(ig => ig.label).join(', ');
-                parts.push(`**Connected via Claude Desktop:** ${names}. Use their \`mcp__claude_ai_*\` tools for email, calendar, etc.`);
+                parts.push(`**Connected via Claude Desktop:** ${names}. Use their \`mcp__claude_ai_*\` tools (e.g. \`mcp__claude_ai_Google_Drive__search_files\`).`);
+            }
+            // Common integrations to speculatively mention. If the owner has
+            // connected any of these at claude.ai, the corresponding tool names
+            // will work even if no prior record exists.
+            const SPECULATIVE = [
+                ['Google_Drive', 'Google Drive'], ['Gmail', 'Gmail'],
+                ['Google_Calendar', 'Google Calendar'], ['Google_Workspace', 'Google Workspace'],
+                ['Slack', 'Slack'], ['Notion', 'Notion'], ['GitHub', 'GitHub'],
+                ['Linear', 'Linear'], ['Asana', 'Asana'], ['Jira', 'Jira'],
+                ['Dropbox', 'Dropbox'], ['Salesforce', 'Salesforce'],
+                ['Microsoft_365', 'Microsoft 365'],
+            ];
+            const maybe = SPECULATIVE.filter(([name]) => !knownNames.has(name)).map(([, label]) => label);
+            if (maybe.length > 0) {
+                parts.push(`**Possibly connected (try them — they'll either work or return an auth error):** ${maybe.join(', ')}. ` +
+                    `Tool names follow \`mcp__claude_ai_<IntegrationName>__<tool>\` — e.g. \`mcp__claude_ai_Google_Drive__search_files\`, \`mcp__claude_ai_Gmail__authenticate\`. ` +
+                    `Don't tell ${owner} an integration is "not available" without first attempting the tool call — a fresh connection won't be in your recorded list until after first use.`);
             }
         }
         catch { /* non-fatal */ }

package/dist/agent/mcp-bridge.d.ts

@@ -54,6 +54,21 @@ export declare function loadClaudeIntegrations(): Record<string, ClaudeIntegrati
 export declare function recordClaudeIntegrationUse(toolName: string): void;
 /** Get all discovered Claude Desktop integrations as a list. */
 export declare function getClaudeIntegrations(): ClaudeIntegration[];
+/**
+ * Register every integration found in a tool inventory. The SDK's system
+ * init message (subtype='init') includes a `tools: string[]` with the full
+ * set of tools the agent actually has access to this session — including
+ * every mcp__claude_ai_* tool Claude Desktop is surfacing. Walking that
+ * list on init gives us the authoritative, up-to-date integration set
+ * without waiting for the agent to blindly try each one.
+ *
+ * Idempotent: if an entry already exists, we merge new tool names into it
+ * and bump `connected = true` without touching firstSeen/lastUsed.
+ */
+export declare function registerClaudeIntegrationsFromToolList(tools: string[]): {
+    added: string[];
+    updated: string[];
+};
 /**
  * Bootstrap integrations from the audit log.
  * Call once on startup to seed the integrations file from historical data.

package/dist/agent/mcp-bridge.js

@@ -329,7 +329,12 @@ function parseClaudeDesktopTool(toolName) {
     const match = toolName.match(/^mcp__claude_ai_([^_]+(?:_[^_]+)*)__(.+)$/);
     if (!match)
         return null;
-    return { integration: match[1], tool: match[2] };
+    const raw = match[1];
+    // Normalize against the known canonical set (case-insensitive) so we don't
+    // create both `Microsoft_365` and `microsoft_365` entries when the SDK
+    // occasionally hands us a lowercased tool name.
+    const canonical = Object.keys(INTEGRATION_LABELS).find(k => k.toLowerCase() === raw.toLowerCase()) ?? raw;
+    return { integration: canonical, tool: match[2] };
 }
 /** Load persisted integrations from disk. */
 export function loadClaudeIntegrations() {
@@ -379,6 +384,60 @@ export function recordClaudeIntegrationUse(toolName) {
 export function getClaudeIntegrations() {
     return Object.values(loadClaudeIntegrations());
 }
+/**
+ * Register every integration found in a tool inventory. The SDK's system
+ * init message (subtype='init') includes a `tools: string[]` with the full
+ * set of tools the agent actually has access to this session — including
+ * every mcp__claude_ai_* tool Claude Desktop is surfacing. Walking that
+ * list on init gives us the authoritative, up-to-date integration set
+ * without waiting for the agent to blindly try each one.
+ *
+ * Idempotent: if an entry already exists, we merge new tool names into it
+ * and bump `connected = true` without touching firstSeen/lastUsed.
+ */
+export function registerClaudeIntegrationsFromToolList(tools) {
+    const added = [];
+    const updated = [];
+    if (!Array.isArray(tools) || tools.length === 0)
+        return { added, updated };
+    const integrations = loadClaudeIntegrations();
+    const now = new Date().toISOString();
+    let dirty = false;
+    for (const toolName of tools) {
+        const parsed = parseClaudeDesktopTool(toolName);
+        if (!parsed)
+            continue;
+        const existing = integrations[parsed.integration];
+        if (existing) {
+            if (!existing.tools.includes(parsed.tool)) {
+                existing.tools.push(parsed.tool);
+                existing.tools.sort();
+                dirty = true;
+            }
+            if (!existing.connected) {
+                existing.connected = true;
+                dirty = true;
+            }
+            if (!updated.includes(parsed.integration))
+                updated.push(parsed.integration);
+        }
+        else {
+            integrations[parsed.integration] = {
+                name: parsed.integration,
+                label: INTEGRATION_LABELS[parsed.integration] ?? parsed.integration.replace(/_/g, ' '),
+                tools: [parsed.tool],
+                firstSeen: now,
+                lastUsed: now,
+                connected: true,
+            };
+            added.push(parsed.integration);
+            dirty = true;
+        }
+    }
+    if (dirty)
+        saveClaudeIntegrations(integrations);
+    return { added, updated };
+}
 /**
  * Bootstrap integrations from the audit log.
  * Call once on startup to seed the integrations file from historical data.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",