@addai/node 0.24.0 → 0.25.0

package/dist/flows/run.js

@@ -0,0 +1,219 @@
+"use strict";
+// Execute one claimed flow run on this machine.
+//
+// The engine does the walking. What this file owns is the part the engine
+// deliberately knows nothing about: turning a database row into a graph call,
+// keeping the server informed while it runs, and writing exactly one terminal
+// answer at the end.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlow = runFlow;
+const os = __importStar(require("os"));
+const engine_loader_1 = require("./engine-loader");
+const supabase_client_1 = require("../supabase-client");
+const store_1 = require("../store");
+const host_1 = require("./host");
+/**
+ * What the engine's result means for the run row.
+ *
+ * An end condition outranks the walk's own verdict: a flow that hit a goal
+ * "completed" as far as the graph is concerned, but goal and exit are the
+ * answers the runs list and the stats are counted on, and a node run that
+ * reported plain 'completed' for a goal would quietly skew both.
+ */
+function resolveStatus(result) {
+    const endType = result?.endConditionResult?.type;
+    if (endType === 'goal')
+        return 'goal';
+    if (endType === 'exit')
+        return 'exit';
+    switch (result?.status) {
+        case 'completed': return 'completed';
+        case 'cancelled': return 'cancelled';
+        case 'paused': return 'paused';
+        case 'failed': return 'failed';
+        default: return 'completed';
+    }
+}
+async function complete(run, status, fields = {}) {
+    const pairing = (0, store_1.readPairing)();
+    if (!pairing)
+        return;
+    try {
+        await (0, supabase_client_1.rpc)('flow_run_complete', {
+            p_token: pairing.daemonToken,
+            p_run_id: run.id,
+            p_status: status,
+            p_node_outputs: fields.nodeOutputs ?? null,
+            p_error: fields.error ?? null,
+            p_current_node_id: fields.currentNodeId ?? null,
+            p_metadata: fields.metadata ?? null,
+        });
+    }
+    catch (err) {
+        // The run is finished on this machine either way. Losing this write means
+        // the server's reclaim sweep eventually requeues it, which is the correct
+        // fallback — better a second attempt than a run stuck 'running' forever.
+        console.error(`[flows] could not report ${status} [run=${run.id}]:`, err.message);
+    }
+}
+/**
+ * Run it. Resolves when the run has reached a terminal or paused state and
+ * that state has been reported; never throws, because the pump's slot
+ * accounting is built on this settling exactly once.
+ */
+async function runFlow(run) {
+    const label = `${run.flow_id?.slice(0, 8) ?? '?'} run=${run.id.slice(0, 8)}`;
+    const started = Date.now();
+    console.log(`[flows] starting ${label}`);
+    // Resuming: the row carries what already ran, so a run that paused on a form
+    // and came back does not re-execute the nodes before it. This is also what
+    // makes a run survive being handed to a different machine mid-flight.
+    const previousOutputs = run.node_outputs || {};
+    const previouslyExecuted = new Set(Object.keys(previousOutputs));
+    let lastNodeId = run.current_node_id;
+    try {
+        // Inside the try, deliberately. If the engine cannot load — a broken
+        // install, a native sandbox that never built — this run has to be marked
+        // failed with that message on it. Loading above the try would throw past
+        // every handler below and leave the run sitting 'running' until the
+        // server's reclaim sweep noticed, three minutes later, with no reason
+        // attached.
+        //
+        // The error classes must come from the loaded module too: `instanceof`
+        // against a separately imported copy would never match, and every paused
+        // flow would be recorded as a failure.
+        const { executeWorkflowGraph, FlowPausedError, FlowCancelledError } = await (0, engine_loader_1.loadEngine)();
+        const result = await executeWorkflowGraph({
+            nodes: run.nodes || [],
+            edges: run.edges || [],
+            inputData: run.trigger_data || {},
+            // Where to pick up. A fresh run has none and starts at its trigger; a
+            // run the cloud handed back after a form or a wait carries the node it
+            // stopped at. Without this a resumed flow would walk from the top —
+            // previouslyExecuted stops it re-running anything, but a flow whose
+            // trigger is a webhook has nothing to walk from.
+            startFromNode: run.resume_from_node_id || null,
+            previousOutputs,
+            previouslyExecuted,
+            endConditions: null,
+            hooks: {
+                onNodeStarted: (node) => {
+                    lastNodeId = node?.id ?? lastNodeId;
+                },
+                onNodeCompleted: (node, output) => {
+                    (0, host_1.reportNodeLog)(run, node, 'success', output);
+                },
+                onNodeError: (node, error) => {
+                    (0, host_1.reportNodeLog)(run, node, 'error', {
+                        error: error?.message || String(error),
+                        success: false,
+                    });
+                },
+            },
+            context: {
+                handlers: await (0, host_1.buildRegistry)(run),
+                workspaceId: run.workspace_id,
+                flowRunId: run.id,
+                flowId: run.flow_id,
+                versionId: run.aiflow_version_id,
+                isTest: run.is_test === true,
+                variables: run.resolved_variables || [],
+                // Cancellation. The engine asks between nodes, so a cancel from the
+                // runs list stops this machine at the next boundary rather than after
+                // the whole flow. Failures here answer "unknown" rather than throwing:
+                // a blip talking to Supabase must not kill a healthy run.
+                checkRunStatus: async (rid) => {
+                    try {
+                        const pairing = (0, store_1.readPairing)();
+                        if (!pairing)
+                            return undefined;
+                        return await (0, supabase_client_1.rpc)('flow_run_status', {
+                            p_token: pairing.daemonToken,
+                            p_run_id: rid,
+                        }) ?? undefined;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+            },
+        });
+        const status = resolveStatus(result);
+        await complete(run, status, {
+            nodeOutputs: result?.nodeOutputs ?? null,
+            // A flow can fail without throwing: the engine catches a handled node
+            // error and RETURNS status 'failed' with the reason on `error`. Missing
+            // it meant a node run showed "failed" in the runs list with nothing
+            // beside it, which is the least useful thing a failed run can say.
+            error: result?.error ?? null,
+            currentNodeId: lastNodeId,
+            metadata: {
+                // So the run view can say which machine ran it, and why it is not in
+                // the cloud's logs.
+                ran_on: 'node',
+                runtime_hostname: os.hostname(),
+                duration_ms: Date.now() - started,
+            },
+        });
+        console.log(`[flows] ${status} ${label} in ${((Date.now() - started) / 1000).toFixed(1)}s`);
+    }
+    catch (err) {
+        // A pause is a normal outcome, not a failure: the flow is sitting on a
+        // form, a webhook or a timer. It releases the slot and the claim; whichever
+        // machine is free when it resumes picks it up.
+        //
+        // Named rather than `instanceof` because the classes live inside the try's
+        // scope, and because a run that failed to load the engine at all has no
+        // classes to compare against.
+        const kind = err?.constructor?.name;
+        if (kind === 'FlowPausedError') {
+            await complete(run, 'waiting', {
+                nodeOutputs: err?.nodeOutputs ?? null,
+                currentNodeId: lastNodeId,
+            });
+            console.log(`[flows] waiting ${label}`);
+            return;
+        }
+        if (kind === 'FlowCancelledError') {
+            await complete(run, 'cancelled', { currentNodeId: lastNodeId });
+            console.log(`[flows] cancelled ${label}`);
+            return;
+        }
+        const message = err?.message || String(err);
+        await complete(run, 'failed', { error: message, currentNodeId: lastNodeId });
+        console.error(`[flows] failed ${label}: ${message}`);
+    }
+}

package/dist/gemini-spawn.js

@@ -104,8 +104,8 @@ function writeGeminiWorkspaceSettings(cwd, servers) {
             ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
         };
     }
-    // Start with the host's settings so auth method (security.auth.selectedType
-    // = oauth-personal etc.) and theme carry through. Override just mcpServers.
+    // Start with the host's settings so auth method and theme carry through.
+    // Override just mcpServers — and the auth type, below.
     const hostSettingsPath = path.join(os.homedir(), '.gemini', 'settings.json');
     let baseSettings = {};
     if (fs.existsSync(hostSettingsPath)) {
@@ -115,6 +115,24 @@ function writeGeminiWorkspaceSettings(cwd, servers) {
         catch { /* corrupt — start fresh */ }
     }
     const merged = { ...baseSettings, mcpServers };
+    // Google retired individual Gemini Code Assist OAuth on 18 June 2026: a CLI
+    // set to 'oauth-personal' now answers IneligibleTierError and points at
+    // Antigravity, whatever else is configured. Most hosts still carry that
+    // retired value in ~/.gemini/settings.json, so inheriting it verbatim means
+    // the run cannot start.
+    //
+    // An API key is the supported path that survives (as is vertex-ai for
+    // enterprise), so when one is present the auth type is forced to match it
+    // rather than trusting whatever the host was left set to. childEnv already
+    // passes GEMINI_API_KEY through from the daemon's own environment.
+    if (process.env.GEMINI_API_KEY) {
+        const security = { ...(baseSettings.security ?? {}) };
+        security.auth = {
+            ...(security.auth ?? {}),
+            selectedType: 'gemini-api-key',
+        };
+        merged.security = security;
+    }
     const settingsPath = path.join(dir, 'settings.json');
     fs.writeFileSync(settingsPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
     return settingsPath;
@@ -274,6 +292,40 @@ function spawnGemini(input) {
     if (input.resumeSessionId && isGeminiSessionId(input.resumeSessionId)) {
         args.push('--resume', input.resumeSessionId);
     }
+    // Fail early and legibly when there is nothing to authenticate with. Without
+    // this the run dies inside gemini with "IneligibleTierError: This client is no
+    // longer supported for Gemini Code Assist for individuals", which reads like
+    // an account problem rather than a missing key on this machine.
+    if (!process.env.GEMINI_API_KEY) {
+        const host = path.join(os.homedir(), '.gemini', 'settings.json');
+        let selected = 'oauth-personal';
+        try {
+            const raw = JSON.parse(fs.readFileSync(host, 'utf8'));
+            selected = raw.security?.auth?.selectedType ?? selected;
+        }
+        catch { /* no host settings — the default is the retired one anyway */ }
+        if (selected === 'oauth-personal') {
+            const events = (0, events_1.bufferedEvents)([
+                {
+                    type: 'error',
+                    code: 'gemini_auth_retired',
+                    message: 'gemini cannot start on this machine: Google retired individual ' +
+                        'Gemini Code Assist OAuth on 18 June 2026, and this host is still set ' +
+                        "to 'oauth-personal'. Set GEMINI_API_KEY on the node (or switch the " +
+                        'host to vertex-ai for an enterprise licence), or point this entity at ' +
+                        'another agent.',
+                },
+                { type: 'turn_complete', stopReason: 'failed' },
+            ]);
+            return {
+                pid: undefined,
+                sessionId: null,
+                kill: () => { },
+                onEvent: events.onEvent,
+                done: Promise.resolve(1),
+            };
+        }
+    }
     // No HOME override — gemini's auth + shell-out tools all need the
     // real $HOME. Workspace-scope settings.json (written above) is enough
     // to override the host's mcpServers without poisoning everything else.

package/dist/grok-spawn.js

@@ -74,7 +74,6 @@ const grok_binary_1 = require("./grok-binary");
 const win_1 = require("./win");
 const events_1 = require("./events");
 const think_split_1 = require("./think-split");
-const mcp_headers_1 = require("./mcp-headers");
 /** Real config dir for the logged-in account. GROK_HOME points here so the
  *  entity uses the same account and token refresh works. */
 function realGrokHome() {
@@ -161,30 +160,16 @@ function writeProjectMcpConfig(workingDirectory, servers) {
     }
     const lines = [];
     for (const s of usable) {
-        // Remote MCP servers. xAI documents [mcp_servers.<name>] with `url` and a
-        // `headers` inline table, so grok now gets them properly instead of the
-        // skip this used to do — a skip that was safe (better than emitting
-        // `command = "http"`, which grok would try to exec) but meant an entity
-        // running on grok silently had none of its remote servers.
-        //
-        // Folder trust still gates repo-local config.toml servers, so the --trust
-        // launch flag remains load-bearing for these entries to start at all.
-        if ((0, mcp_headers_1.isRemoteMcp)(s.command)) {
-            const url = (0, mcp_headers_1.remoteMcpUrl)(s.args);
-            if (!url) {
-                console.error(`[grok] MCP ${s.slug}: ${s.command} server has no URL — skipped`);
-                continue;
-            }
-            lines.push(`[mcp_servers.${tomlStr(s.slug)}]`);
-            lines.push(`url = ${tomlStr(url)}`);
-            const headers = Object.entries((0, mcp_headers_1.remoteMcpHeaders)(s.env));
-            if (headers.length > 0) {
-                const kv = headers.map(([k, v]) => `${tomlStr(k)} = ${tomlStr(v)}`).join(', ');
-                lines.push(`headers = { ${kv} }`);
-            }
-            lines.push('enabled = true');
-            lines.push('startup_timeout_sec = 30');
-            lines.push('');
+        // Remote MCP servers (registry command='http'|'sse', args=[url]) have no
+        // verified grok config spelling, and writing the row verbatim is worse
+        // than skipping: grok would try to exec a binary called `http`, the
+        // server would never start, and its tools would vanish with no error —
+        // the exact silent failure that cost an entity its GitHub access after a
+        // provider-ladder hop. Skip it, and say so loudly enough to be findable.
+        if (s.command === 'http' || s.command === 'sse') {
+            console.error(`[grok] MCP ${s.slug}: remote ${s.command} servers are not supported by the grok ` +
+                `adapter — skipping. Its tools will be ABSENT from this run. Use claude (or codex, ` +
+                `which supports url + bearer_token_env_var) for entities that depend on it.`);
             continue;
         }
         // `cmd /c` wrapper for npm-shim commands on native Windows (no-op on POSIX).

package/dist/heartbeat.js

@@ -13,6 +13,8 @@ const supabase_client_1 = require("./supabase-client");
 const store_1 = require("./store");
 const capabilities_1 = require("./capabilities");
 const request_pump_1 = require("./request-pump");
+const pump_1 = require("./flows/pump");
+const manager_1 = require("./desktop/manager");
 const config_1 = require("./config");
 let timer = null;
 let stopped = false;
@@ -59,6 +61,19 @@ async function tick() {
         // whatever it already had (its own default of 4).
         if (res && res.max_concurrent_runs != null)
             (0, request_pump_1.setMaxConcurrent)(res.max_concurrent_runs);
+        // Flows and desktops ride the same heartbeat for the same reason: they are
+        // fields on this node's own row and we are already talking every 30s.
+        //
+        // Each is applied only when the server actually said something. An older
+        // server that has not had the migration says nothing, and nothing must
+        // read as "leave it alone" — never as "turn flows off" (which would
+        // silently strand a queue) or "cap desktops at zero".
+        if (res && typeof res.flows_enabled === 'boolean')
+            (0, pump_1.setFlowsEnabled)(res.flows_enabled);
+        if (res && res.max_concurrent_flows != null)
+            (0, pump_1.setMaxConcurrentFlows)(res.max_concurrent_flows);
+        if (res && res.max_concurrent_desktops != null)
+            (0, manager_1.setMaxConcurrentDesktops)(res.max_concurrent_desktops);
     }
     catch (err) {
         if (err instanceof supabase_client_1.RpcError && err.status === 401) {
@@ -124,6 +139,15 @@ async function runTick() {
             p_token: pairing.daemonToken,
             p_request_ids: (0, request_pump_1.activeRequestIdList)(),
         });
+        // Flow runs are claimed rows too, and the server's reclaim sweep is just
+        // as capable of requeueing a healthy one that happens to be quiet. Sent in
+        // the same tick so the two never drift apart under load; the empty call
+        // matters, because it is what tells the server this build reports flow
+        // runs at all.
+        await (0, supabase_client_1.rpc)('flow_run_heartbeat', {
+            p_token: pairing.daemonToken,
+            p_run_ids: (0, pump_1.activeFlowRunIds)(),
+        });
         lastRunBeatError = '';
     }
     catch (err) {

package/dist/index.js

@@ -56,6 +56,7 @@ const autostart_1 = require("./autostart");
 const sleep_detector_1 = require("./sleep-detector");
 const claude_config_1 = require("./claude-config");
 const request_pump_1 = require("./request-pump");
+const pump_1 = require("./flows/pump");
 const projects_1 = require("./projects");
 const manager_1 = require("./desktop/manager");
 const relay_client_1 = require("./desktop/relay-client");
@@ -210,6 +211,12 @@ async function start(argv = []) {
     (0, projects_1.start)();
     // …and to keep desktops and the containers behind them in agreement.
     (0, manager_1.startDesktopManager)();
+    // The flows pump starts idle and stays that way until the heartbeat reports
+    // this machine has flows switched on. Starting it unconditionally is right:
+    // the alternative is a daemon that only notices the switch on restart, and
+    // "turn it on, then restart the node" is not a setup step anyone should have
+    // to be told about.
+    (0, pump_1.start)();
     // …and dial out to the relay. That socket is this node's live link: the
     // server pushes work down it the instant it exists, so a command no longer
     // waits up to 30s for the next heartbeat to notice it. The heartbeat and
@@ -231,6 +238,7 @@ async function start(argv = []) {
         (0, manager_1.stopDesktopManager)();
         (0, relay_client_1.stopRelayClient)();
         (0, request_pump_1.stop)();
+        (0, pump_1.stop)();
         (0, heartbeat_1.stop)();
         (0, auto_update_1.stop)();
         sleepMonitor.stop();
@@ -241,10 +249,20 @@ async function start(argv = []) {
         // leave paused flow runs stuck `waiting` until server-side reclaim
         // (5 min) requeued or failed them.
         try {
-            const { drained, timedOut } = await (0, request_pump_1.drain)(drainTimeoutMs);
-            lastDrain = { drained, timedOut };
-            if (drained || timedOut) {
-                console.log(`[shutdown] drained ${drained} request(s); ${timedOut} still in-flight (timed out)`);
+            // Both pools drain against the SAME deadline, in parallel. Draining them
+            // one after the other would give a machine holding both up to twice the
+            // timeout to shut down, and the timeout is there because something
+            // upstream is waiting for this process to be gone.
+            const [requests, flows] = await Promise.all([
+                (0, request_pump_1.drain)(drainTimeoutMs),
+                (0, pump_1.drain)(drainTimeoutMs),
+            ]);
+            lastDrain = { drained: requests.drained, timedOut: requests.timedOut };
+            if (requests.drained || requests.timedOut) {
+                console.log(`[shutdown] drained ${requests.drained} request(s); ${requests.timedOut} still in-flight (timed out)`);
+            }
+            if (flows.drained || flows.timedOut) {
+                console.log(`[shutdown] drained ${flows.drained} flow run(s); ${flows.timedOut} still in-flight (timed out)`);
             }
         }
         catch (err) {

package/dist/mcp-headers.d.ts

@@ -13,3 +13,50 @@ export declare function remoteMcpUrl(args?: string[] | null): string | null;
  * and must never be sent as a header.
  */
 export declare function remoteMcpHeaders(env?: Record<string, string> | null): Record<string, string>;
+/**
+ * Which agents can actually open an HTTP MCP connection, measured against the
+ * real binaries rather than their documentation.
+ *
+ *   claude  YES  — proven in production; entities use these every day.
+ *   codex   YES  — `codex mcp list` shows a `url` entry under Url, enabled.
+ *   kimi    YES  — `kimi mcp list` prints "<slug> (http): <url>".
+ *   gemini  YES  — its shipped bundle treats httpUrl as a network transport
+ *                  (hasNetworkTransport), carries StreamableHTTPClientTransport,
+ *                  and documents "httpUrl (for Streamable HTTP), url (for SSE),
+ *                  and command (for stdio)" with a headers map. Read out of the
+ *                  installed bundle rather than the docs, because docs are what
+ *                  lied about grok. It was never watched connecting, though:
+ *                  gemini-cli cannot authenticate at all on a personal account
+ *                  since Google retired individual Gemini Code Assist OAuth on
+ *                  18 June 2026 (IneligibleTierError -> migrate to Antigravity).
+ *                  API-key and enterprise auth are unaffected. So gemini's
+ *                  blocker is AUTH, not MCP transport — bridging it would fix
+ *                  nothing. No entity runs gemini today.
+ *   grok    NO   — grok 1.0.3 SILENTLY IGNORES url-based entries. In one run it
+ *                  loaded ten stdio servers and skipped every remote one, ours
+ *                  and a third party's, with no error, while its own bundled
+ *                  README documents `url` + `headers`. The docs describe a
+ *                  transport the binary does not have.
+ *
+ * An agent listed here gets its remote servers bridged instead — see
+ * remoteMcpBridge. Add to this set only on evidence from the binary; the whole
+ * point is that "the docs say it works" is not evidence.
+ */
+export declare const AGENTS_WITHOUT_HTTP_MCP: Set<string>;
+export declare function agentNeedsMcpBridge(agent: string): boolean;
+/**
+ * Turn a remote MCP server into a STDIO command, for agents that cannot speak
+ * HTTP MCP themselves.
+ *
+ * mcp-remote is the standard stdio<->HTTP shim, and the one grok's own README
+ * reaches for in its Linear example. Verified end to end against grok 1.0.3:
+ * the bridged server's tools appear and are callable.
+ *
+ * The cost is an npx start per remote server — exactly the cost moving to HTTP
+ * removed — so this is a fallback for the agents that need it, never the
+ * default path.
+ */
+export declare function remoteMcpBridge(url: string, env?: Record<string, string> | null): {
+    command: string;
+    args: string[];
+};

package/dist/mcp-headers.js

@@ -8,9 +8,12 @@
 // inline in install.ts (the claude path) and the other four adapters each got
 // it wrong in their own way, so it lives here now and they all call it.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTS_WITHOUT_HTTP_MCP = void 0;
 exports.isRemoteMcp = isRemoteMcp;
 exports.remoteMcpUrl = remoteMcpUrl;
 exports.remoteMcpHeaders = remoteMcpHeaders;
+exports.agentNeedsMcpBridge = agentNeedsMcpBridge;
+exports.remoteMcpBridge = remoteMcpBridge;
 /** True when a registry row describes a remote MCP server rather than a
  *  local process to spawn. */
 function isRemoteMcp(command) {
@@ -47,3 +50,58 @@ function remoteMcpHeaders(env) {
     }
     return headers;
 }
+/**
+ * Which agents can actually open an HTTP MCP connection, measured against the
+ * real binaries rather than their documentation.
+ *
+ *   claude  YES  — proven in production; entities use these every day.
+ *   codex   YES  — `codex mcp list` shows a `url` entry under Url, enabled.
+ *   kimi    YES  — `kimi mcp list` prints "<slug> (http): <url>".
+ *   gemini  YES  — its shipped bundle treats httpUrl as a network transport
+ *                  (hasNetworkTransport), carries StreamableHTTPClientTransport,
+ *                  and documents "httpUrl (for Streamable HTTP), url (for SSE),
+ *                  and command (for stdio)" with a headers map. Read out of the
+ *                  installed bundle rather than the docs, because docs are what
+ *                  lied about grok. It was never watched connecting, though:
+ *                  gemini-cli cannot authenticate at all on a personal account
+ *                  since Google retired individual Gemini Code Assist OAuth on
+ *                  18 June 2026 (IneligibleTierError -> migrate to Antigravity).
+ *                  API-key and enterprise auth are unaffected. So gemini's
+ *                  blocker is AUTH, not MCP transport — bridging it would fix
+ *                  nothing. No entity runs gemini today.
+ *   grok    NO   — grok 1.0.3 SILENTLY IGNORES url-based entries. In one run it
+ *                  loaded ten stdio servers and skipped every remote one, ours
+ *                  and a third party's, with no error, while its own bundled
+ *                  README documents `url` + `headers`. The docs describe a
+ *                  transport the binary does not have.
+ *
+ * An agent listed here gets its remote servers bridged instead — see
+ * remoteMcpBridge. Add to this set only on evidence from the binary; the whole
+ * point is that "the docs say it works" is not evidence.
+ */
+exports.AGENTS_WITHOUT_HTTP_MCP = new Set(['grok']);
+function agentNeedsMcpBridge(agent) {
+    return exports.AGENTS_WITHOUT_HTTP_MCP.has(agent);
+}
+/**
+ * Turn a remote MCP server into a STDIO command, for agents that cannot speak
+ * HTTP MCP themselves.
+ *
+ * mcp-remote is the standard stdio<->HTTP shim, and the one grok's own README
+ * reaches for in its Linear example. Verified end to end against grok 1.0.3:
+ * the bridged server's tools appear and are callable.
+ *
+ * The cost is an npx start per remote server — exactly the cost moving to HTTP
+ * removed — so this is a fallback for the agents that need it, never the
+ * default path.
+ */
+function remoteMcpBridge(url, env) {
+    const args = ['-y', 'mcp-remote', url];
+    for (const [key, value] of Object.entries(remoteMcpHeaders(env))) {
+        // Spawned without a shell, so "K:V" needs no quoting of its own.
+        args.push('--header', `${key}:${value}`);
+    }
+    // Our servers are streamable HTTP; skip the SSE fallback probing.
+    args.push('--transport', 'http-only');
+    return { command: 'npx', args };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [
@@ -49,6 +49,7 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@addai/node-flows": "^1.0.0",
     "node-pty": "^1.1.0",
     "ws": "^8.21.3"
   },