langflower 0.1.0 → 0.1.1

package/vendor/tools/dist/kb/kb-store.js

@@ -1,246 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import { cosineSimilarity } from './cosine.js';
-import { chunkText } from './chunk-text.js';
-import { kbChunksPath, kbCollectionDir, kbManifestPath, kbRootDir, kbVectorsPath, sanitizeCollectionId, } from './kb-paths.js';
-import { embedTextLocal, LOCAL_EMBED_DIMS } from './local-embed.js';
-const emptyManifest = () => ({ collections: [] });
-const readJsonFile = async (filePath, fallback) => {
-    try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return fallback;
-        }
-        throw error;
-    }
-};
-const ensureDir = async (dir) => {
-    await fs.mkdir(dir, { recursive: true });
-};
-const readChunks = async (projectDir, collectionId) => {
-    const filePath = kbChunksPath(projectDir, collectionId);
-    try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        return raw
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .map((line) => JSON.parse(line));
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-};
-const writeChunks = async (projectDir, collectionId, chunks) => {
-    await ensureDir(kbCollectionDir(projectDir, collectionId));
-    const body = chunks.length === 0
-        ? ''
-        : `${chunks.map((chunk) => JSON.stringify(chunk)).join('\n')}\n`;
-    await fs.writeFile(kbChunksPath(projectDir, collectionId), body, 'utf8');
-};
-const readVectors = async (projectDir, collectionId, dims, expectedCount) => {
-    const filePath = kbVectorsPath(projectDir, collectionId);
-    try {
-        const buf = await fs.readFile(filePath);
-        const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
-        if (dims <= 0 || floats.length === 0) {
-            return [];
-        }
-        const count = Math.floor(floats.length / dims);
-        const vectors = [];
-        for (let i = 0; i < count; i += 1) {
-            vectors.push(floats.slice(i * dims, (i + 1) * dims));
-        }
-        if (expectedCount > 0 && vectors.length !== expectedCount) {
-            return vectors.slice(0, Math.min(vectors.length, expectedCount));
-        }
-        return vectors;
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-};
-const writeVectors = async (projectDir, collectionId, vectors) => {
-    await ensureDir(kbCollectionDir(projectDir, collectionId));
-    if (vectors.length === 0) {
-        await fs.writeFile(kbVectorsPath(projectDir, collectionId), Buffer.alloc(0));
-        return;
-    }
-    const dims = vectors[0].length;
-    const out = new Float32Array(vectors.length * dims);
-    for (let i = 0; i < vectors.length; i += 1) {
-        const vec = vectors[i];
-        if (vec.length !== dims) {
-            throw new Error('vector dimension mismatch in collection');
-        }
-        out.set(vec, i * dims);
-    }
-    await fs.writeFile(kbVectorsPath(projectDir, collectionId), Buffer.from(out.buffer, out.byteOffset, out.byteLength));
-};
-const touchManifest = async (projectDir, collectionId, chunkCount) => {
-    await ensureDir(kbRootDir(projectDir));
-    const id = sanitizeCollectionId(collectionId);
-    const manifest = await readJsonFile(kbManifestPath(projectDir), emptyManifest());
-    const updatedAt = new Date().toISOString();
-    const others = manifest.collections.filter((entry) => entry.id !== id);
-    const next = {
-        collections: [...others, { id, updatedAt, chunkCount }].sort((a, b) => a.id.localeCompare(b.id)),
-    };
-    await fs.writeFile(kbManifestPath(projectDir), `${JSON.stringify(next, null, '\t')}\n`, 'utf8');
-};
-const defaultEmbedTexts = async (texts) => texts.map((text) => embedTextLocal(text));
-export const ingestText = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const pieces = chunkText(args.text);
-    if (pieces.length === 0) {
-        return [];
-    }
-    const documentId = args.documentId?.trim() || randomUUID();
-    const existing = await readChunks(args.projectDir, collectionId);
-    const created = pieces.map((text, index) => ({
-        id: `${documentId}:${index}`,
-        text,
-        meta: {
-            documentId,
-            chunkIndex: index,
-            ...(args.source !== undefined && args.source.length > 0
-                ? { source: args.source }
-                : {}),
-        },
-    }));
-    const next = [...existing, ...created];
-    await writeChunks(args.projectDir, collectionId, next);
-    // New chunks invalidate trailing vectors; keep prefix alignment only when
-    // previous vectors match prior chunk count.
-    const priorVectors = await readVectors(args.projectDir, collectionId, LOCAL_EMBED_DIMS, existing.length);
-    const kept = priorVectors.length === existing.length
-        ? priorVectors
-        : [];
-    await writeVectors(args.projectDir, collectionId, kept);
-    await touchManifest(args.projectDir, collectionId, next.length);
-    return created.map((chunk) => chunk.id);
-};
-export const embedCollection = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return 0;
-    }
-    const embedTexts = args.embedTexts ?? defaultEmbedTexts;
-    const vectors = await embedTexts(chunks.map((chunk) => chunk.text));
-    await writeVectors(args.projectDir, collectionId, vectors);
-    await touchManifest(args.projectDir, collectionId, chunks.length);
-    return vectors.length;
-};
-export const searchCollection = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const topK = Math.max(1, args.topK ?? 5);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return [];
-    }
-    const embedTexts = args.embedTexts ?? defaultEmbedTexts;
-    const queryVec = (await embedTexts([args.query]))[0];
-    if (queryVec === undefined) {
-        return [];
-    }
-    let vectors = await readVectors(args.projectDir, collectionId, queryVec.length, chunks.length);
-    if (vectors.length !== chunks.length) {
-        vectors = [...(await embedTexts(chunks.map((chunk) => chunk.text)))];
-        await writeVectors(args.projectDir, collectionId, vectors);
-    }
-    const ranked = chunks
-        .map((chunk, index) => ({
-        id: chunk.id,
-        text: chunk.text,
-        meta: chunk.meta,
-        score: cosineSimilarity(queryVec, vectors[index]),
-    }))
-        .sort((a, b) => b.score - a.score)
-        .slice(0, topK);
-    return ranked;
-};
-export const listKb = async (args) => {
-    const manifest = await readJsonFile(kbManifestPath(args.projectDir), emptyManifest());
-    const collectionFilter = args.collectionId?.trim();
-    if (collectionFilter === undefined || collectionFilter.length === 0) {
-        return manifest.collections.map((entry) => ({
-            kind: 'collection',
-            id: entry.id,
-            detail: `${entry.chunkCount} chunks`,
-        }));
-    }
-    const collectionId = sanitizeCollectionId(collectionFilter);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    const byDoc = new Map();
-    for (const chunk of chunks) {
-        const documentId = typeof chunk.meta.documentId === 'string'
-            ? chunk.meta.documentId
-            : chunk.id;
-        byDoc.set(documentId, (byDoc.get(documentId) ?? 0) + 1);
-    }
-    return [...byDoc.entries()].map(([id, count]) => ({
-        kind: 'document',
-        id,
-        detail: `${count} chunks`,
-    }));
-};
-export const deleteFromKb = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return 0;
-    }
-    const chunkIdSet = args.chunkIds !== undefined && args.chunkIds.length > 0
-        ? new Set(args.chunkIds)
-        : null;
-    const documentId = args.documentId?.trim() ?? '';
-    const deleteAll = chunkIdSet === null && documentId.length === 0;
-    if (deleteAll) {
-        await fs.rm(kbCollectionDir(args.projectDir, collectionId), {
-            recursive: true,
-            force: true,
-        });
-        const manifest = await readJsonFile(kbManifestPath(args.projectDir), emptyManifest());
-        const nextManifest = {
-            collections: manifest.collections.filter((entry) => entry.id !== collectionId),
-        };
-        await ensureDir(kbRootDir(args.projectDir));
-        await fs.writeFile(kbManifestPath(args.projectDir), `${JSON.stringify(nextManifest, null, '\t')}\n`, 'utf8');
-        return chunks.length;
-    }
-    const next = chunks.filter((chunk) => {
-        if (chunkIdSet !== null && chunkIdSet.has(chunk.id)) {
-            return false;
-        }
-        if (documentId.length > 0 && chunk.meta.documentId === documentId) {
-            return false;
-        }
-        return true;
-    });
-    const removed = chunks.length - next.length;
-    await writeChunks(args.projectDir, collectionId, next);
-    // Drop vectors — re-embed after selective delete.
-    await writeVectors(args.projectDir, collectionId, []);
-    await touchManifest(args.projectDir, collectionId, next.length);
-    return removed;
-};
-//# sourceMappingURL=kb-store.js.map

package/vendor/tools/dist/kb/local-embed.d.ts

@@ -1,8 +0,0 @@
-/** Fixed local embedding size (hashing trick). Offline MVP for epic 10. */
-export declare const LOCAL_EMBED_DIMS = 64;
-/**
- * Deterministic bag-of-tokens hashing embedder. Good enough for fixture
- * relevance tests without an external embedding API.
- */
-export declare const embedTextLocal: (text: string) => Float32Array;
-//# sourceMappingURL=local-embed.d.ts.map

package/vendor/tools/dist/kb/local-embed.js

@@ -1,41 +0,0 @@
-/** Fixed local embedding size (hashing trick). Offline MVP for epic 10. */
-export const LOCAL_EMBED_DIMS = 64;
-/**
- * Deterministic bag-of-tokens hashing embedder. Good enough for fixture
- * relevance tests without an external embedding API.
- */
-export const embedTextLocal = (text) => {
-    const vec = new Float32Array(LOCAL_EMBED_DIMS);
-    const tokens = text
-        .toLowerCase()
-        .split(/[^a-z0-9_]+/i)
-        .filter((token) => token.length > 0);
-    for (const token of tokens) {
-        let hash = 2166136261;
-        for (let i = 0; i < token.length; i += 1) {
-            hash ^= token.charCodeAt(i);
-            hash = Math.imul(hash, 16777619);
-        }
-        const index = (hash >>> 0) % LOCAL_EMBED_DIMS;
-        vec[index] = (vec[index] ?? 0) + 1;
-        const index2 = ((hash >>> 8) ^ token.length) % LOCAL_EMBED_DIMS;
-        vec[index2] = (vec[index2] ?? 0) + 0.5;
-    }
-    return l2Normalize(vec);
-};
-const l2Normalize = (vec) => {
-    let sumSquares = 0;
-    for (let i = 0; i < vec.length; i += 1) {
-        sumSquares += vec[i] * vec[i];
-    }
-    if (sumSquares <= 0) {
-        return vec;
-    }
-    const scale = 1 / Math.sqrt(sumSquares);
-    const out = new Float32Array(vec.length);
-    for (let i = 0; i < vec.length; i += 1) {
-        out[i] = vec[i] * scale;
-    }
-    return out;
-};
-//# sourceMappingURL=local-embed.js.map

package/vendor/tools/dist/mcp/build-mcp-handle.d.ts

@@ -1,12 +0,0 @@
-import type { ToolHandle } from '@langflower/node-sdk';
-import type { McpClient } from './mcp-client-types.js';
-/**
- * After connect: list tools once and bind invoke closures.
- * Optional `toolNamesRaw` filters for system MCP jsonc; canvas nodes omit it
- * and expose the full `tools/list` inventory. Tool ids use `client.serverName`
- * (`<mcp_name>__<tool>`).
- */
-export declare const buildMcpHandle: (options: {
-    readonly toolNamesRaw?: unknown;
-    readonly client: McpClient;
-}) => Promise<readonly ToolHandle[]>;

package/vendor/tools/dist/mcp/build-mcp-handle.js

@@ -1,56 +0,0 @@
-import { encodeMcpToolId } from './mcp-tool-id.js';
-const parseToolNames = (raw) => {
-    if (typeof raw !== 'string') {
-        return [];
-    }
-    return raw
-        .split(/[,\s]+/)
-        .map((name) => name.trim())
-        .filter((name) => name.length > 0);
-};
-/**
- * After connect: list tools once and bind invoke closures.
- * Optional `toolNamesRaw` filters for system MCP jsonc; canvas nodes omit it
- * and expose the full `tools/list` inventory. Tool ids use `client.serverName`
- * (`<mcp_name>__<tool>`).
- */
-export const buildMcpHandle = async (options) => {
-    const mcpName = options.client.serverName.trim();
-    if (mcpName.length === 0) {
-        throw new Error('MCP client.serverName is empty.');
-    }
-    const toolNames = parseToolNames(options.toolNamesRaw);
-    const listed = await options.client.listTools();
-    const allowedIds = toolNames.length === 0
-        ? undefined
-        : new Set(toolNames
-            .map((toolName) => encodeMcpToolId(mcpName, toolName))
-            .filter((toolId) => toolId.length > 0));
-    return listed.flatMap((tool) => {
-        const toolId = encodeMcpToolId(mcpName, tool.name);
-        if (toolId.length === 0) {
-            return [];
-        }
-        if (allowedIds !== undefined && !allowedIds.has(toolId)) {
-            return [];
-        }
-        const description = (tool.description ?? '').trim().length > 0
-            ? `${tool.description} (MCP:${mcpName})`
-            : `MCP tool «${tool.name}» from server «${mcpName}»`;
-        return [
-            {
-                toolId,
-                name: toolId,
-                description,
-                inputSchema: tool.inputSchema !== undefined &&
-                    typeof tool.inputSchema === 'object'
-                    ? tool.inputSchema
-                    : { type: 'object', properties: {} },
-                invoke: async (args) => {
-                    const result = await options.client.callTool(tool.name, args);
-                    return result.text;
-                },
-            },
-        ];
-    });
-};

package/vendor/tools/dist/mcp/create-mcp-runtime.d.ts

@@ -1,29 +0,0 @@
-import type { BuiltinToolRegistration, ToolInvokeCall, ToolInvokeResult } from '../harness-types.js';
-import { type PermissionAskRequest, type PermissionConfig, type PermissionDecision } from '../permission.js';
-export type { BuiltinToolRegistration, ToolInvokeCall, ToolInvokeResult, } from '../harness-types.js';
-export type McpServerConfig = {
-    readonly command: string;
-    readonly args?: readonly string[];
-    readonly cwd?: string;
-    readonly env?: Readonly<Record<string, string>>;
-};
-export type McpRuntime = {
-    readonly listRegistrations: (serverIds: readonly string[]) => readonly BuiltinToolRegistration[];
-    readonly invoke: (call: ToolInvokeCall) => Promise<ToolInvokeResult>;
-    readonly authorize?: (call: ToolInvokeCall) => Promise<'allow' | 'deny'>;
-    readonly close: () => Promise<void>;
-};
-/**
- * Connect allowlisted MCP servers.
- * Trust model: missing/empty `allowlist` → no spawn; unknown ids skipped.
- */
-export declare const createMcpRuntime: (options: {
-    readonly projectRoot: string;
-    readonly allowlist?: readonly string[];
-    readonly servers?: Readonly<Record<string, McpServerConfig>>;
-    readonly permission?: PermissionConfig;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<PermissionDecision>;
-}) => Promise<McpRuntime>;
-/** Empty runtime when MCP is unset / allowlist empty. */
-export declare const emptyMcpRuntime: () => McpRuntime;
-//# sourceMappingURL=create-mcp-runtime.d.ts.map

package/vendor/tools/dist/mcp/create-mcp-runtime.js

@@ -1,161 +0,0 @@
-import path from 'node:path';
-import { deniedToolResult, gateToolCall } from '../gate-tool-call.js';
-import { DEFAULT_PERMISSION_CONFIG, permissionDetailForMcpCall, } from '../permission.js';
-import { connectMcpStdioClient, } from './mcp-stdio-client.js';
-import { encodeMcpToolId, isValidMcpServerId, parseMcpToolId, } from './mcp-tool-id.js';
-const resolveEnvPlaceholders = (env) => {
-    if (env === undefined) {
-        return undefined;
-    }
-    const resolved = {};
-    for (const [key, value] of Object.entries(env)) {
-        const match = /^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(value);
-        resolved[key] =
-            match !== null ? (process.env[match[1] ?? ''] ?? '') : value;
-    }
-    return resolved;
-};
-/**
- * Connect allowlisted MCP servers.
- * Trust model: missing/empty `allowlist` → no spawn; unknown ids skipped.
- */
-export const createMcpRuntime = async (options) => {
-    const allowlist = options.allowlist ?? [];
-    const servers = options.servers ?? {};
-    const permission = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(options.permission ?? {}),
-    };
-    const grants = new Set();
-    const allowedIds = allowlist
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0 && isValidMcpServerId(id))
-        .filter((id) => servers[id] !== undefined);
-    const connected = [];
-    for (const serverId of allowedIds) {
-        const config = servers[serverId];
-        if (config === undefined) {
-            continue;
-        }
-        const cwd = config.cwd !== undefined && config.cwd.trim().length > 0
-            ? path.resolve(options.projectRoot, config.cwd)
-            : options.projectRoot;
-        try {
-            const resolvedEnv = resolveEnvPlaceholders(config.env);
-            const client = await connectMcpStdioClient({
-                command: config.command,
-                cwd,
-                ...(config.args !== undefined ? { args: config.args } : {}),
-                ...(resolvedEnv !== undefined ? { env: resolvedEnv } : {}),
-            });
-            const listed = await client.listTools();
-            const toolNameById = new Map();
-            const registrations = listed.flatMap((tool) => {
-                const toolId = encodeMcpToolId(serverId, tool.name);
-                if (toolId.length === 0) {
-                    return [];
-                }
-                toolNameById.set(toolId, tool.name);
-                return [
-                    {
-                        toolId,
-                        name: toolId,
-                        description: (tool.description ?? '').trim().length > 0
-                            ? `${tool.description} (MCP:${serverId})`
-                            : `MCP tool «${tool.name}» from server «${serverId}»`,
-                        inputSchema: tool.inputSchema !== undefined &&
-                            typeof tool.inputSchema === 'object'
-                            ? tool.inputSchema
-                            : { type: 'object', properties: {} },
-                    },
-                ];
-            });
-            connected.push({
-                serverId,
-                client,
-                registrations,
-                toolNameById,
-            });
-        }
-        catch {
-            /* Fail closed per server — do not abort the run for one bad MCP. */
-        }
-    }
-    const byServerId = new Map(connected.map((entry) => [entry.serverId, entry]));
-    const resolveRemoteName = (toolId) => {
-        const parsed = parseMcpToolId(toolId);
-        if (parsed === null) {
-            return 'mcp';
-        }
-        const server = byServerId.get(parsed.serverId);
-        return server?.toolNameById.get(toolId) ?? parsed.toolName;
-    };
-    const gate = async (toolId, args) => {
-        const detail = permissionDetailForMcpCall(resolveRemoteName(toolId), args);
-        const access = await gateToolCall({
-            toolId,
-            detail,
-            grants,
-            permission,
-            whenMissingToolConfig: 'ask',
-            ...(options.requestPermission !== undefined
-                ? { requestPermission: options.requestPermission }
-                : {}),
-        });
-        return { access, detail };
-    };
-    return {
-        listRegistrations: (serverIds) => {
-            const wanted = new Set(serverIds.map((id) => id.trim()).filter((id) => id.length > 0));
-            return connected.flatMap((entry) => wanted.has(entry.serverId) ? entry.registrations : []);
-        },
-        authorize: async (call) => {
-            const { access } = await gate(call.toolId.trim(), call.args);
-            return access;
-        },
-        invoke: async (call) => {
-            const parsed = parseMcpToolId(call.toolId);
-            if (parsed === null) {
-                return {
-                    ok: false,
-                    text: `Not an MCP tool id: «${call.toolId}».`,
-                };
-            }
-            const server = byServerId.get(parsed.serverId);
-            if (server === undefined) {
-                return {
-                    ok: false,
-                    text: `MCP server «${parsed.serverId}» is not connected (check mcp.allowlist).`,
-                };
-            }
-            const remoteName = server.toolNameById.get(call.toolId);
-            if (remoteName === undefined) {
-                return {
-                    ok: false,
-                    text: `Unknown MCP tool «${call.toolId}» on server «${parsed.serverId}».`,
-                };
-            }
-            const { access, detail } = await gate(call.toolId, call.args);
-            if (access === 'deny') {
-                return deniedToolResult(call.toolId, detail);
-            }
-            return server.client.callTool(remoteName, call.args);
-        },
-        close: async () => {
-            await Promise.all(connected.map((entry) => entry.client.close()));
-            connected.length = 0;
-            byServerId.clear();
-        },
-    };
-};
-/** Empty runtime when MCP is unset / allowlist empty. */
-export const emptyMcpRuntime = () => ({
-    listRegistrations: () => [],
-    authorize: async () => 'deny',
-    invoke: async (call) => ({
-        ok: false,
-        text: `MCP is not configured; cannot invoke «${call.toolId}».`,
-    }),
-    close: async () => undefined,
-});
-//# sourceMappingURL=create-mcp-runtime.js.map

package/vendor/tools/dist/mcp/create-system-mcp-handles.d.ts

@@ -1,52 +0,0 @@
-import type { ToolHandle } from '@langflower/node-sdk';
-/**
- * Structural twin of shared `LangflowerMcp*ServerConfig` (tools cannot import
- * `@langflower/shared`). Keep fields in sync with CONFIG / MCP nodes.
- * Server display name comes from MCP initialize, not author config.
- */
-export type SystemMcpStdioEntry = {
-    readonly kind: 'stdio';
-    readonly command: string;
-    readonly toolNames?: string;
-};
-/** @see SystemMcpStdioEntry */
-export type SystemMcpHttpEntry = {
-    readonly kind: 'http';
-    readonly url: string;
-    readonly command?: string;
-    readonly toolNames?: string;
-};
-export type SystemMcpServerEntry = SystemMcpStdioEntry | SystemMcpHttpEntry;
-export type SystemMcpConnectFailure = {
-    readonly serverId: string;
-    readonly message: string;
-};
-/** Jsonc server key plus bound tools — not an author SDK type. */
-export type SystemMcpServerTools = {
-    readonly serverId: string;
-    readonly tools: readonly ToolHandle[];
-};
-export type SystemMcpHandles = {
-    readonly handles: readonly SystemMcpServerTools[];
-    readonly failures: readonly SystemMcpConnectFailure[];
-    readonly close: () => Promise<void>;
-};
-/**
- * Connect system MCP servers (same connect/build path as MCP stdio/http nodes).
- * Only `serverIds` that exist in `servers` are opened.
- * Per-server connect/build failures are recorded; successful servers stay open.
- */
-export declare const createSystemMcpHandles: (options: {
-    readonly projectRoot: string;
-    readonly serverIds: readonly string[];
-    readonly servers: Readonly<Record<string, SystemMcpServerEntry>>;
-}) => Promise<SystemMcpHandles>;
-export declare const parseEnabledMcpIds: (value: unknown) => readonly string[];
-/** Union of `enabledMcpIds` across workflow nodes (Inspector system MCP). */
-export declare const collectEnabledMcpIdsFromNodes: (nodes: ReadonlyArray<{
-    readonly params: Readonly<Record<string, unknown>>;
-}>) => readonly string[];
-/** Ready server bags whose jsonc ids are enabled on this agent instance. */
-export declare const filterSystemMcpToolsByServerIds: (handles: readonly SystemMcpServerTools[], enabledMcpIds: readonly string[]) => readonly SystemMcpServerTools[];
-/** Failures that intersect this node's Inspector `enabledMcpIds`. */
-export declare const filterMcpFailuresForNode: (failures: readonly SystemMcpConnectFailure[], enabledMcpIds: readonly string[]) => readonly SystemMcpConnectFailure[];