loopengine 0.1.98 → 0.2.0

package/dist/web/workflow-admin.js

@@ -11,6 +11,7 @@ import { writeSkill } from './skills-admin.js';
 import { createFromTemplateObject, installFailureReason, templateChecklist } from './templates-admin.js';
 import { templateScheduleStart } from '../core/system-agents/templates.js';
 import { planWorkflowWithModel, slugify, workflowTemplate } from '../core/system-agents/workflow-planner.js';
+import { mcpAbilityNames } from '../core/mcp-ability-generator.js';
 import { readWorkflows, removeWorkflow, saveWorkflow } from '../core/workflows.js';
 import { createScheduledTask, listScheduledTasks, pauseScheduledTask, runScheduledTaskNow } from '../core/scheduler.js';
 import { workspaceTimeZone } from '../core/time-zone.js';
@@ -81,6 +82,155 @@ function specNames(spec) {
     const named = spec.match(/^([^@/:][^@]*)(@.*)?$/)?.[1];
     return [...new Set([scoped, named, last.replace(/@.*$/, '')].filter((n) => Boolean(n)))];
 }
+/** Looks up each MCP server the plan's steps name: a server that can't
+ * be found leaves its steps missing; the rest are listed on the plan
+ * with the ability each would become and whether its key is set. */
+export async function resolveMcpServers(plan, deps) {
+    const ids = [...new Set(plan.steps.flatMap((s) => (s.mcp ? [s.mcp] : [])))];
+    const servers = [];
+    for (const id of ids) {
+        const server = await deps.getServer(id).catch(() => undefined);
+        if (!server) {
+            for (const step of plan.steps) {
+                if (step.mcp !== id)
+                    continue;
+                delete step.mcp;
+                step.missing = `the MCP server ${id} couldn't be found`;
+            }
+            plan.gaps = [...plan.gaps, `The MCP server ${id} couldn't be found, so its steps have no tool yet.`].slice(0, 10);
+            continue;
+        }
+        const names = mcpAbilityNames(server);
+        const existing = deps.existingFor(server.url);
+        servers.push({
+            id,
+            title: server.title,
+            url: server.url,
+            description: server.description,
+            verified: server.verified,
+            source: server.source,
+            ability: names.name,
+            keyEnv: names.keyEnv,
+            keySet: deps.keyValue(names.keyEnv) !== undefined,
+            ...(existing ? { existing: existing.spec } : {}),
+        });
+    }
+    if (servers.length)
+        plan.mcpServers = servers;
+    else
+        delete plan.mcpServers;
+}
+/** On Create: each MCP server on the plan becomes a private ability (or
+ * reuses the one already made from it), and its steps point at that
+ * ability's tools. A server that can't be set up leaves its steps
+ * missing and is reported. `keys` are what the person typed per server. */
+export async function prepareMcpAbilities(plan, keys, deps) {
+    const made = [];
+    const failed = [];
+    for (const planned of plan.mcpServers ?? []) {
+        const steps = plan.steps.map((step, index) => ({ step, index })).filter(({ step }) => step.mcp === planned.id);
+        if (!steps.length)
+            continue;
+        const fail = (error) => {
+            failed.push({ name: planned.title, error });
+            for (const { step } of steps) {
+                delete step.mcp;
+                step.missing = `${planned.title}: ${error}`;
+            }
+        };
+        if (!deps) {
+            fail('setting up MCP servers isn\'t available on this server');
+            continue;
+        }
+        // The app, connected already or connected now; and the server tool for
+        // each step (the planner's when the app has it, else worked out).
+        const existing = deps.existingFor(planned.url);
+        const known = existing && steps.every(({ step }) => step.tool && existing.tools.some((t) => t.remote === step.tool));
+        let spec;
+        let stepTools;
+        let names;
+        if (existing && known) {
+            spec = existing.spec;
+            stepTools = Object.fromEntries(steps.map(({ step, index }) => [index, step.tool]));
+            names = existing.tools;
+        }
+        else {
+            const server = await deps.getServer(planned.id).catch(() => undefined);
+            if (!server) {
+                fail('the server couldn\'t be found any more');
+                continue;
+            }
+            const typed = keys[planned.id]?.trim();
+            const key = typed || deps.keyValue(planned.keyEnv);
+            let generated;
+            try {
+                generated = await deps.generate({
+                    server,
+                    ...(key ? { key } : {}),
+                    workflow: { name: plan.name, summary: plan.summary, steps: steps.map(({ step, index }) => ({ index, title: step.title, kind: step.kind, ...(step.detail ? { detail: step.detail } : {}), ...(step.tool ? { tool: step.tool } : {}) })) },
+                });
+            }
+            catch (err) {
+                fail(err instanceof Error ? err.message : String(err));
+                continue;
+            }
+            stepTools = generated.stepTools;
+            names = generated.tools;
+            if (existing) {
+                // Connected already: only the step matching was needed.
+                spec = existing.spec;
+            }
+            else {
+                if (typed && generated.keyEnv) {
+                    try {
+                        await deps.saveKey(generated.keyEnv, typed);
+                    }
+                    catch (err) {
+                        failed.push({ name: planned.title, error: `its key wasn't saved (${err instanceof Error ? err.message : String(err)}); add ${generated.keyEnv} from the checklist` });
+                        if (!plan.keys.includes(generated.keyEnv))
+                            plan.keys.push(generated.keyEnv);
+                    }
+                }
+                spec = deps.store(generated.dir, `mcp:${server.url}`);
+                made.push(generated.name);
+            }
+        }
+        const installedName = (remote) => names.find((t) => t.remote === remote)?.name ?? remote;
+        const tools = [];
+        for (const { step, index } of steps) {
+            delete step.mcp;
+            step.ability = spec;
+            const remote = stepTools[index];
+            if (!remote) {
+                delete step.tool;
+                step.missing = `${planned.title} has no tool for this`;
+                continue;
+            }
+            step.tool = installedName(remote);
+            if (!tools.includes(remote))
+                tools.push(remote);
+            // An approval step's tool asks first, whatever its default.
+            if (step.kind === 'approval') {
+                const rule = plan.rules.find((r) => r.tool === step.tool);
+                if (rule)
+                    rule.decision = 'ask';
+                else
+                    plan.rules.push({ tool: step.tool, decision: 'ask' });
+            }
+        }
+        // The skill was written with the server's own tool names.
+        for (const { remote, name } of names) {
+            if (remote === name)
+                continue;
+            plan.skill.body = plan.skill.body.replace(new RegExp(`(?<![A-Za-z0-9_])${remote.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9_])`, 'g'), name);
+        }
+        // Added to the agent as an app, with just these tools.
+        if (tools.length)
+            plan.apps = [...(plan.apps ?? []).filter((a) => a.id !== planned.id), { id: planned.id, title: planned.title, tools }];
+    }
+    delete plan.mcpServers;
+    return { made, failed };
+}
 /** Plans a workflow from a description, then checks the suggested agent:
  * one that would have a decision changed, or doesn't exist, becomes a new
  * agent instead, saying why. */
@@ -96,6 +246,14 @@ export async function planWorkflow(description, modelCall, tools) {
     const plan = result.plan;
     const agents = await tools.agentInfo();
     resolveConnections(plan, agents);
+    if (tools.mcp)
+        await resolveMcpServers(plan, tools.mcp);
+    else
+        for (const step of plan.steps)
+            if (step.mcp) {
+                delete step.mcp;
+                step.missing = step.missing ?? 'no ability does this';
+            }
     if (plan.target.kind !== 'existing' || !plan.target.agent)
         return { plan };
     const agent = agents.find((a) => a.name === plan.target.agent);
@@ -160,6 +318,8 @@ export async function createWorkflow(input, deps) {
     });
     const agents = await deps.agentInfo();
     resolveConnections(plan, agents);
+    const keys = input.mcpKeys && typeof input.mcpKeys === 'object' ? Object.fromEntries(Object.entries(input.mcpKeys).flatMap(([k, v]) => (typeof v === 'string' && v.trim() ? [[k, v.trim()]] : []))) : {};
+    const mcp = await prepareMcpAbilities(plan, keys, deps.mcp);
     const template = workflowTemplate(plan);
     if (target.kind !== 'existing') {
         const created = await createFromTemplateObject(template, deps);
@@ -171,7 +331,7 @@ export async function createWorkflow(input, deps) {
             agent: created.name,
             newAgent: true,
             workflow: plan.name,
-            abilities: { installed: [...created.abilities.installed, ...connected.copied], failed: [...created.abilities.failed, ...connected.failed] },
+            abilities: { installed: [...created.abilities.installed, ...connected.copied], failed: [...mcp.failed, ...created.abilities.failed, ...connected.failed] },
             keptDecisions: [],
             checklist: withMissingSteps(plan, created.name, created.checklist),
             ...(created.schedule ? { schedule: created.schedule } : {}),
@@ -196,7 +356,7 @@ export async function createWorkflow(input, deps) {
     }
     // 2. Abilities it doesn't have yet.
     const installed = [];
-    const failed = [];
+    const failed = [...mcp.failed];
     for (const spec of check.toInstall) {
         if (!deps.installAbility) {
             failed.push({ name: spec, error: 'installing abilities needs LOOPENGINE_ADMIN_AUTH set on the server' });
@@ -213,6 +373,38 @@ export async function createWorkflow(input, deps) {
             failed.push({ name: spec, error: installFailureReason(err) });
         }
     }
+    // Apps: added with just the tools the steps use, or those tools added
+    // to the agent's when it has the app already.
+    const appsToConnect = [];
+    for (const app of plan.apps ?? []) {
+        const spec = deps.prepareApp ? await deps.prepareApp(app.id) : undefined;
+        if (!spec) {
+            appsToConnect.push(app.title);
+            continue;
+        }
+        if (!deps.installAbility) {
+            failed.push({ name: app.title, error: 'adding apps needs LOOPENGINE_ADMIN_AUTH set on the server' });
+            continue;
+        }
+        try {
+            await deps.installAbility(agent.name, spec, { mcpTools: app.tools });
+            installed.push(app.title);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (/already installed/i.test(message) && deps.addAppTools) {
+                try {
+                    await deps.addAppTools(agent.name, spec, app.tools);
+                    installed.push(app.title);
+                }
+                catch (e) {
+                    failed.push({ name: app.title, error: e instanceof Error ? e.message : String(e) });
+                }
+            }
+            else
+                failed.push({ name: app.title, error: installFailureReason(err) });
+        }
+    }
     // Connected-service tools it doesn't have yet.
     const connected = copyConnectedTools(plan, agent.name, agents, deps.agentDir);
     installed.push(...connected.copied);
@@ -252,7 +444,7 @@ export async function createWorkflow(input, deps) {
         workflow: plan.name,
         abilities: { installed, failed },
         keptDecisions: check.conflicts,
-        checklist: withMissingSteps(plan, agent.name, templateChecklist(template, agent.name, deps, failed)),
+        checklist: withMissingSteps(plan, agent.name, templateChecklist(template, agent.name, deps, failed, appsToConnect)),
         ...(schedule ? { schedule } : {}),
         ...(scheduleError ? { scheduleError } : {}),
         ...(loadError ? { loadError } : {}),

package/dist/web/workflow-page.js

@@ -36,6 +36,9 @@ export const workflowPageHtml = `<!doctype html>
   .wf-btn { display: inline-block; padding: 7px 14px; border-radius: 6px; text-decoration: none; font-size: 13px; font-weight: 600; background: var(--accent); color: var(--on-accent); border: 0; cursor: pointer; }
   .wf-btn.plain { background: none; color: var(--ink); border: 1px solid var(--line); font-weight: 500; }
   .wf-btn:disabled { opacity: 0.6; cursor: progress; }
+  .wf-mcp { display: grid; gap: 10px; }
+  .wf-mcp-row { border: 1px solid var(--line); border-radius: var(--radius); padding: 10px 12px; display: grid; gap: 6px; background: var(--surface); }
+  .wf-mcp-row input { font: inherit; padding: 6px 8px; border: 1px solid var(--line); border-radius: 6px; background: var(--bg); color: var(--ink); width: 100%; max-width: 360px; box-sizing: border-box; }
   .hint { font-size: 12px; color: var(--ink-muted); }
   .error { font-size: 13px; color: var(--bad); }
 </style>
@@ -134,8 +137,16 @@ ${consoleShellScript}
   }
 
   // ---- 2. Check the plan ----
+  function mcpTitle(id) {
+    var servers = (state.planned && state.planned.plan.mcpServers) || [];
+    for (var i = 0; i < servers.length; i++) if (servers[i].id === id) return servers[i].title;
+    return id;
+  }
+
   function stepRow(step, i) {
-    var becomes = step.tool
+    var becomes = step.mcp
+      ? (step.tool ? '<code>' + esc(step.tool) + '</code> ' : '') + '<span class="hint">from ' + esc(mcpTitle(step.mcp)) + ' (MCP server)' + (step.tool ? '' : ', tool picked on Create') + '</span>'
+      : step.tool
       ? '<code>' + esc(step.tool) + '</code>' + (step.ability ? ' <span class="hint">from ' + esc(step.ability) + '</span>' : step.connection ? ' <span class="hint">connected service: ' + esc(step.connection) + '</span>' : (step.tool === 'system_ask_user' ? ' <span class="hint">built in</span>' : ''))
       : '<span class="hint">the agent' + String.fromCharCode(8217) + 's own work</span>';
     var badge = step.missing
@@ -148,6 +159,21 @@ ${consoleShellScript}
     return '<tr><td class="wf-num">' + (i + 1) + '</td><td><strong>' + esc(step.title) + '</strong>' + (step.detail ? '<div class="hint">' + esc(step.detail) + '</div>' : '') + '</td><td>' + becomes + '</td><td>' + badge + '</td></tr>';
   }
 
+  function mcpRow(s) {
+    var badge = s.verified ? '<span class="le-pill allow">' + (s.source === 'saved' ? 'Saved server' : 'Verified') + '</span>' : '<span class="le-pill ask">Unverified</span>';
+    var what = s.existing
+      ? 'Uses <code>' + esc(s.ability) + '</code>, already in your workspace.'
+      : 'Connected to the workspace when you create this, as <code>' + esc(s.ability) + '</code>; the agent gets just the tools its steps use (anything that changes data asks you first).';
+    var key = s.existing ? '' :
+      '<label class="hint" for="wfKey-' + esc(s.ability) + '">API key' + (s.keySet ? ' (one is saved; leave blank to use it)' : ' (if it needs one)') + '</label>' +
+      '<input type="password" autocomplete="off" id="wfKey-' + esc(s.ability) + '" data-mcp-key="' + esc(s.id) + '" placeholder="' + esc(s.keyEnv) + '">';
+    return '<div class="wf-mcp-row"><div><strong>' + esc(s.title) + '</strong> ' + badge + '</div>' +
+      '<div class="hint">' + esc(s.url) + (s.description ? ' ' + DASH + ' ' + esc(s.description) : '') + '</div>' +
+      '<div class="hint">' + what + '</div>' + key +
+      (s.verified ? '' : '<div class="hint">Not published on the app' + String.fromCharCode(8217) + 's own domain: only add a key if you trust who runs it.</div>') +
+      '</div>';
+  }
+
   function renderPlan(error) {
     var p = state.planned.plan;
     var suggested = p.target.kind === 'existing' && p.target.agent ? p.target.agent : '';
@@ -160,6 +186,7 @@ ${consoleShellScript}
         '<div class="le-table-wrap"><table class="wf-steps"><thead><tr><th></th><th>Step</th><th>Becomes</th><th>Checkpoint</th></tr></thead><tbody>' + p.steps.map(stepRow).join('') + '</tbody></table></div>' +
         (p.rules.length ? '<h3>Permissions it sets</h3><ul class="wf-list">' + p.rules.map(function (r) { return '<li><code>' + esc(r.tool) + '</code> ' + pill(r.decision) + '</li>'; }).join('') + '</ul>' : '') +
         (p.abilities.length ? '<h3>Abilities it uses</h3><ul class="wf-list">' + p.abilities.map(function (a) { return '<li><code>' + esc(a) + '</code></li>'; }).join('') + '</ul>' + (state.canInstall ? '' : '<p class="hint">Installing abilities needs LOOPENGINE_ADMIN_AUTH set; otherwise they head the checklist.</p>') : '') +
+        (p.mcpServers && p.mcpServers.length ? '<h3>Apps it connects to</h3><div class="wf-mcp">' + p.mcpServers.map(mcpRow).join('') + '</div>' : '') +
         (p.keys.length ? '<h3>Keys it needs</h3><p class="hint" style="margin:0">' + p.keys.map(esc).join(', ') + ' ' + DASH + ' you add them after, from the checklist.</p>' : '') +
         (p.needsApprovals ? '<p class="hint" style="margin:0">It asks you through the agent' + String.fromCharCode(8217) + 's primary messaging app (Messaging tab) when nobody is in Chat.</p>' : '') +
       '</div>' +
@@ -184,8 +211,11 @@ ${consoleShellScript}
       var target = chosen.value === 'new' ? { kind: 'new' } : { kind: 'existing', agent: chosen.value === 'other' ? document.getElementById('wfOther').value : chosen.dataset.agent };
       var btn = document.getElementById('wfCreate');
       btn.disabled = true;
-      document.getElementById('wfStatus').textContent = 'Creating' + ELLIPSIS + ' installing abilities can take a minute.';
-      post('/workflows/create', { plan: p, target: target, description: state.description }).then(function (r) {
+      var mcpKeys = {};
+      var keyInputs = page.querySelectorAll('[data-mcp-key]');
+      for (var k = 0; k < keyInputs.length; k++) if (keyInputs[k].value.trim()) mcpKeys[keyInputs[k].dataset.mcpKey] = keyInputs[k].value.trim();
+      document.getElementById('wfStatus').textContent = 'Creating' + ELLIPSIS + (p.mcpServers && p.mcpServers.length ? ' connecting to its apps and installing abilities can take a minute or two.' : ' installing abilities can take a minute.');
+      post('/workflows/create', { plan: p, target: target, description: state.description, mcpKeys: mcpKeys }).then(function (r) {
         if (!r.ok) { renderPlan(r.body.error || 'Could not create it.'); return; }
         renderDone(r.body);
       }).catch(function (err) { renderPlan(err.message); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.98",
+  "version": "0.2.0",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -62,6 +62,14 @@
     "dist/core/ability-sources.d.ts",
     "dist/core/ability-details.js",
     "dist/core/ability-details.d.ts",
+    "dist/core/mcp-abilities.js",
+    "dist/core/mcp-abilities.d.ts",
+    "dist/core/mcp-directory.js",
+    "dist/core/mcp-directory.d.ts",
+    "dist/core/mcp-ability-generator.js",
+    "dist/core/mcp-ability-generator.d.ts",
+    "dist/core/mcp-apps.js",
+    "dist/core/mcp-apps.d.ts",
     "dist/core/workspace-abilities.js",
     "dist/core/workspace-abilities.d.ts",
     "dist/core/time-zone.d.ts",
@@ -129,6 +137,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.116.0",
+    "@modelcontextprotocol/sdk": "1.32.1",
     "actauth": "^0.0.12",
     "ioredis": "^6.0.0",
     "openai": "^7.4.0",