clementine-agent 1.18.12 → 1.18.13

package/dist/agent/tool-router.js

@@ -126,6 +126,15 @@ export const TOOL_BUNDLES = [
 function uniqueStrings(values) {
     return [...new Set([...values].filter((v) => !!v && v.trim().length > 0))];
 }
+function explicitMcpServers(scopeText) {
+    const servers = new Set();
+    const re = /\bmcp__([A-Za-z0-9_-]+)__[A-Za-z0-9_.:-]+\b/g;
+    let match;
+    while ((match = re.exec(scopeText)) !== null) {
+        servers.add(match[1]);
+    }
+    return uniqueStrings(servers);
+}
 export function routeToolSurface(text) {
     const scopeText = text?.trim() ?? '';
     if (!scopeText) {
@@ -162,13 +171,26 @@ export function routeToolSurface(text) {
             composio.add(slug);
         inheritFullClaudeEnv = inheritFullClaudeEnv || bundle.inheritFullClaudeEnv === true;
     }
+    for (const server of explicitMcpServers(scopeText)) {
+        if (server.startsWith('claude_ai_')) {
+            external.add(server.slice('claude_ai_'.length));
+        }
+        else {
+            // Exact `mcp__<server>__<tool>` mentions are authoritative. Add the
+            // name as both a direct MCP server and a Composio toolkit; whichever
+            // source is actually connected will mount, and the other path no-ops.
+            external.add(server);
+            composio.add(server);
+        }
+        inheritFullClaudeEnv = true;
+    }
     return {
         bundles: uniqueStrings(bundles),
         externalMcpServers: uniqueStrings(external),
         composioToolkits: uniqueStrings(composio),
         inheritFullClaudeEnv,
         fullSurface: false,
-        reason: bundles.size > 0 ? 'matched' : 'empty',
+        reason: bundles.size > 0 || external.size > 0 || composio.size > 0 ? 'matched' : 'empty',
     };
 }
 //# sourceMappingURL=tool-router.js.map

package/dist/brain/connector-recipes.d.ts

@@ -59,7 +59,7 @@ export interface ConnectorRecipe {
     description: string;
     /** Emoji shown next to the label. */
     icon: string;
-    /** Matches the key in ~/.clementine/claude-integrations.json */
+    /** Matches the tool source name; "*" recipes are offered for every source. */
     integration: string;
     /** Tools we rely on for this recipe. Used only to warn if the integration
      *  hasn't surfaced them yet in claude-integrations.json. */

package/dist/brain/connector-recipes.js

@@ -25,6 +25,10 @@ function slugify(s) {
         .replace(/^-+|-+$/g, '')
         .slice(0, 40) || 'feed';
 }
+function inferToolServer(toolName) {
+    const match = String(toolName).match(/^mcp__([^_]+(?:_[^_]+)*)__/);
+    return match?.[1] ?? 'tool';
+}
 const COMMIT_INSTRUCTIONS = `When you have the records collected, call the \`brain_ingest_folder\` MCP tool with:
 - \`slug\`: "{{slug}}"
 - \`records\`: an array of \`{title, externalId, content, metadata}\` objects (one per item). \`externalId\` should be the source provider's stable id so re-runs dedup. \`metadata\` can include any fields you want preserved (url, modifiedAt, author).
@@ -35,6 +39,102 @@ If the tool returns an error, include the error text in your summary.`;
 const MEMORY_DELTA_INSTRUCTIONS = `Before committing, call \`memory_recall\` for the feed slug/topic and use the returned chunks as the current memory state for this source. Keep records that are new, materially changed, or contain a new finding. Drop exact duplicates and rows that add no useful information. The ingestion pipeline will write markdown and embeddings; do not call \`memory_write\` for these feed records.`;
 // ── Recipes ────────────────────────────────────────────────────────────
 export const RECIPES = [
+    {
+        id: 'tool-backed-memory-seed',
+        label: 'Any tool: call and seed memory',
+        description: 'Call a selected tool from this connector, compare results with current memory, and ingest new or changed findings.',
+        icon: '🔌',
+        integration: '*',
+        requiredTools: [],
+        fields: [
+            {
+                key: 'topic',
+                label: 'Memory topic',
+                placeholder: 'customers, calls, leads, deals, meetings...',
+                required: true,
+                help: 'Used for recall, deduping, and the generated feed slug.',
+            },
+            {
+                key: 'toolName',
+                label: 'Tool to call',
+                required: true,
+                help: 'Pick the exact tool this feed should call when it runs.',
+            },
+            {
+                key: 'callGoal',
+                label: 'What to pull',
+                placeholder: 'Fetch updated HubSpot contacts modified since the last run...',
+                required: true,
+                help: 'Describe the records to fetch, filters to apply, and any pagination bounds.',
+            },
+            {
+                key: 'variablesJson',
+                label: 'Variables JSON',
+                placeholder: '{"listId":"123","limit":100,"updatedAfter":"last_run"}',
+                help: 'Optional arguments, IDs, ranges, filters, or query variables the tool should use.',
+            },
+            {
+                key: 'recordStrategy',
+                label: 'Record strategy',
+                placeholder: 'One record per contact. Use email as stable id. Summarize lifecycle stage, owner, last activity, and new changes.',
+                help: 'Tell the agent how to convert the tool output into memory records.',
+            },
+            {
+                key: 'slug',
+                label: 'Slug override',
+                placeholder: 'hubspot-contacts',
+                help: 'Optional. Leave blank to derive one from the connector and topic.',
+            },
+            {
+                key: 'limit',
+                label: 'Max records per run',
+                placeholder: '100',
+                defaultValue: '100',
+            },
+        ],
+        defaultSchedule: '0 8 * * *',
+        tier: 2,
+        slugFromValues: (v) => `tool-${slugify(v.slug || `${v.toolSourceName || inferToolServer(v.toolName || '')}-${v.topic || v.toolName || 'feed'}`)}`,
+        buildPrompt: (v, ctx) => {
+            const sourceName = v.toolSourceName || inferToolServer(v.toolName || '');
+            const sourceKind = v.toolSourceKind || 'mcp';
+            const sourceLabel = v.toolSourceLabel || sourceName;
+            const topic = v.topic || 'tool-backed memory';
+            const limit = v.limit || '100';
+            return `You are running a generic tool-backed memory seed feed.
+
+Tool source:
+- Label: "${sourceLabel}"
+- Source name: "${sourceName}"
+- Source kind: "${sourceKind}"
+- Tool: \`${v.toolName}\`
+
+Goal: ${v.callGoal || `Call ${v.toolName} and ingest useful returned data into memory.`}
+
+Variables JSON:
+\`\`\`json
+${(v.variablesJson || '{}').trim() || '{}'}
+\`\`\`
+
+Record strategy:
+${v.recordStrategy || 'Convert the tool response into one memory record per returned entity or event. Use the provider stable id when available; otherwise use a deterministic hash of the source, topic, and meaningful record key.'}
+
+Steps:
+1. Call exactly this selected tool: \`${v.toolName}\`. Use the Variables JSON and the Goal above as the tool-call inputs. If the tool schema needs differently named arguments, map the provided variables to that schema. Do not switch to a different external tool unless this tool returns a clear instruction that another tool is required to read the selected records.
+2. If the tool supports pagination or modified-since filters, prefer new/updated records and stop after ${limit} records. If no modified-since filter is available, fetch the most relevant ${limit} records.
+3. Normalize the tool result into candidate records. Preserve stable ids, URLs, timestamps, owners/authors, status fields, and provider metadata. Skip empty or purely administrative records.
+4. ${MEMORY_DELTA_INSTRUCTIONS}
+   Use this recall query: \`source:${ctx.slug} ${topic} ${sourceLabel} ${v.toolName}\`.
+5. Compare the normalized candidates with recalled memory. Keep only candidates that are new, materially changed, or produce a new useful finding. Drop exact duplicates and trivial timestamp-only changes unless the timestamp itself is the useful fact.
+6. For each kept candidate, build one record:
+   - \`title\`: a compact human label including the topic and record name/id.
+   - \`externalId\`: \`${sourceName}:${topic}:<providerStableIdOrDeterministicHash>\`.
+   - \`content\`: markdown containing the current facts, the new/changed finding, and a "Source data" section with relevant returned fields.
+   - \`metadata\`: \`{provider:"${sourceName}", toolSource:"${sourceKind}", toolName:"${v.toolName}", topic:"${topic}", fetchedAt, sourceUrl, updatedAt}\` plus any provider-specific keys worth preserving.
+7. ${COMMIT_INSTRUCTIONS.replace(/{{slug}}/g, ctx.slug).replace(/{{targetFolder}}/g, ctx.targetFolder)}
+`;
+        },
+    },
     {
         id: 'gdrive-watch-folder',
         label: 'Google Drive: watch a folder',

package/dist/cli/dashboard.js

@@ -3890,7 +3890,7 @@ export async function cmdDashboard(opts) {
                     const connected = await composio.listConnectedToolkits();
                     const activeSlugs = [...new Set(connected
                             .filter((c) => c.status === 'ACTIVE')
-                            .filter((c) => recipeIntegrations.has(c.slug))
+                            .filter((c) => recipeIntegrations.has('*') || recipeIntegrations.has(c.slug))
                             .map((c) => c.slug))];
                     if (activeSlugs.length) {
                         const { listComposioToolkitTools } = await import('../integrations/composio/mcp-bridge.js');
@@ -14115,6 +14115,11 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
             for (const f of (s.recipe.fields || [])) {
               if (f.defaultValue) s.values[f.key] = f.defaultValue;
             }
+            if (s.recipe.integration === '*' && s.pick) {
+              s.values.toolSourceName = s.pick.name;
+              s.values.toolSourceKind = s.pick.kind;
+              s.values.toolSourceLabel = s.pick.label;
+            }
             s.schedule = s.recipe.defaultSchedule;
             s.step = 2;
           } else if (s.step === 2) {
@@ -14290,6 +14295,13 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
           if (field) await brainRenderFieldPicker(field, s.values);
         }
 
+        function brainFullToolNameForPick(pick, tool) {
+          if (!pick || !tool) return tool || '';
+          if (String(tool).startsWith('mcp__')) return tool;
+          const server = pick.kind === 'claude-desktop' ? ('claude_ai_' + pick.name) : pick.name;
+          return 'mcp__' + server + '__' + tool;
+        }
+
         function brainFeedWizardRender() {
           if (!brainFeedWizardState) return;
           const s = brainFeedWizardState;
@@ -14317,7 +14329,7 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
                 }).join('') + '</div>';
             }
           } else if (s.step === 1) {
-            const recipes = (s.catalog.recipes || []).filter(function(r) { return r.integration === s.pick.name; });
+            const recipes = (s.catalog.recipes || []).filter(function(r) { return r.integration === s.pick.name || r.integration === '*'; });
             if (!recipes.length) {
               html = '<div style="color:var(--muted)">No recipes for this connector yet.</div>';
             } else {
@@ -14346,6 +14358,25 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
                       '<div style="color:var(--muted);font-size:13px;padding:6px">Loading choices…</div>' +
                     '</div>' +
                     '<input type="hidden" data-field="' + f.key + '" value="' + escapeHtml(val) + '">';
+                  } else if (s.recipe.integration === '*' && f.key === 'toolName') {
+                    const tools = (s.pick && s.pick.tools) || [];
+                    if (!tools.length) {
+                      control = '<input type="text" data-field="' + f.key + '" value="' + escapeHtml(val) + '" placeholder="mcp__server__TOOL_NAME" style="width:100%">';
+                    } else {
+                      const options = tools.map(function(t) {
+                        const full = brainFullToolNameForPick(s.pick, t);
+                        const selected = full === val ? ' selected' : '';
+                        return '<option value="' + escapeHtml(full) + '"' + selected + '>' + escapeHtml(t) + '</option>';
+                      }).join('');
+                      control = '<select data-field="' + f.key + '" style="width:100%;padding:6px">' +
+                        '<option value="">— pick a tool —</option>' +
+                        options +
+                      '</select>' +
+                      '<div style="font-size:11px;color:var(--muted);margin-top:4px">The feed will call the selected tool exactly, then compare returned records with memory.</div>';
+                    }
+                  } else if (s.recipe.integration === '*' && ['callGoal', 'variablesJson', 'recordStrategy'].includes(f.key)) {
+                    const minHeight = f.key === 'variablesJson' ? '70px' : '92px';
+                    control = '<textarea data-field="' + f.key + '" placeholder="' + escapeHtml(f.placeholder || '') + '" style="width:100%;min-height:' + minHeight + ';resize:vertical">' + escapeHtml(val) + '</textarea>';
                   } else {
                     control = '<input type="text" data-field="' + f.key + '" value="' + escapeHtml(val) + '" placeholder="' + escapeHtml(f.placeholder || '') + '" style="width:100%">';
                   }
@@ -14387,6 +14418,11 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
         function brainFeedWizardPickRecipe(id) {
           const r = (brainFeedWizardState.catalog.recipes || []).find(function(x) { return x.id === id; });
           brainFeedWizardState.recipe = r;
+          if (r && r.integration === '*' && brainFeedWizardState.pick) {
+            brainFeedWizardState.values.toolSourceName = brainFeedWizardState.pick.name;
+            brainFeedWizardState.values.toolSourceKind = brainFeedWizardState.pick.kind;
+            brainFeedWizardState.values.toolSourceLabel = brainFeedWizardState.pick.label;
+          }
           brainFeedWizardRender();
         }
 

package/package.json

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