@vibecodr/cli 0.1.8

package/dist/cli/parse.js

@@ -0,0 +1,84 @@
+import { CliError, EXIT_CODES } from "./errors.js";
+function normalizeFlagName(flag) {
+    return flag.replace(/^--/, "");
+}
+export function parseFlags(args, options) {
+    const valueFlags = new Set(options.valueFlags || []);
+    const booleanFlags = new Set(options.booleanFlags || []);
+    const flags = {};
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === undefined)
+            continue;
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const name = normalizeFlagName(token);
+        if (booleanFlags.has(name)) {
+            flags[name] = true;
+            continue;
+        }
+        if (valueFlags.has(name)) {
+            const value = args[index + 1];
+            if (!value || value.startsWith("--")) {
+                throw new CliError("usage.missing_flag_value", `Missing value for --${name}.`, EXIT_CODES.usage);
+            }
+            flags[name] = value;
+            index += 1;
+            continue;
+        }
+        throw new CliError("usage.unknown_flag", `Unknown flag: ${token}`, EXIT_CODES.usage);
+    }
+    return { flags, positionals };
+}
+export function parseGlobalOptions(argv) {
+    const globalOptions = {
+        profile: "default",
+        json: false,
+        verbose: false,
+        nonInteractive: false
+    };
+    let command;
+    const commandArgs = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === undefined)
+            continue;
+        if (token === "--profile") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new CliError("usage.missing_profile", "Missing value for --profile.", EXIT_CODES.usage);
+            globalOptions.profile = value;
+            index += 1;
+            continue;
+        }
+        if (token === "--server-url") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new CliError("usage.missing_server_url", "Missing value for --server-url.", EXIT_CODES.usage);
+            globalOptions.serverUrl = value;
+            index += 1;
+            continue;
+        }
+        if (token === "--json") {
+            globalOptions.json = true;
+            continue;
+        }
+        if (token === "--verbose") {
+            globalOptions.verbose = true;
+            continue;
+        }
+        if (token === "--non-interactive") {
+            globalOptions.nonInteractive = true;
+            continue;
+        }
+        if (!command && !token.startsWith("--")) {
+            command = token;
+            continue;
+        }
+        commandArgs.push(token);
+    }
+    return { ...(command ? { command } : {}), commandArgs, globalOptions };
+}

package/dist/clients/base.js

@@ -0,0 +1,30 @@
+import { readFile } from "node:fs/promises";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { writeFileWithBackup } from "../storage/file-lock.js";
+export async function readJsonFile(path, fallback) {
+    try {
+        const raw = await readFile(path, "utf8");
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            throw new CliError("install.config_parse", `Existing config at ${path} is not valid JSON.`, EXIT_CODES.installConflict, {
+                cause: error,
+                nextStep: "Repair the existing config file before retrying."
+            });
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return fallback;
+        throw error;
+    }
+}
+export async function writeTextFileAtomic(path, content) {
+    await writeFileWithBackup(path, content);
+}
+export function requireScope(actual, supported) {
+    if (!supported.includes(actual)) {
+        throw new CliError("install.unsupported_scope", `Scope ${actual} is not supported for this client.`, EXIT_CODES.unsupportedClient);
+    }
+}

package/dist/clients/codex.js

@@ -0,0 +1,136 @@
+import * as TOML from "@iarna/toml";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { codexConfigPath } from "../platform/paths.js";
+import { requireScope, writeTextFileAtomic } from "./base.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { commandExists, runCommand } from "../platform/exec.js";
+async function readCodexConfig(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        try {
+            return TOML.parse(raw);
+        }
+        catch (error) {
+            throw new CliError("install.config_parse", `Existing Codex config at ${path} is not valid TOML.`, EXIT_CODES.installConflict, {
+                cause: error,
+                nextStep: "Repair the existing Codex config before retrying."
+            });
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+function resolvedCodexConfigPath(request) {
+    return request.path ? join(request.path, "config.toml") : codexConfigPath();
+}
+export async function installCodex(request) {
+    requireScope(request.scope, ["user"]);
+    if (!request.dryRun && !request.path && commandExists("codex")) {
+        try {
+            await runCommand("codex", ["mcp", "add", request.name, "--url", request.serverUrl]);
+            return {
+                client: "codex",
+                scope: request.scope,
+                name: request.name,
+                method: "cli",
+                changed: true,
+                location: "codex mcp add",
+                managed: true,
+                nextStep: "Codex is configured. Codex will handle its own OAuth flow on first protected use."
+            };
+        }
+        catch {
+            // fall through to TOML merge
+        }
+    }
+    const location = resolvedCodexConfigPath(request);
+    const current = await readCodexConfig(location);
+    const servers = (current.mcp_servers || {});
+    const existing = servers[request.name];
+    if (existing?.url && existing.url !== request.serverUrl && !request.overwrite) {
+        throw new CliError("install.conflict", `Codex already has an MCP entry named ${request.name} with a different URL.`, EXIT_CODES.installConflict, {
+            nextStep: "Retry with --overwrite or choose a different --name."
+        });
+    }
+    const next = {
+        ...current,
+        mcp_servers: {
+            ...servers,
+            [request.name]: {
+                url: request.serverUrl
+            }
+        }
+    };
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (!request.dryRun && changed) {
+        await writeTextFileAtomic(location, TOML.stringify(next));
+    }
+    return {
+        client: "codex",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed,
+        location,
+        managed: true,
+        nextStep: "Codex is configured. Codex will handle its own OAuth flow on first protected use."
+    };
+}
+export async function uninstallCodex(request, managedLocation) {
+    requireScope(request.scope, ["user"]);
+    if (!request.dryRun && !request.path && !managedLocation && commandExists("codex")) {
+        try {
+            await runCommand("codex", ["mcp", "remove", request.name]);
+            return {
+                client: "codex",
+                scope: request.scope,
+                name: request.name,
+                method: "cli",
+                changed: true,
+                location: "codex mcp remove",
+                managed: true,
+                nextStep: "Codex config was updated. Codex-owned auth state is unchanged."
+            };
+        }
+        catch {
+            // fall through to file removal
+        }
+    }
+    const location = managedLocation && managedLocation !== "codex mcp add" ? managedLocation : resolvedCodexConfigPath(request);
+    const current = await readCodexConfig(location);
+    const servers = { ...(current.mcp_servers || {}) };
+    if (!servers[request.name]) {
+        return {
+            client: "codex",
+            scope: request.scope,
+            name: request.name,
+            method: "file",
+            changed: false,
+            location,
+            managed: true,
+            nextStep: "No managed Codex entry was present."
+        };
+    }
+    delete servers[request.name];
+    const next = {
+        ...current,
+        mcp_servers: Object.keys(servers).length ? servers : undefined
+    };
+    if (!request.dryRun) {
+        await writeTextFileAtomic(location, TOML.stringify(next));
+    }
+    return {
+        client: "codex",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed: true,
+        location,
+        managed: true,
+        nextStep: "Codex config was updated. Codex-owned auth state is unchanged."
+    };
+}

package/dist/clients/cursor.js

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { readJsonFile, requireScope, writeTextFileAtomic } from "./base.js";
+import { cursorUserConfigPath, projectCursorConfigPath } from "../platform/paths.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { openExternalUrl } from "../platform/browser.js";
+function configPath(scope, rootPath) {
+    if (scope === "user") {
+        return rootPath ? join(rootPath, "mcp.json") : cursorUserConfigPath();
+    }
+    return projectCursorConfigPath(rootPath || process.cwd());
+}
+export async function installCursor(request) {
+    requireScope(request.scope, ["user", "project"]);
+    const location = configPath(request.scope, request.path);
+    const current = await readJsonFile(location, {});
+    const next = {
+        ...current,
+        mcpServers: {
+            ...(current.mcpServers || {}),
+            [request.name]: {
+                type: "http",
+                url: request.serverUrl
+            }
+        }
+    };
+    const existing = current.mcpServers?.[request.name];
+    if (existing && existing.url !== request.serverUrl && !request.overwrite) {
+        throw new CliError("install.conflict", `Cursor already has an MCP entry named ${request.name} with a different URL.`, EXIT_CODES.installConflict, {
+            nextStep: "Retry with --overwrite or choose a different --name."
+        });
+    }
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (!request.dryRun && changed) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    if (request.openClient && !request.dryRun) {
+        const deeplink = new URL("cursor://anysphere.cursor-deeplink/mcp/install");
+        deeplink.searchParams.set("name", request.name);
+        deeplink.searchParams.set("config", JSON.stringify({
+            url: request.serverUrl
+        }));
+        await openExternalUrl(deeplink.toString());
+    }
+    return {
+        client: "cursor",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed,
+        location,
+        managed: true,
+        nextStep: "Use the server in Cursor to trigger Cursor-owned OAuth."
+    };
+}
+export async function uninstallCursor(request, managedLocation) {
+    requireScope(request.scope, ["user", "project"]);
+    const location = managedLocation || configPath(request.scope, request.path);
+    const current = await readJsonFile(location, {});
+    const existing = current.mcpServers?.[request.name];
+    if (!existing) {
+        return {
+            client: "cursor",
+            scope: request.scope,
+            name: request.name,
+            method: "file",
+            changed: false,
+            location,
+            managed: true,
+            nextStep: "No managed Cursor entry was present."
+        };
+    }
+    const nextServers = { ...(current.mcpServers || {}) };
+    delete nextServers[request.name];
+    const next = {
+        ...current,
+        mcpServers: Object.keys(nextServers).length ? nextServers : undefined
+    };
+    if (!request.dryRun) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    return {
+        client: "cursor",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed: true,
+        location,
+        managed: true,
+        nextStep: "Cursor config was updated. Cursor-owned auth state is unchanged."
+    };
+}

package/dist/clients/vscode.js

@@ -0,0 +1,138 @@
+import { spawn } from "node:child_process";
+import { readJsonFile, requireScope, writeTextFileAtomic } from "./base.js";
+import { vscodeWorkspaceConfigPath } from "../platform/paths.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { openExternalUrl } from "../platform/browser.js";
+import { commandExists } from "../platform/exec.js";
+function runCli(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: "ignore"
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} exited with code ${code}`));
+        });
+    });
+}
+export async function installVsCode(request) {
+    requireScope(request.scope, ["user", "project"]);
+    if (request.scope === "user") {
+        const payload = JSON.stringify({
+            name: request.name,
+            type: "http",
+            url: request.serverUrl
+        });
+        let method = "cli";
+        if (!request.dryRun) {
+            await runCli("code", ["--add-mcp", payload]).catch((error) => {
+                if (request.openClient) {
+                    const uri = `vscode:mcp/install?${encodeURIComponent(payload)}`;
+                    method = "uri";
+                    return openExternalUrl(uri);
+                }
+                throw new CliError("install.vscode_cli_failed", "VS Code CLI install failed.", EXIT_CODES.unsupportedClient, {
+                    cause: error,
+                    nextStep: "Ensure the `code` CLI is installed, or retry with --open-client."
+                });
+            });
+        }
+        else if (request.openClient && !commandExists("code")) {
+            method = "uri";
+        }
+        return {
+            client: "vscode",
+            scope: request.scope,
+            name: request.name,
+            method,
+            changed: true,
+            location: method === "cli" ? "code --add-mcp" : "vscode:mcp/install",
+            managed: true,
+            nextStep: "Use the server in VS Code to trigger VS Code-owned OAuth."
+        };
+    }
+    const location = vscodeWorkspaceConfigPath(request.path || process.cwd());
+    const current = await readJsonFile(location, {});
+    const next = {
+        ...current,
+        servers: {
+            ...(current.servers || {}),
+            [request.name]: {
+                type: "http",
+                url: request.serverUrl
+            }
+        }
+    };
+    const existing = current.servers?.[request.name];
+    if (existing && existing.url !== request.serverUrl && !request.overwrite) {
+        throw new CliError("install.conflict", `VS Code already has an MCP entry named ${request.name} with a different URL.`, EXIT_CODES.installConflict, {
+            nextStep: "Retry with --overwrite or choose a different --name."
+        });
+    }
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (!request.dryRun && changed) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    if (request.openClient && !request.dryRun) {
+        const payload = JSON.stringify({
+            name: request.name,
+            type: "http",
+            url: request.serverUrl
+        });
+        await openExternalUrl(`vscode:mcp/install?${encodeURIComponent(payload)}`);
+    }
+    return {
+        client: "vscode",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed,
+        location,
+        managed: true,
+        nextStep: "Use the server in VS Code to trigger VS Code-owned OAuth."
+    };
+}
+export async function uninstallVsCode(request, managedLocation, managedMethod) {
+    requireScope(request.scope, ["user", "project"]);
+    if (request.scope === "user" || managedMethod === "cli") {
+        throw new CliError("install.conflict", "User-scope VS Code uninstall is not automated yet with documented surfaces.", EXIT_CODES.installConflict, {
+            nextStep: "Remove the server from VS Code MCP settings, then rerun uninstall when a documented removal surface exists."
+        });
+    }
+    const location = managedLocation || vscodeWorkspaceConfigPath(request.path || process.cwd());
+    const current = await readJsonFile(location, {});
+    if (!current.servers?.[request.name]) {
+        return {
+            client: "vscode",
+            scope: request.scope,
+            name: request.name,
+            method: "file",
+            changed: false,
+            location,
+            managed: true,
+            nextStep: "No managed VS Code workspace entry was present."
+        };
+    }
+    const nextServers = { ...(current.servers || {}) };
+    delete nextServers[request.name];
+    const next = {
+        ...current,
+        servers: Object.keys(nextServers).length ? nextServers : undefined
+    };
+    if (!request.dryRun) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    return {
+        client: "vscode",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed: true,
+        location,
+        managed: true,
+        nextStep: "VS Code workspace config was updated. VS Code-owned auth state is unchanged."
+    };
+}

package/dist/clients/windsurf.js

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+import { readJsonFile, requireScope, writeTextFileAtomic } from "./base.js";
+import { windsurfLegacyConfigPath, windsurfUserConfigPath } from "../platform/paths.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+export async function installWindsurf(request) {
+    requireScope(request.scope, ["user"]);
+    const location = request.path ? join(request.path, "mcp_config.json") : windsurfUserConfigPath();
+    const current = await readJsonFile(location, {});
+    const next = {
+        ...current,
+        mcpServers: {
+            ...(current.mcpServers || {}),
+            [request.name]: {
+                serverUrl: request.serverUrl
+            }
+        }
+    };
+    const existing = current.mcpServers?.[request.name];
+    if (existing && existing.serverUrl !== request.serverUrl && !request.overwrite) {
+        throw new CliError("install.conflict", `Windsurf already has an MCP entry named ${request.name} with a different URL.`, EXIT_CODES.installConflict, {
+            nextStep: "Retry with --overwrite or choose a different --name."
+        });
+    }
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (!request.dryRun && changed) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    const notes = [];
+    const legacyPath = windsurfLegacyConfigPath();
+    const legacyExists = await readJsonFile(legacyPath, null).catch(() => null);
+    if (legacyExists && typeof legacyExists === "object") {
+        notes.push(`Legacy Windsurf plugin config detected at ${legacyPath}.`);
+    }
+    return {
+        client: "windsurf",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed,
+        location,
+        managed: true,
+        nextStep: "Open Windsurf and refresh MCPs if needed.",
+        ...(notes.length ? { notes } : {})
+    };
+}
+export async function uninstallWindsurf(request, managedLocation) {
+    requireScope(request.scope, ["user"]);
+    const location = managedLocation || (request.path ? join(request.path, "mcp_config.json") : windsurfUserConfigPath());
+    const current = await readJsonFile(location, {});
+    if (!current.mcpServers?.[request.name]) {
+        return {
+            client: "windsurf",
+            scope: request.scope,
+            name: request.name,
+            method: "file",
+            changed: false,
+            location,
+            managed: true,
+            nextStep: "No managed Windsurf entry was present."
+        };
+    }
+    const nextServers = { ...(current.mcpServers || {}) };
+    delete nextServers[request.name];
+    const next = {
+        ...current,
+        mcpServers: Object.keys(nextServers).length ? nextServers : undefined
+    };
+    if (!request.dryRun) {
+        await writeTextFileAtomic(location, JSON.stringify(next, null, 2) + "\n");
+    }
+    return {
+        client: "windsurf",
+        scope: request.scope,
+        name: request.name,
+        method: "file",
+        changed: true,
+        location,
+        managed: true,
+        nextStep: "Windsurf config was updated. Windsurf-owned auth state is unchanged."
+    };
+}

package/dist/commands/call.js

@@ -0,0 +1,123 @@
+import { readFile } from "node:fs/promises";
+import { promptText } from "../platform/prompt.js";
+import { parseFlags } from "../cli/parse.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { renderToolResult } from "../core/renderers.js";
+import { promptObjectBySchema } from "../core/interactive-input.js";
+function challengedScope(error) {
+    if (!error.debugDetails || typeof error.debugDetails !== "object")
+        return undefined;
+    const scope = error.debugDetails["scope"];
+    return typeof scope === "string" && scope.trim() ? scope : undefined;
+}
+async function requiredScopeForTool(context, toolName) {
+    const { serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const tools = await context.runtimeClient.listTools(serverUrl);
+    const tool = tools.find((item) => item.name === toolName);
+    const directSchemes = Array.isArray(tool?.["securitySchemes"])
+        ? (tool.securitySchemes)
+        : [];
+    const metaSchemes = tool?._meta && typeof tool._meta === "object" && Array.isArray(tool._meta["securitySchemes"])
+        ? tool._meta["securitySchemes"]
+        : [];
+    const scopes = [...directSchemes, ...metaSchemes].find((scheme) => scheme.type === "oauth2")?.scopes;
+    return Array.isArray(scopes) && scopes.length ? scopes.join(" ") : undefined;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function callToolWithRetry(context, toolName, input, allowLogin) {
+    const { profileName, serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const existingSession = await context.tokenManager.getSession(profileName);
+    try {
+        return {
+            result: await context.runtimeClient.callTool(serverUrl, existingSession?.accessToken, toolName, input),
+            ...(existingSession ? { session: existingSession } : {})
+        };
+    }
+    catch (error) {
+        if (!(error instanceof CliError) || !["auth.required", "auth.insufficient_scope"].includes(error.machineCode))
+            throw error;
+        if (error.machineCode === "auth.required" && existingSession?.refreshToken) {
+            const refreshed = await context.tokenManager.refresh(profileName, existingSession);
+            return {
+                result: await context.runtimeClient.callTool(serverUrl, refreshed.session.accessToken, toolName, input),
+                session: refreshed.session
+            };
+        }
+        if (allowLogin && !context.globalOptions.nonInteractive) {
+            const scope = challengedScope(error) || await requiredScopeForTool(context, toolName);
+            await context.tokenManager.login(context.globalOptions, {
+                scope
+            });
+            const nextSession = await context.tokenManager.getSession(profileName);
+            return {
+                result: await context.runtimeClient.callTool(serverUrl, nextSession?.accessToken, toolName, input),
+                ...(nextSession ? { session: nextSession } : {})
+            };
+        }
+        throw error;
+    }
+}
+async function listToolsWithRetry(context, allowLogin) {
+    const { profileName, serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const existingSession = await context.tokenManager.getSession(profileName);
+    try {
+        return await context.runtimeClient.listTools(serverUrl, existingSession?.accessToken);
+    }
+    catch (error) {
+        if (!(error instanceof CliError) || !["auth.required", "auth.insufficient_scope"].includes(error.machineCode))
+            throw error;
+        if (error.machineCode === "auth.required" && existingSession?.refreshToken) {
+            const refreshed = await context.tokenManager.refresh(profileName, existingSession);
+            return await context.runtimeClient.listTools(serverUrl, refreshed.session.accessToken);
+        }
+        if (allowLogin && !context.globalOptions.nonInteractive) {
+            await context.tokenManager.login(context.globalOptions, {
+                scope: challengedScope(error)
+            });
+            const nextSession = await context.tokenManager.getSession(profileName);
+            return await context.runtimeClient.listTools(serverUrl, nextSession?.accessToken);
+        }
+        throw error;
+    }
+}
+export async function runCallCommand(args, context) {
+    const { flags, positionals } = parseFlags(args, {
+        valueFlags: ["input-json", "input-file"],
+        booleanFlags: ["stdin", "interactive", "no-login"]
+    });
+    const toolName = positionals[0];
+    if (!toolName) {
+        throw new CliError("usage.tool_name_required", "A tool name is required.", EXIT_CODES.usage);
+    }
+    let input = {};
+    if (typeof flags["input-json"] === "string") {
+        input = JSON.parse(flags["input-json"]);
+    }
+    else if (typeof flags["input-file"] === "string") {
+        input = JSON.parse(await readFile(flags["input-file"], "utf8"));
+    }
+    else if (flags["stdin"]) {
+        input = JSON.parse(await readStdin());
+    }
+    else if (flags["interactive"]) {
+        const tools = await listToolsWithRetry(context, !flags["no-login"]);
+        const tool = tools.find((item) => item.name === toolName);
+        if (!tool) {
+            throw new CliError("tool.not_found", `Tool not found: ${toolName}`, EXIT_CODES.toolFailed);
+        }
+        input = await promptObjectBySchema(promptText, toolName, tool.inputSchema);
+    }
+    const { result } = await callToolWithRetry(context, toolName, input, !flags["no-login"]);
+    context.output.success({
+        schemaVersion: 1,
+        tool: toolName,
+        arguments: input,
+        result
+    }, [renderToolResult(result)]);
+}