@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/shared/mcp-direct-tool-allowlist.js

@@ -1,365 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { getAgentDir } from "../../shared/agent-dir.js";
-import { Check, ServersSchema, CacheSchema } from "./mcp-config-schema.js";
-import { stableStringify } from "./stable-value.js";
-import { isRecord } from "../../shared/unknown.js";
-const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
-const GENERIC_GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "mcp", "mcp.json");
-const IMPORT_PATHS = {
-    cursor: [path.join(os.homedir(), ".cursor", "mcp.json")],
-    "claude-code": [
-        path.join(os.homedir(), ".claude", "mcp.json"),
-        path.join(os.homedir(), ".claude.json"),
-        path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
-    ],
-    "claude-desktop": [
-        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-    ],
-    codex: [path.join(os.homedir(), ".codex", "config.json")],
-    windsurf: [path.join(os.homedir(), ".windsurf", "mcp.json")],
-    vscode: [".vscode/mcp.json"],
-};
-export function resolveMcpDirectToolNames(mcpDirectTools, cwd = process.cwd()) {
-    if (mcpDirectTools === undefined || mcpDirectTools.length === 0) {
-        return [];
-    }
-    const names = new Set();
-    // Keep pre-v5 and independent Fitch configs paired with their own caches.
-    for (const directory of ["", "fitch-mcp-adapter"]) {
-        try {
-            const config = loadMcpConfig(cwd, directory);
-            const cache = loadMetadataCache(directory);
-            if (!cache) {
-                continue;
-            }
-            for (const name of resolveDirectToolNames(config, cache, getToolPrefix(config.settings?.toolPrefix), mcpDirectTools)) {
-                names.add(name);
-            }
-        }
-        catch {
-            /* An unavailable adapter does not hide the other adapter's tools. */
-        }
-    }
-    return [...names];
-}
-function loadMetadataCache(directory) {
-    const cachePath = path.join(getAgentDir(), directory, "mcp-cache.json");
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-    return Check(CacheSchema, parsed) ? parsed : null;
-}
-function loadMcpConfig(cwd, directory) {
-    let config = { mcpServers: {} };
-    for (const sourcePath of getConfigPaths(cwd, directory)) {
-        const loaded = readConfig(sourcePath);
-        if (!loaded) {
-            continue;
-        }
-        config = mergeConfigs(config, expandImports(loaded, cwd));
-    }
-    return config;
-}
-function getConfigPaths(cwd, directory) {
-    const piGlobalPath = path.join(getAgentDir(), directory, "mcp.json");
-    const projectPath = path.resolve(cwd, ".mcp.json");
-    const projectPiPath = path.resolve(cwd, ".pi", directory, "mcp.json");
-    const sources = [];
-    if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath) {
-        sources.push(GENERIC_GLOBAL_CONFIG_PATH);
-    }
-    sources.push(piGlobalPath);
-    if (projectPath !== piGlobalPath) {
-        sources.push(projectPath);
-    }
-    if (projectPiPath !== piGlobalPath && projectPiPath !== projectPath) {
-        sources.push(projectPiPath);
-    }
-    return sources;
-}
-function readConfig(configPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-    return validateConfig(parsed);
-}
-function validatedServers(value) {
-    return Check(ServersSchema, value) ? value : {};
-}
-function validateConfig(raw) {
-    if (!isRecord(raw)) {
-        return { mcpServers: {} };
-    }
-    const settings = isRecord(raw.settings)
-        ? { toolPrefix: getToolPrefix(raw.settings.toolPrefix) }
-        : undefined;
-    return {
-        mcpServers: validatedServers(raw.mcpServers ?? raw["mcp-servers"] ?? {}),
-        imports: Array.isArray(raw.imports) ? raw.imports.filter(isImportKind) : undefined,
-        settings,
-    };
-}
-function mergeConfigs(base, next) {
-    const imports = [...(base.imports ?? []), ...(next.imports ?? [])];
-    return {
-        mcpServers: { ...base.mcpServers, ...next.mcpServers },
-        imports: imports.length > 0 ? [...new Set(imports)] : undefined,
-        settings: next.settings ? { ...base.settings, ...next.settings } : base.settings,
-    };
-}
-function expandImports(config, cwd) {
-    if (config.imports === undefined || config.imports.length === 0) {
-        return config;
-    }
-    const importedServers = new Map();
-    for (const importKind of config.imports) {
-        const importPath = resolveImportPath(importKind, cwd);
-        if (importPath === null) {
-            continue;
-        }
-        let imported;
-        try {
-            imported = JSON.parse(fs.readFileSync(importPath, "utf-8"));
-        }
-        catch {
-            continue;
-        }
-        for (const [name, definition] of Object.entries(extractServers(imported, importKind))) {
-            if (!importedServers.has(name)) {
-                importedServers.set(name, definition);
-            }
-        }
-    }
-    return {
-        imports: config.imports,
-        settings: config.settings,
-        mcpServers: { ...Object.fromEntries(importedServers), ...config.mcpServers },
-    };
-}
-function resolveImportPath(importKind, cwd) {
-    for (const candidate of IMPORT_PATHS[importKind]) {
-        const fullPath = candidate.startsWith(".") ? path.resolve(cwd, candidate) : candidate;
-        if (fs.existsSync(fullPath)) {
-            return fullPath;
-        }
-    }
-    return null;
-}
-function extractServers(config, kind) {
-    if (!isRecord(config)) {
-        return {};
-    }
-    const servers = kind === "cursor" || kind === "windsurf" || kind === "vscode"
-        ? (config.mcpServers ?? config["mcp-servers"])
-        : config.mcpServers;
-    return validatedServers(servers);
-}
-function cachedNames(cache, exposeResources) {
-    const tools = (cache.tools ?? []).flatMap((tool) => tool.name !== undefined && tool.name !== "" ? [tool.name] : []);
-    if (!exposeResources) {
-        return tools;
-    }
-    const resources = (cache.resources ?? []).flatMap((resource) => {
-        if (resource.name === undefined ||
-            resource.name === "" ||
-            resource.uri === undefined ||
-            resource.uri === "") {
-            return [];
-        }
-        return [`read_${resourceNameToToolName(resource.name)}`];
-    });
-    return [...tools, ...resources];
-}
-function serverDirectNames(input) {
-    const names = [];
-    for (const name of cachedNames(input.cache, input.definition.exposeResources !== false)) {
-        if (input.selection !== true && !input.selection.has(name)) {
-            continue;
-        }
-        if (isToolExcluded(name, input.serverName, input.prefix, input.definition.excludeTools)) {
-            continue;
-        }
-        const prefixed = formatToolName(name, input.serverName, input.prefix);
-        if (!BUILTIN_TOOL_NAMES.has(prefixed)) {
-            names.push(prefixed);
-        }
-    }
-    return names;
-}
-function resolveDirectToolNames(config, cache, defaultPrefix, envOverride) {
-    const names = [];
-    const { servers, tools } = parseSelections(envOverride);
-    for (const [serverName, definition] of Object.entries(config.mcpServers)) {
-        const serverCache = cache.servers[serverName];
-        if (definition.disabled === true || !isServerCacheValid(serverCache, definition)) {
-            continue;
-        }
-        const selection = servers.has(serverName) ? true : tools.get(serverName);
-        if (selection === undefined) {
-            continue;
-        }
-        names.push(...serverDirectNames({
-            serverName,
-            definition,
-            cache: serverCache,
-            prefix: definition.toolPrefix ?? defaultPrefix,
-            selection,
-        }));
-    }
-    return [...new Set(names)];
-}
-function parseSelection(item) {
-    const normalized = item.replace(/\/+$/, "");
-    if (!normalized.includes("/")) {
-        return normalized === "" ? undefined : { server: normalized };
-    }
-    const [server = "", tool = ""] = normalized.split("/", 2);
-    if (server === "") {
-        return;
-    }
-    return tool === "" ? { server } : { server, tool };
-}
-function parseSelections(selections) {
-    const servers = new Set();
-    const tools = new Map();
-    for (const item of selections) {
-        const selected = parseSelection(item);
-        if (!selected) {
-            continue;
-        }
-        if (selected.tool === undefined) {
-            servers.add(selected.server);
-            continue;
-        }
-        const names = tools.get(selected.server) ?? new Set();
-        names.add(selected.tool);
-        tools.set(selected.server, names);
-    }
-    return { servers, tools };
-}
-function isServerCacheValid(entry, definition) {
-    if (!entry || entry.configHash !== computeMcpServerHash(definition)) {
-        return false;
-    }
-    if (entry.cachedAt === undefined || entry.cachedAt === 0) {
-        return false;
-    }
-    return Date.now() - entry.cachedAt <= CACHE_MAX_AGE_MS;
-}
-function computeMcpServerHash(definition) {
-    const identity = {
-        command: definition.command,
-        args: definition.args,
-        socket: resolveConfigPath(definition.socket),
-        env: interpolateEnvRecord(definition.env),
-        cwd: resolveConfigPath(definition.cwd),
-        url: definition.url !== undefined && definition.url !== ""
-            ? interpolateEnvVars(definition.url)
-            : definition.url,
-        headers: interpolateEnvRecord(definition.headers),
-        auth: definition.auth,
-        bearerToken: resolveBearerToken(definition),
-        bearerTokenEnv: definition.bearerTokenEnv,
-        exposeResources: definition.exposeResources,
-        includeTools: definition.includeTools,
-        excludeTools: definition.excludeTools,
-    };
-    return createHash("sha256").update(stableStringify(identity)).digest("hex");
-}
-function getToolPrefix(value) {
-    return value === "none" || value === "short" || value === "server" ? value : "server";
-}
-function isImportKind(value) {
-    return typeof value === "string" && Object.hasOwn(IMPORT_PATHS, value);
-}
-function getServerPrefix(serverName, mode) {
-    if (mode === "none") {
-        return "";
-    }
-    if (mode === "short") {
-        const short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
-        return short === "" ? "mcp" : short;
-    }
-    return serverName.replace(/-/g, "_");
-}
-function formatToolName(toolName, serverName, prefix) {
-    const serverPrefix = getServerPrefix(serverName, prefix);
-    return serverPrefix !== "" ? `${serverPrefix}_${toolName}` : toolName;
-}
-function isToolExcluded(toolName, serverName, prefix, excludeTools) {
-    if (!Array.isArray(excludeTools) || excludeTools.length === 0) {
-        return false;
-    }
-    const candidates = new Set([
-        normalizeToolName(toolName),
-        normalizeToolName(formatToolName(toolName, serverName, prefix)),
-        normalizeToolName(formatToolName(toolName, serverName, "server")),
-        normalizeToolName(formatToolName(toolName, serverName, "short")),
-    ]);
-    return excludeTools.some((excluded) => typeof excluded === "string" && candidates.has(normalizeToolName(excluded)));
-}
-function normalizeToolName(value) {
-    return value.replace(/-/g, "_");
-}
-function resourceNameToToolName(name) {
-    let result = name
-        .replace(/[^a-zA-Z0-9]/g, "_")
-        .replace(/_+/g, "_")
-        .replace(/^_+/, "")
-        .replace(/_+$/, "")
-        .toLowerCase();
-    if (result === "" || /^\d/.test(result)) {
-        result = `resource${result !== "" ? `_${result}` : ""}`;
-    }
-    return result;
-}
-function interpolateEnvRecord(values) {
-    if (!values || typeof values !== "object" || Array.isArray(values)) {
-        return undefined;
-    }
-    const resolved = {};
-    for (const [key, value] of Object.entries(values)) {
-        if (typeof value === "string") {
-            resolved[key] = interpolateEnvVars(value);
-        }
-    }
-    return resolved;
-}
-function interpolateEnvVars(value) {
-    return value
-        .replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "")
-        .replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "");
-}
-function resolveConfigPath(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const resolved = interpolateEnvVars(value);
-    if (resolved === "~") {
-        return os.homedir();
-    }
-    if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
-        return path.join(os.homedir(), resolved.slice(2));
-    }
-    return resolved;
-}
-function resolveBearerToken(definition) {
-    if (typeof definition.bearerToken === "string") {
-        return interpolateEnvVars(definition.bearerToken);
-    }
-    return typeof definition.bearerTokenEnv === "string"
-        ? process.env[definition.bearerTokenEnv]
-        : undefined;
-}

package/dist/runs/shared/model-fallback.js

@@ -1,247 +0,0 @@
-export function splitThinkingSuffix(model) {
-    const colonIdx = model.lastIndexOf(":");
-    if (colonIdx === -1) {
-        return { baseModel: model, thinkingSuffix: "" };
-    }
-    return {
-        baseModel: model.substring(0, colonIdx),
-        thinkingSuffix: model.substring(colonIdx),
-    };
-}
-function preferredModel(matches, provider) {
-    return provider === undefined || provider.length === 0
-        ? undefined
-        : matches.find((entry) => entry.provider === provider);
-}
-export function resolveModelCandidate(model, availableModels, preferredProvider) {
-    if (model === undefined || model.length === 0) {
-        return undefined;
-    }
-    if (model.includes("/")) {
-        return model;
-    }
-    if (!availableModels || availableModels.length === 0) {
-        return model;
-    }
-    const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
-    const matches = availableModels.filter((entry) => entry.id === baseModel);
-    const preferredMatch = preferredModel(matches, preferredProvider);
-    if (preferredMatch) {
-        return `${preferredMatch.fullId}${thinkingSuffix}`;
-    }
-    if (matches.length !== 1) {
-        return model;
-    }
-    const match = matches.at(0);
-    return match === undefined ? model : `${match.fullId}${thinkingSuffix}`;
-}
-export function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider) {
-    const seen = new Set();
-    const candidates = [];
-    for (const raw of [primaryModel, ...(fallbackModels ?? [])]) {
-        if (raw === undefined || raw.length === 0) {
-            continue;
-        }
-        const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
-        if (normalized === undefined || normalized.length === 0 || seen.has(normalized)) {
-            continue;
-        }
-        seen.add(normalized);
-        candidates.push(normalized);
-    }
-    return candidates;
-}
-const RETRYABLE_MODEL_FAILURE_PATTERNS = [
-    /rate\s*limit/i,
-    /usage\s*limit/i,
-    /too many requests/i,
-    /\b429\b/,
-    /quota/i,
-    /billing/i,
-    /credit/i,
-    /auth(?:entication)?/i,
-    /unauthori[sz]ed/i,
-    /forbidden/i,
-    /api key/i,
-    /token expired/i,
-    /invalid key/i,
-    /provider.*unavailable/i,
-    /model.*unavailable/i,
-    /model.*disabled/i,
-    /model.*not found/i,
-    /unknown model/i,
-    /overloaded/i,
-    /service unavailable/i,
-    /temporar(?:ily)? unavailable/i,
-    /connection refused/i,
-    /database is locked/i,
-    /\bsqlite_busy\b/i,
-    /fetch failed/i,
-    /network error/i,
-    /socket hang up/i,
-    /upstream/i,
-    /timed? out/i,
-    /timeout/i,
-    /\b502\b/,
-    /\b503\b/,
-    /\b504\b/,
-];
-export function isRetryableModelFailure(error) {
-    if (error === undefined || error.length === 0) {
-        return false;
-    }
-    return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
-}
-const NON_RECOVERABLE_SAME_MODEL_PATTERNS = [
-    /usage\s*limit/i,
-    /quota/i,
-    /billing/i,
-    /credit/i,
-    /auth(?:entication)?/i,
-    /unauthori[sz]ed/i,
-    /forbidden/i,
-    /api key/i,
-    /token expired/i,
-    /invalid key/i,
-    /model.*disabled/i,
-    /model.*not found/i,
-    /unknown model/i,
-];
-const SAME_MODEL_RECOVERY_PATTERNS = [
-    /web\s*socket/i,
-    /websocket/i,
-    /transport/i,
-    /stream/i,
-    /socket/i,
-    /connection/i,
-    /fetch failed/i,
-    // Node fetch reports a response body cut off mid-stream as bare "terminated"; Pi retries it too.
-    // Match the whole message: process failures embed stderr and paths that can contain the word.
-    /^\s*terminated\s*$/i,
-    /network/i,
-    /http idle/i,
-    /timed? out/i,
-    /timeout/i,
-    /overloaded/i,
-    /service unavailable/i,
-    /temporar(?:ily)? unavailable/i,
-    /connection refused/i,
-    /database is locked/i,
-    /\bsqlite_busy\b/i,
-    /econnreset/i,
-    /etimedout/i,
-    /\b502\b/,
-    /\b503\b/,
-    /\b504\b/,
-];
-export function isRecoverableSameModelFailure(error, exitCode) {
-    if (exitCode === 143) {
-        return true;
-    }
-    if (error === undefined || error.length === 0) {
-        return false;
-    }
-    if (NON_RECOVERABLE_SAME_MODEL_PATTERNS.some((pattern) => pattern.test(error))) {
-        return false;
-    }
-    return SAME_MODEL_RECOVERY_PATTERNS.some((pattern) => pattern.test(error));
-}
-export function formatModelAttemptNote(attempt, nextModel) {
-    const failure = failureDescription(attempt);
-    return nextModel !== undefined && nextModel.length > 0
-        ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.`
-        : `[fallback] ${attempt.model} failed: ${failure}.`;
-}
-export function formatModelRecoveryAttemptNote(attempt, retryNumber, maxRetries) {
-    const failure = failureDescription(attempt);
-    return `[retry] ${attempt.model} failed: ${failure}. Retrying same model (${retryNumber}/${maxRetries}).`;
-}
-export function sumAttemptUsage(attempts) {
-    const usage = {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        turns: 0,
-    };
-    for (const attempt of attempts) {
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"]) {
-            usage[key] += attempt.usage?.[key] ?? 0;
-        }
-        const contributions = attempt.usage?.contributions;
-        if (contributions !== undefined && contributions.length > 0) {
-            (usage.contributions ??= []).push(...contributions);
-        }
-    }
-    return usage;
-}
-function failureDescription(attempt) {
-    const error = attempt.error?.trim();
-    return error !== undefined && error.length > 0 ? error : `exit ${attempt.exitCode ?? 1}`;
-}
-function successfulAttempt(result) {
-    return (result.exitCode === 0 &&
-        (result.error === undefined || result.error.length === 0) &&
-        result.interrupted !== true);
-}
-function terminalAttempt(result, signal) {
-    return (signal?.aborted === true ||
-        result.resourceLimitExceeded !== undefined ||
-        result.terminalFailure === true ||
-        result.interrupted === true ||
-        result.timedOut === true);
-}
-function summarizeAttempt(model, result) {
-    return {
-        model: model ?? result.model ?? "default",
-        success: successfulAttempt(result),
-        exitCode: result.exitCode,
-        error: result.error,
-        accounting: result.accounting,
-        usage: { ...result.usage },
-    };
-}
-function retryDecision(result, recovery, lastCandidate, signal) {
-    if (terminalAttempt(result, signal) || successfulAttempt(result)) {
-        return "stop";
-    }
-    const recoverable = isRecoverableSameModelFailure(result.error, result.exitCode);
-    if (recoverable && recovery === 0) {
-        return "recover";
-    }
-    return lastCandidate || (!recoverable && !isRetryableModelFailure(result.error))
-        ? "stop"
-        : "fallback";
-}
-export async function runModelAttempts(input) {
-    const candidates = input.candidates.length > 0 ? input.candidates : [undefined];
-    const modelAttempts = [];
-    const attemptedModels = [];
-    const notes = [];
-    let result;
-    modelLoop: for (let index = 0; index < candidates.length; index++) {
-        const model = candidates[index];
-        for (let recovery = 0;; recovery++) {
-            // A recovery needs the previous finalized outcome and accumulated notes before it starts.
-            // oxlint-disable-next-line no-await-in-loop
-            result = await input.runAttempt(model, notes);
-            if (model !== undefined && model.length > 0) {
-                attemptedModels.push(model);
-            }
-            const attempt = summarizeAttempt(model, result);
-            modelAttempts.push(attempt);
-            const decision = retryDecision(result, recovery, index === candidates.length - 1, input.signal);
-            if (decision === "stop") {
-                break modelLoop;
-            }
-            if (decision === "recover") {
-                notes.push(formatModelRecoveryAttemptNote(attempt, 1, 1));
-                continue;
-            }
-            notes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
-            break;
-        }
-    }
-    return { result, modelAttempts, attemptedModels, notes, usage: sumAttemptUsage(modelAttempts) };
-}