@reticlehq/server 2.4.0 → 2.6.0

package/dist/mcp-proxy.js

@@ -1,337 +0,0 @@
-import * as http from 'node:http';
-import * as net from 'node:net';
-import { appendFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { LOOPBACK_HOST, MCP_SSE_PATH, ReticleDir } from '@reticlehq/core';
-import { log } from './log.js';
-const DEFAULT_DAEMON_READY_TIMEOUT_MS = 10_000;
-/**
- * How long to wait for the spawned daemon's port to accept connections before giving up. The default
- * suits a normal machine; a slow CI/VM (heavy headless-browser launch) can raise it via the
- * RETICLE_DAEMON_READY_TIMEOUT_MS env var. Invalid/absent values fall back to the default.
- */
-const envDaemonReadyTimeoutMs = Number(process.env['RETICLE_DAEMON_READY_TIMEOUT_MS']);
-const DAEMON_READY_TIMEOUT_MS = Number.isFinite(envDaemonReadyTimeoutMs) && envDaemonReadyTimeoutMs > 0
-    ? envDaemonReadyTimeoutMs
-    : DEFAULT_DAEMON_READY_TIMEOUT_MS;
-const DAEMON_POLL_INTERVAL_MS = 100;
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/** Reconnect backoff: linear, capped, so a briefly-restarting daemon is picked up fast. */
-const RECONNECT_BASE_MS = 250;
-const RECONNECT_CAP_MS = 5_000;
-/**
- * How many consecutive failed reconnects before the proxy gives up and exits. At the capped backoff
- * this is a few minutes — long enough to ride out a daemon restart, short enough that a genuinely
- * dead daemon lets the agent host respawn the proxy (which spawns a fresh daemon) instead of hanging.
- */
-export const MAX_RECONNECT_ATTEMPTS = 60;
-export function reconnectDelayMs(attempt) {
-    return Math.min(RECONNECT_BASE_MS * attempt, RECONNECT_CAP_MS);
-}
-/** JSON-RPC id the proxy uses for its own replayed `initialize` — never one the client could send. */
-export const RECONNECT_INITIALIZE_ID = '__reticle_proxy_reinit';
-/** The proxy's own log file, so a silent drop leaves a readable trace the agent can go read. */
-export function proxyLogPath() {
-    return join(homedir(), ReticleDir.ROOT, 'mcp-proxy.log');
-}
-/**
- * Log to stderr (which the agent host usually swallows) AND to ~/.reticle/mcp-proxy.log, which it
- * does not. A dropped MCP connection is invisible from the agent's side — no message, no exit code —
- * so the one thing that makes it diagnosable at all is a file somebody can read afterwards.
- */
-function proxyLog(event, fields = {}) {
-    log(event, fields);
-    try {
-        const dir = join(homedir(), ReticleDir.ROOT);
-        mkdirSync(dir, { recursive: true });
-        appendFileSync(proxyLogPath(), `${JSON.stringify({ event, ...fields })}\n`, 'utf8');
-    }
-    catch {
-        // Logging must never be the thing that kills the proxy.
-    }
-}
-function parseJsonRpc(line) {
-    try {
-        const parsed = JSON.parse(line);
-        return typeof parsed === 'object' && parsed !== null ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-const INITIALIZE_METHOD = 'initialize';
-const INITIALIZED_METHOD = 'notifications/initialized';
-/**
- * Makes a reconnect invisible to the client.
- *
- * The daemon builds a FRESH `McpServer` per SSE connection, so a reconnected session has never seen
- * the client's `initialize` — every subsequent `tools/call` would hit an uninitialized server. The
- * proxy therefore remembers the handshake the client sent once and replays it into each new session.
- * The replay is re-issued under a reserved id so the daemon's response to it can be dropped rather
- * than reaching the client's stdout, where a duplicate JSON-RPC id would be a protocol violation.
- */
-export class HandshakeReplay {
-    #initialize = null;
-    #initialized = null;
-    #pendingReplayId = null;
-    /** Record one outbound client line. Cheap enough to call for every stdin message. */
-    observeOutbound(line) {
-        const msg = parseJsonRpc(line);
-        if (msg === null)
-            return;
-        // The first initialize is the session's identity; a client re-issuing one does not change it.
-        if (msg.method === INITIALIZE_METHOD && this.#initialize === null)
-            this.#initialize = line;
-        else if (msg.method === INITIALIZED_METHOD)
-            this.#initialized = line;
-    }
-    /** Lines to POST into a freshly-established session, before any queued client traffic. */
-    replayLines() {
-        if (this.#initialize === null)
-            return [];
-        const msg = parseJsonRpc(this.#initialize);
-        if (msg === null)
-            return [];
-        this.#pendingReplayId = RECONNECT_INITIALIZE_ID;
-        const reinit = { ...msg, id: RECONNECT_INITIALIZE_ID };
-        return this.#initialized === null
-            ? [JSON.stringify(reinit)]
-            : [JSON.stringify(reinit), this.#initialized];
-    }
-    /** True when this inbound daemon line is the echo of our replayed handshake and must not be forwarded. */
-    shouldSuppressInbound(line) {
-        if (this.#pendingReplayId === null)
-            return false;
-        const msg = parseJsonRpc(line);
-        if (msg === null || msg.id !== this.#pendingReplayId)
-            return false;
-        this.#pendingReplayId = null; // one response per replay — anything later is not ours to swallow
-        return true;
-    }
-}
-/**
- * Incremental SSE frame parser for the MCP front door.
- *
- * A single SSE field can split across TCP reads (`da` in one chunk, `ta: {...}` in the next), and a
- * server may send CRLF or bare CR line endings — so the framing is stateful and edge-case-prone, yet it
- * carried every MCP message the agent sends and was only ever exercised end-to-end. Pulled out of the
- * socket handler as a pure, chunk-fed parser so those boundaries are unit-testable: feed raw chunks,
- * get back each complete frame (a blank line terminates a frame; `event:` names it, `data:` lines
- * accumulate newline-joined; `id:`/`retry:`/comments are ignored — not needed for the bridge).
- */
-export class SseFrameParser {
-    #buffer = '';
-    #event = '';
-    #data = '';
-    push(chunk) {
-        this.#buffer += chunk;
-        // Normalise CRLF/CR so the splitter only handles \n, then hold the trailing partial line for the
-        // next chunk (it may complete later).
-        const normalised = this.#buffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-        const lines = normalised.split('\n');
-        this.#buffer = lines.pop() ?? '';
-        const frames = [];
-        for (const line of lines) {
-            if (line === '') {
-                if (this.#data !== '') {
-                    frames.push({ event: this.#event !== '' ? this.#event : 'message', data: this.#data });
-                }
-                this.#event = '';
-                this.#data = '';
-            }
-            else if (line.startsWith('event:')) {
-                this.#event = line.slice(6).trim();
-            }
-            else if (line.startsWith('data:')) {
-                const val = line.slice(5).trim();
-                this.#data = this.#data !== '' ? `${this.#data}\n${val}` : val;
-            }
-        }
-        return frames;
-    }
-}
-/**
- * Returns true if something is already listening on the reticle port.
- * Uses a plain TCP probe so we don't create a side-effectful SSE session
- * inside the daemon just to check reachability.
- */
-export function probeDaemon(port) {
-    return new Promise((resolve) => {
-        const socket = new net.Socket();
-        socket.setTimeout(500);
-        socket.on('connect', () => {
-            socket.destroy();
-            resolve(true);
-        });
-        socket.on('error', () => resolve(false));
-        socket.on('timeout', () => {
-            socket.destroy();
-            resolve(false);
-        });
-        socket.connect(port, LOOPBACK_HOST);
-    });
-}
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export async function waitForDaemon(port) {
-    const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        const reachable = await probeDaemon(port);
-        if (reachable)
-            return;
-        await delay(DAEMON_POLL_INTERVAL_MS);
-    }
-    throw new Error(`reticle daemon did not become ready on port ${port} within ${DAEMON_READY_TIMEOUT_MS}ms`);
-}
-function postToSession(url, body) {
-    return new Promise((resolve) => {
-        const parsed = new URL(url);
-        const bodyBuf = Buffer.from(body, 'utf8');
-        const options = {
-            host: parsed.hostname,
-            port: parsed.port !== '' ? parseInt(parsed.port, 10) : 80,
-            path: `${parsed.pathname}${parsed.search}`,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': bodyBuf.byteLength,
-            },
-        };
-        const req = http.request(options, (res) => {
-            const status = res.statusCode ?? 0;
-            if (status < 200 || status >= 300) {
-                // A non-2xx from the daemon MCP endpoint used to be swallowed, hanging the JSON-RPC call
-                // client-side with no diagnostic. Surface it (the forward is still fire-and-forget).
-                log('reticle_mcp_proxy_post_non2xx', { status, path: options.path });
-            }
-            res.resume(); // drain so the socket is reused
-            resolve();
-        });
-        req.on('error', (err) => {
-            log('reticle_mcp_proxy_post_error', { error: err.message });
-            resolve();
-        });
-        req.write(bodyBuf);
-        req.end();
-    });
-}
-export function buildSessionUrl(rawData, port) {
-    return rawData.startsWith('/') ? `http://${LOOPBACK_HOST}:${port}${rawData}` : rawData;
-}
-/**
- * Bridge stdio ↔ SSE: connects to the running daemon's MCP endpoint and forwards
- * Claude Code's stdin/stdout JSON-RPC through it. Never resolves — runs until stdin closes.
- *
- * A dropped SSE stream used to exit the process, which is what made the agent's `reticle_*` tools
- * vanish mid-session with no message and no way for the agent to get them back — only a human running
- * `/mcp` could. The daemon demonstrably stays up across these drops, so the stream ending is a
- * transport event, not a shutdown: reconnect to it and replay the handshake instead of dying.
- */
-export function startMcpProxy(port) {
-    return new Promise((_resolve, reject) => {
-        let postUrl = null;
-        const stdinQueue = [];
-        const replay = new HandshakeReplay();
-        let stopped = false;
-        let attempts = 0;
-        function onSseEvent(event, data, p) {
-            if (event === 'endpoint') {
-                const url = buildSessionUrl(data, p);
-                postUrl = url;
-                // The new session's McpServer has never seen the client's initialize — replay it first, then
-                // flush whatever the client sent while we were reconnecting.
-                for (const line of replay.replayLines())
-                    void postToSession(url, line);
-                for (const queued of stdinQueue.splice(0))
-                    void postToSession(url, queued);
-                return;
-            }
-            if (event === 'message' && !replay.shouldSuppressInbound(data)) {
-                process.stdout.write(`${data}\n`);
-            }
-        }
-        function scheduleReconnect(reason, detail) {
-            if (stopped)
-                return;
-            postUrl = null;
-            attempts++;
-            if (attempts > MAX_RECONNECT_ATTEMPTS) {
-                proxyLog('reticle_mcp_proxy_gave_up', {
-                    port,
-                    reason,
-                    attempts,
-                    ...(detail !== undefined ? { detail } : {}),
-                });
-                process.exit(1);
-            }
-            const wait = reconnectDelayMs(attempts);
-            proxyLog('reticle_mcp_proxy_reconnecting', {
-                port,
-                reason,
-                attempt: attempts,
-                retryInMs: wait,
-                ...(detail !== undefined ? { detail } : {}),
-            });
-            setTimeout(() => connect(false), wait).unref();
-        }
-        function connect(first) {
-            const req = http.get({ host: LOOPBACK_HOST, port, path: MCP_SSE_PATH }, (res) => {
-                attempts = 0; // a stream we actually established resets the budget
-                if (!first)
-                    proxyLog('reticle_mcp_proxy_reconnected', { port });
-                res.setEncoding('utf8');
-                // `end` and `error` can both fire on one response; only the first should drive a reconnect.
-                let settled = false;
-                const drop = (reason, detail) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    scheduleReconnect(reason, detail);
-                };
-                const sse = new SseFrameParser();
-                res.on('data', (chunk) => {
-                    for (const frame of sse.push(chunk))
-                        onSseEvent(frame.event, frame.data, port);
-                });
-                res.on('end', () => drop('sse_ended'));
-                res.on('error', (err) => drop('sse_error', err.message));
-                // A socket dying under us (daemon killed, network stack reset) emits NEITHER `end` nor
-                // `error` — only `aborted`/`close`. Listening for just the first two is why the proxy sat
-                // there afterwards holding a dead stream. `settled` keeps the clean case single-fire.
-                res.on('aborted', () => drop('sse_aborted'));
-                res.on('close', () => drop('sse_closed'));
-            });
-            // The very first connect failing means there is no daemon to talk to — that is a startup
-            // failure the caller handles. Later ones are just the daemon bouncing: keep retrying.
-            req.on('error', (err) => (first ? reject(err) : scheduleReconnect('connect_error', err.message)));
-        }
-        connect(true);
-        // ── stdin reader ─────────────────────────────────────────────────────────
-        process.stdin.setEncoding('utf8');
-        let stdinBuffer = '';
-        process.stdin.on('data', (chunk) => {
-            stdinBuffer += chunk;
-            const lines = stdinBuffer.split('\n');
-            stdinBuffer = lines.pop() ?? '';
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed === '')
-                    continue;
-                replay.observeOutbound(trimmed);
-                if (postUrl === null) {
-                    stdinQueue.push(trimmed);
-                }
-                else {
-                    void postToSession(postUrl, trimmed);
-                }
-            }
-        });
-        // The client going away is the one clean shutdown — stop reconnecting and exit.
-        process.stdin.on('end', () => {
-            stopped = true;
-            process.exit(0);
-        });
-    });
-}

package/dist/tools/profiles.d.ts

@@ -1,37 +0,0 @@
-import type { ToolDef } from './tools.js';
-/**
- * Which MCP tool surface to expose. The advertised tool DEFINITIONS are re-sent to the model on
- * every turn, so a smaller surface is a per-turn token saving that compounds across a loop. Fewer
- * tools also makes the model wander less (fewer turns, higher accuracy). See bench/agent-loop-and-replay.md.
- *
- * MEASURED surface sizes (assert them with profile-reachability.test.ts rather than trusting prose —
- * every count previously written here was wrong, and the token figures below derive from those counts):
- *   core 15 · standard 32 · hybrid 15 · full 43 · dynamic 2
- * core and hybrid are both 14 because a trimmed profile now also advertises the two meta-tools, which
- * is what keeps an un-advertised tool reachable through reticle_run.
- *
- * core — the verify loop a coding agent actually needs: navigate→look→act→observe→assert,
- * WITH direct network + console + state observability (the highest-signal checks).
- * The recommended profile for agent-driven verification.
- * standard — core + common extras (inspect, sequences, animations, flows, session lifecycle,
- * scroll, baselines, …). For agents that need more than the bare loop.
- * hybrid — THE DEFAULT: core verify+oracle tools advertised directly + 2 meta-tools for on-demand
- * reach to everything else. Core accuracy/detection at ~64% less schema tax than full.
- * full — all tools advertised directly. Opt in via RETICLE_TOOL_PROFILE=full for hard-call scripts.
- */
-export declare const TOOL_PROFILE: {
-    /** dynamic — advertise only 2 meta-tools (reticle_tools + reticle_run); load real tools on demand.
-     * Fixed ~hundreds of tokens/turn regardless of how many tools exist. See dynamic-tools.ts. */
-    readonly DYNAMIC: "dynamic";
-    /** hybrid — the core verify tools advertised directly (so the agent acts reliably) PLUS the 2
-     * meta-tools for on-demand reach to every other tool. Core accuracy + full reach at ~core cost. */
-    readonly HYBRID: "hybrid";
-    readonly CORE: "core";
-    readonly STANDARD: "standard";
-    readonly FULL: "full";
-};
-export type ToolProfile = (typeof TOOL_PROFILE)[keyof typeof TOOL_PROFILE];
-export declare const TOOL_PROFILE_ENV = "RETICLE_TOOL_PROFILE";
-export declare const CORE_TOOL_NAMES: ReadonlySet<string>;
-export declare function resolveToolProfile(explicit?: string): ToolProfile;
-export declare function filterTools(tools: ToolDef[], profile: ToolProfile): ToolDef[];

package/dist/tools/profiles.js

@@ -1,139 +0,0 @@
-import { ReticleTool } from './tool-names.js';
-/**
- * Which MCP tool surface to expose. The advertised tool DEFINITIONS are re-sent to the model on
- * every turn, so a smaller surface is a per-turn token saving that compounds across a loop. Fewer
- * tools also makes the model wander less (fewer turns, higher accuracy). See bench/agent-loop-and-replay.md.
- *
- * MEASURED surface sizes (assert them with profile-reachability.test.ts rather than trusting prose —
- * every count previously written here was wrong, and the token figures below derive from those counts):
- *   core 15 · standard 32 · hybrid 15 · full 43 · dynamic 2
- * core and hybrid are both 14 because a trimmed profile now also advertises the two meta-tools, which
- * is what keeps an un-advertised tool reachable through reticle_run.
- *
- * core — the verify loop a coding agent actually needs: navigate→look→act→observe→assert,
- * WITH direct network + console + state observability (the highest-signal checks).
- * The recommended profile for agent-driven verification.
- * standard — core + common extras (inspect, sequences, animations, flows, session lifecycle,
- * scroll, baselines, …). For agents that need more than the bare loop.
- * hybrid — THE DEFAULT: core verify+oracle tools advertised directly + 2 meta-tools for on-demand
- * reach to everything else. Core accuracy/detection at ~64% less schema tax than full.
- * full — all tools advertised directly. Opt in via RETICLE_TOOL_PROFILE=full for hard-call scripts.
- */
-export const TOOL_PROFILE = {
-    /** dynamic — advertise only 2 meta-tools (reticle_tools + reticle_run); load real tools on demand.
-     * Fixed ~hundreds of tokens/turn regardless of how many tools exist. See dynamic-tools.ts. */
-    DYNAMIC: 'dynamic',
-    /** hybrid — the core verify tools advertised directly (so the agent acts reliably) PLUS the 2
-     * meta-tools for on-demand reach to every other tool. Core accuracy + full reach at ~core cost. */
-    HYBRID: 'hybrid',
-    CORE: 'core',
-    STANDARD: 'standard',
-    FULL: 'full',
-};
-export const TOOL_PROFILE_ENV = 'RETICLE_TOOL_PROFILE';
-// The set an agent needs to verify a change end-to-end. Tool DEFINITIONS are re-sent every turn, so a
-// smaller surface compounds.
-//
-// MEASURED per-turn `tools/list` cost — the bytes an MCP client re-sends EVERY turn — taken off the
-// real wire (spawn `mcp`, read tools/list, measure the serialized result), not estimated:
-//
-//   dynamic     2 tools    1,531 B   ~383 tok/turn
-//   core       15 tools   14,104 B  ~3,526 tok/turn
-//   hybrid     15 tools   14,104 B  ~3,526 tok/turn
-//   standard   32 tools   26,769 B  ~6,692 tok/turn
-//   full       43 tools  105,061 B ~26,265 tok/turn
-//
-// These REPLACE the previous figures (core 6,479 / standard 13,951 / full 20,441), which the comment
-// itself flagged as stale. Two of the three moved in opposite directions, which is why re-measuring
-// mattered: the lean profiles got much CHEAPER because they now drop the advertised outputSchema,
-// while `full` got much more EXPENSIVE because it still carries it — the gap between lean and full is
-// 7.4x, not the ~3x the old numbers implied.
-//
-// Where the remaining cost sits, on the hybrid default: inputSchema is 76% of the payload (parameter
-// descriptions are half of that), tool descriptions are 12%, and outputSchema is already ~0. So the
-// next real saving is in parameter prose, not in dropping more tools.
-//
-// There is a floor, though: an 8-tool cut (dropping act/navigate/wait_for/sessions) was MEASURED to
-// regress real-agent accuracy 5/5 -> 3/5, because the model loses scaffolding and wanders on harder
-// flows. Direct network/console stay (far more discoverable than observe-with-filters -> fewer turns,
-// better verdicts).
-//
-// Evidence status: the 5/5 figure came from a single gpt-4o run and is STALE as a justification.
-// Current-model evidence is indirect but real — the cost-delta run (bench/fix-loop/COST-DELTA.md)
-// drove this hybrid default on a current model and fixed 4/4 cells with ~25% FEWER tool calls than
-// the baseline. A formal core-vs-hybrid A/B on a current model is still UNRUN; do not quote the 5/5
-// number as if it were current. See bench/agent-loop-and-replay.md.
-export const CORE_TOOL_NAMES = new Set([
-    ReticleTool.SESSIONS,
-    ReticleTool.NAVIGATE,
-    ReticleTool.SNAPSHOT,
-    ReticleTool.QUERY,
-    ReticleTool.ACT,
-    ReticleTool.ACT_AND_WAIT,
-    ReticleTool.OBSERVE,
-    ReticleTool.NETWORK,
-    ReticleTool.CONSOLE,
-    ReticleTool.WAIT_FOR,
-    ReticleTool.ASSERT,
-    ReticleTool.STATE,
-    // INSPECT is what turns a finding into an EDIT: it maps a DOM node to `src/App.tsx:104`. Finding a
-    // bug is half the job; knowing which file to open is the half that makes the agent useful, and it
-    // is the one capability here with no substitute in any other verification tool. It sat in
-    // `standard`, so under the default profile an agent had to already know it existed and reach it
-    // through reticle_run — which, observed over a full 43-tool drive, means it never gets called.
-    // The measured floor that justifies a lean core was about CUTTING to 8 (accuracy 5/5 → 3/5), not
-    // about holding at 12; one tool of schema tax to close the find→fix loop is the right trade.
-    ReticleTool.INSPECT,
-    // FEEDBACK is in every profile for the same reason INSPECT is: a tool an agent has to already know
-    // about, and reach through reticle_run, is a tool that never gets called. That is fatal here in a way
-    // it is not elsewhere — an unadvertised feedback channel collects nothing, which is indistinguishable
-    // from not having built one. It is also the cheapest tool on the surface to carry (three params) and
-    // the only one whose whole purpose is telling us which of the other fifteen are failing.
-    ReticleTool.FEEDBACK,
-]);
-const STANDARD_TOOL_NAMES = new Set([
-    ...CORE_TOOL_NAMES,
-    ReticleTool.ACT_SEQUENCE,
-    ReticleTool.NETWORK,
-    ReticleTool.CONSOLE,
-    ReticleTool.ANIMATIONS,
-    ReticleTool.FLOW_SAVE,
-    ReticleTool.FLOW_REPLAY,
-    ReticleTool.FLOW_VERIFY,
-    ReticleTool.FLOW_HEAL,
-    ReticleTool.SESSION, // merged lifecycle/human-channel family
-    ReticleTool.FLOW, // merged flow list/load/delete
-    ReticleTool.RECORD, // merged record start/stop
-    ReticleTool.BASELINE, // merged baseline save/list/diff
-    ReticleTool.SCROLL_TO,
-    ReticleTool.CRAWL,
-    ReticleTool.REPLAY,
-    ReticleTool.EXPLORE,
-    ReticleTool.CONTRACT_SAVE,
-    ReticleTool.NETWORK_MOCK,
-    ReticleTool.VIEWPORT,
-]);
-export function resolveToolProfile(explicit) {
-    const raw = explicit ?? process.env[TOOL_PROFILE_ENV];
-    if (raw === TOOL_PROFILE.DYNAMIC)
-        return TOOL_PROFILE.DYNAMIC;
-    if (raw === TOOL_PROFILE.HYBRID)
-        return TOOL_PROFILE.HYBRID;
-    if (raw === TOOL_PROFILE.CORE)
-        return TOOL_PROFILE.CORE;
-    if (raw === TOOL_PROFILE.STANDARD)
-        return TOOL_PROFILE.STANDARD;
-    if (raw === TOOL_PROFILE.FULL)
-        return TOOL_PROFILE.FULL;
-    // Default: hybrid — the core verify+oracle tools advertised directly (no detection loss, verified
-    // 10/10 on the regression bench) PLUS the 2 meta-tools for on-demand reach to every other tool. ~64%
-    // less per-turn schema than `full` at the same accuracy. Explicit `full` still opts into all tools.
-    return TOOL_PROFILE.HYBRID;
-}
-export function filterTools(tools, profile) {
-    if (profile === TOOL_PROFILE.CORE)
-        return tools.filter((t) => CORE_TOOL_NAMES.has(t.name));
-    if (profile === TOOL_PROFILE.STANDARD)
-        return tools.filter((t) => STANDARD_TOOL_NAMES.has(t.name));
-    return tools;
-}