@zivis/mcp 0.1.19 → 0.2.5

package/dist/tools/discover-local-infra.js

@@ -1,686 +0,0 @@
-import { z } from "zod";
-import { readFile, readdir, stat } from "fs/promises";
-import { join } from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-const execAsync = promisify(exec);
-export const DISCOVER_LOCAL_INFRA_NAME = "zivis_discover_local_infra";
-export const DISCOVER_LOCAL_INFRA_DESCRIPTION = `Discover AI infrastructure in a local project directory by reading Docker, compose, and dependency files.
-
-Analyzes the project to understand what services are defined, which are running, and what AI/LLM frameworks are in use. Returns a suggested target shape (URL, chat endpoint) for the coding agent to use as grounding context before running \`zivis test ai\`.
-
-What it reads:
-- docker-compose.yml / docker-compose.yaml / compose.yml / compose.yaml
-- Dockerfile(s) in the project root and subdirectories
-- .env files (structure only — values are redacted for safety)
-- package.json, requirements.txt, pyproject.toml, go.mod (to detect AI frameworks)
-
-What it checks:
-- Docker daemon status
-- Currently running containers (docker compose ps)
-- Port mappings and exposed services
-
-What it returns:
-- List of services with ports and images
-- Running vs stopped status per service
-- Detected AI/LLM patterns (OpenAI, Anthropic, LangChain, etc.)
-- Suggested target_url/target_type/chat_endpoint — informational context, not a tool call to make
-- Whether the zivis-local-runner Docker image is available
-
-For actually testing the discovered AI system, run \`zivis test ai\` in the terminal — this tool only maps what's running locally.
-
-This tool makes NO network requests and requires NO authentication. It only reads local files and queries the Docker daemon.`;
-export const DISCOVER_LOCAL_INFRA_SCHEMA = {
-    project_dir: z
-        .string()
-        .optional()
-        .describe("Path to the project directory to analyze. Defaults to the current working directory."),
-};
-const NPM_AI_PACKAGES = [
-    { package: "openai", name: "OpenAI SDK" },
-    { package: "@anthropic-ai/sdk", name: "Anthropic SDK" },
-    { package: "ai", name: "Vercel AI SDK" },
-    { package: "@ai-sdk/openai", name: "Vercel AI SDK (OpenAI)" },
-    { package: "@ai-sdk/anthropic", name: "Vercel AI SDK (Anthropic)" },
-    { package: "@langchain/core", name: "LangChain" },
-    { package: "langchain", name: "LangChain" },
-    { package: "llamaindex", name: "LlamaIndex" },
-    { package: "@azure/openai", name: "Azure OpenAI" },
-    { package: "ollama", name: "Ollama" },
-    { package: "cohere-ai", name: "Cohere" },
-    { package: "@google/generative-ai", name: "Google Gemini" },
-    { package: "@mistralai/mistralai", name: "Mistral" },
-    { package: "replicate", name: "Replicate" },
-];
-const PIP_AI_PACKAGES = [
-    { package: "openai", name: "OpenAI SDK" },
-    { package: "anthropic", name: "Anthropic SDK" },
-    { package: "langchain", name: "LangChain" },
-    { package: "llama-index", name: "LlamaIndex" },
-    { package: "transformers", name: "HuggingFace Transformers" },
-    { package: "vllm", name: "vLLM" },
-    { package: "litellm", name: "LiteLLM" },
-    { package: "guidance", name: "Microsoft Guidance" },
-    { package: "google-generativeai", name: "Google Gemini" },
-    { package: "cohere", name: "Cohere" },
-    { package: "ollama", name: "Ollama" },
-    { package: "gradio", name: "Gradio" },
-    { package: "streamlit", name: "Streamlit" },
-];
-const GO_AI_PACKAGES = [
-    { package: "sashabaranov/go-openai", name: "Go OpenAI" },
-    { package: "liushuangls/go-anthropic", name: "Go Anthropic" },
-];
-const AI_ENV_KEYS = [
-    "OPENAI_API_KEY",
-    "ANTHROPIC_API_KEY",
-    "AZURE_OPENAI_API_KEY",
-    "AZURE_OPENAI_ENDPOINT",
-    "HUGGINGFACE_TOKEN",
-    "HF_TOKEN",
-    "COHERE_API_KEY",
-    "GOOGLE_API_KEY",
-    "GOOGLE_GENERATIVE_AI_API_KEY",
-    "MISTRAL_API_KEY",
-    "REPLICATE_API_TOKEN",
-    "OLLAMA_HOST",
-    "OLLAMA_BASE_URL",
-    "LLM_MODEL",
-    "MODEL_NAME",
-    "EMBEDDING_MODEL",
-    "TOGETHER_API_KEY",
-    "GROQ_API_KEY",
-    "FIREWORKS_API_KEY",
-    "PERPLEXITY_API_KEY",
-];
-const INFRA_IMAGES = [
-    "postgres",
-    "redis",
-    "mongo",
-    "mysql",
-    "mariadb",
-    "nginx",
-    "traefik",
-    "caddy",
-    "azurite",
-    "pgadmin",
-    "adminer",
-    "mailhog",
-    "rabbitmq",
-    "kafka",
-    "zookeeper",
-    "elasticsearch",
-    "minio",
-    "vault",
-    "consul",
-    "prometheus",
-    "grafana",
-    "jaeger",
-    "memcached",
-];
-const MAX_FILE_SIZE = 100 * 1024;
-export function createDiscoverLocalInfraHandler() {
-    return async (params) => {
-        const projectDir = params.project_dir || process.cwd();
-        const result = {
-            docker: { running: false },
-            compose: { found: false, services: [] },
-            dockerfiles: [],
-            aiFrameworks: { detected: [], envHints: [] },
-            runnerImage: { available: false },
-            suggestion: null,
-            nextStep: null,
-        };
-        try {
-            const { stdout } = await execAsync("docker version --format '{{.Server.Version}}'", {
-                timeout: 5000,
-            });
-            result.docker = { running: true, version: stdout.trim().replace(/'/g, "") };
-        }
-        catch {
-            result.docker = { running: false };
-        }
-        const composeFileNames = [
-            "docker-compose.yml",
-            "docker-compose.yaml",
-            "compose.yml",
-            "compose.yaml",
-        ];
-        const composeDirs = ["", "infra", "docker", "deploy", "deployment", ".docker"];
-        for (const dir of composeDirs) {
-            if (result.compose.found)
-                break;
-            for (const file of composeFileNames) {
-                const filePath = dir ? join(projectDir, dir, file) : join(projectDir, file);
-                const content = await safeReadFile(filePath);
-                if (content) {
-                    result.compose.found = true;
-                    result.compose.file = dir ? `${dir}/${file}` : file;
-                    result.compose.services = parseComposeServices(content);
-                    break;
-                }
-            }
-        }
-        if (result.docker.running && result.compose.found) {
-            try {
-                const composeDir = result.compose.file?.includes("/")
-                    ? join(projectDir, result.compose.file.split("/").slice(0, -1).join("/"))
-                    : projectDir;
-                const { stdout } = await execAsync("docker compose ps --format json", {
-                    timeout: 10000,
-                    cwd: composeDir,
-                });
-                const runningServices = parseDockerComposePsOutput(stdout);
-                for (const svc of result.compose.services) {
-                    const running = runningServices.find((r) => r.name === svc.name || r.service === svc.name);
-                    svc.status = running ? "running" : "stopped";
-                }
-            }
-            catch {
-            }
-        }
-        const detected = [];
-        const pkgJson = await safeReadFile(join(projectDir, "package.json"));
-        if (pkgJson) {
-            try {
-                const pkg = JSON.parse(pkgJson);
-                const allDeps = {
-                    ...pkg.dependencies,
-                    ...pkg.devDependencies,
-                };
-                for (const ai of NPM_AI_PACKAGES) {
-                    if (allDeps[ai.package]) {
-                        detected.push({
-                            name: ai.name,
-                            source: "package.json",
-                            package: ai.package,
-                            version: allDeps[ai.package],
-                        });
-                    }
-                }
-            }
-            catch {
-            }
-        }
-        const subdirs = await safeReaddir(projectDir);
-        const searchDirs = [""];
-        for (const dir of subdirs) {
-            if (dir.startsWith(".") || dir === "node_modules" || dir === "vendor")
-                continue;
-            searchDirs.push(dir);
-            const subSubDirs = await safeReaddir(join(projectDir, dir));
-            for (const sub of subSubDirs) {
-                if (sub.startsWith(".") || sub === "node_modules" || sub === "vendor")
-                    continue;
-                searchDirs.push(`${dir}/${sub}`);
-            }
-        }
-        for (const dir of searchDirs) {
-            const base = dir ? join(projectDir, dir) : projectDir;
-            const prefix = dir ? `${dir}/` : "";
-            const subPkgJson = await safeReadFile(join(base, "package.json"));
-            if (subPkgJson) {
-                try {
-                    const pkg = JSON.parse(subPkgJson);
-                    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-                    for (const ai of NPM_AI_PACKAGES) {
-                        if (allDeps[ai.package] && !detected.some((d) => d.package === ai.package)) {
-                            detected.push({
-                                name: ai.name,
-                                source: `${prefix}package.json`,
-                                package: ai.package,
-                                version: allDeps[ai.package],
-                            });
-                        }
-                    }
-                }
-                catch {
-                }
-            }
-            const reqTxt = await safeReadFile(join(base, "requirements.txt"));
-            if (reqTxt) {
-                const lines = reqTxt.toLowerCase().split("\n");
-                for (const ai of PIP_AI_PACKAGES) {
-                    if (lines.some((line) => line.startsWith(ai.package) ||
-                        line.includes(`${ai.package}==`) ||
-                        line.includes(`${ai.package}>=`))) {
-                        if (!detected.some((d) => d.package === ai.package && d.source.includes(prefix))) {
-                            detected.push({
-                                name: ai.name,
-                                source: `${prefix}requirements.txt`,
-                                package: ai.package,
-                            });
-                        }
-                    }
-                }
-            }
-            const pyproject = await safeReadFile(join(base, "pyproject.toml"));
-            if (pyproject) {
-                for (const ai of PIP_AI_PACKAGES) {
-                    if (pyproject.includes(`"${ai.package}"`) ||
-                        pyproject.includes(`'${ai.package}'`) ||
-                        pyproject.includes(ai.package)) {
-                        if (!detected.some((d) => d.package === ai.package)) {
-                            detected.push({
-                                name: ai.name,
-                                source: `${prefix}pyproject.toml`,
-                                package: ai.package,
-                            });
-                        }
-                    }
-                }
-            }
-            const goMod = await safeReadFile(join(base, "go.mod"));
-            if (goMod) {
-                for (const ai of GO_AI_PACKAGES) {
-                    if (goMod.includes(ai.package)) {
-                        if (!detected.some((d) => d.package === ai.package)) {
-                            detected.push({
-                                name: ai.name,
-                                source: `${prefix}go.mod`,
-                                package: ai.package,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        result.aiFrameworks.detected = detected;
-        const envFileNames = [".env", ".env.local", ".env.development"];
-        const envHints = [];
-        for (const dir of ["", "infra", "docker"]) {
-            for (const envFile of envFileNames) {
-                const filePath = dir ? join(projectDir, dir, envFile) : join(projectDir, envFile);
-                const content = await safeReadFile(filePath);
-                if (content) {
-                    const keys = content
-                        .split("\n")
-                        .filter((line) => line.includes("=") && !line.startsWith("#"))
-                        .map((line) => line.split("=")[0].trim())
-                        .filter(Boolean);
-                    for (const key of keys) {
-                        if (AI_ENV_KEYS.some((aiKey) => key.toUpperCase().includes(aiKey) || aiKey.includes(key.toUpperCase()))) {
-                            envHints.push(key);
-                        }
-                    }
-                }
-            }
-        }
-        result.aiFrameworks.envHints = [...new Set(envHints)];
-        const dockerfiles = [];
-        for (const dir of searchDirs) {
-            const base = dir ? join(projectDir, dir) : projectDir;
-            const prefix = dir ? `${dir}/` : "";
-            const dirFiles = await safeReaddir(base);
-            for (const file of dirFiles) {
-                if (file === "Dockerfile" || file.startsWith("Dockerfile.")) {
-                    const info = await parseDockerfile(base, file);
-                    if (info) {
-                        info.path = `${prefix}${file}`;
-                        dockerfiles.push(info);
-                    }
-                }
-            }
-        }
-        result.dockerfiles = dockerfiles;
-        if (result.docker.running) {
-            try {
-                const { stdout } = await execAsync("docker images ghcr.io/zivisai/zivis-local-runner --format '{{.Tag}}'", { timeout: 5000 });
-                const tag = stdout.trim().replace(/'/g, "");
-                if (tag) {
-                    result.runnerImage = { available: true, tag };
-                }
-                else {
-                    result.runnerImage = {
-                        available: false,
-                        buildCommand: "cd zivis-rt && docker build -f Dockerfile.local-runner -t ghcr.io/zivisai/zivis-local-runner:latest .",
-                    };
-                }
-            }
-            catch {
-                result.runnerImage = {
-                    available: false,
-                    buildCommand: "cd zivis-rt && docker build -f Dockerfile.local-runner -t ghcr.io/zivisai/zivis-local-runner:latest .",
-                };
-            }
-        }
-        result.suggestion = generateSuggestion(result.compose.services, result.aiFrameworks.detected, result.aiFrameworks.envHints, result.dockerfiles);
-        if (result.suggestion) {
-            result.nextStep =
-                `Detected ${result.suggestion.target_type} target at ${result.suggestion.target_url}` +
-                    (result.suggestion.chat_endpoint ? ` (chat endpoint: ${result.suggestion.chat_endpoint})` : "") +
-                    `. Run \`zivis test ai\` to test it.`;
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    };
-}
-async function safeReadFile(filePath) {
-    try {
-        const stats = await stat(filePath);
-        if (stats.size > MAX_FILE_SIZE)
-            return null;
-        const content = await readFile(filePath, "utf-8");
-        return content;
-    }
-    catch {
-        return null;
-    }
-}
-async function safeReaddir(dirPath) {
-    try {
-        const entries = await readdir(dirPath);
-        return entries;
-    }
-    catch {
-        return [];
-    }
-}
-function parseComposeServices(content) {
-    const lines = content.split("\n");
-    const services = [];
-    let inServices = false;
-    let currentService = null;
-    let currentSection = "";
-    let serviceIndent = -1;
-    let sectionIndent = -1;
-    for (const line of lines) {
-        const raw = line;
-        const trimmed = raw.trimEnd().trimStart();
-        if (trimmed === "" || trimmed.startsWith("#"))
-            continue;
-        const indent = raw.length - raw.trimStart().length;
-        if (indent === 0 && /^services:\s*$/.test(trimmed)) {
-            inServices = true;
-            serviceIndent = -1;
-            continue;
-        }
-        if (inServices && indent === 0) {
-            inServices = false;
-            if (currentService)
-                services.push(currentService);
-            currentService = null;
-            continue;
-        }
-        if (!inServices)
-            continue;
-        if (serviceIndent === -1 && /^[\w][\w.-]*:\s*$/.test(trimmed)) {
-            serviceIndent = indent;
-        }
-        if (indent === serviceIndent && /^[\w][\w.-]*:\s*$/.test(trimmed)) {
-            if (currentService)
-                services.push(currentService);
-            const name = trimmed.replace(/:\s*$/, "");
-            currentService = {
-                name,
-                ports: [],
-                status: "unknown",
-                environmentKeys: [],
-                dependsOn: [],
-            };
-            currentSection = "";
-            sectionIndent = -1;
-            continue;
-        }
-        if (!currentService)
-            continue;
-        if (indent > serviceIndent) {
-            const propMatch = trimmed.match(/^(image|ports|environment|depends_on|build):\s*(.*)/);
-            if (propMatch) {
-                const key = propMatch[1];
-                const value = propMatch[2].trim();
-                if (key === "image" && value) {
-                    currentService.image = value.replace(/["']/g, "");
-                    currentSection = "";
-                    continue;
-                }
-                if (key === "ports" || key === "environment" || key === "depends_on") {
-                    currentSection = key;
-                    sectionIndent = indent;
-                    continue;
-                }
-                currentSection = "";
-                continue;
-            }
-            if (currentSection && sectionIndent >= 0 && indent > sectionIndent) {
-                if (trimmed.startsWith("-")) {
-                    const value = trimmed.replace(/^-\s*/, "").replace(/["']/g, "").trim();
-                    if (currentSection === "ports") {
-                        const portMatch = value.match(/(\d+):(\d+)/);
-                        if (portMatch) {
-                            currentService.ports.push({
-                                host: parseInt(portMatch[1], 10),
-                                container: parseInt(portMatch[2], 10),
-                            });
-                        }
-                    }
-                    else if (currentSection === "depends_on") {
-                        currentService.dependsOn.push(value);
-                    }
-                    else if (currentSection === "environment") {
-                        const envKey = value.split("=")[0].trim();
-                        if (envKey)
-                            currentService.environmentKeys.push(envKey);
-                    }
-                }
-                else if (currentSection === "environment" && trimmed.includes(":")) {
-                    const envKey = trimmed.split(":")[0].trim();
-                    if (envKey)
-                        currentService.environmentKeys.push(envKey);
-                }
-            }
-            else if (indent <= sectionIndent) {
-                currentSection = "";
-                sectionIndent = -1;
-                const rePropMatch = trimmed.match(/^(image|ports|environment|depends_on|build):\s*(.*)/);
-                if (rePropMatch) {
-                    const key = rePropMatch[1];
-                    const value = rePropMatch[2].trim();
-                    if (key === "image" && value) {
-                        currentService.image = value.replace(/["']/g, "");
-                    }
-                    else if (key === "ports" || key === "environment" || key === "depends_on") {
-                        currentSection = key;
-                        sectionIndent = indent;
-                    }
-                }
-            }
-        }
-    }
-    if (currentService)
-        services.push(currentService);
-    return services;
-}
-function parseDockerComposePsOutput(stdout) {
-    const containers = [];
-    for (const line of stdout.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            const obj = JSON.parse(trimmed);
-            containers.push({
-                name: obj.Name || obj.name || "",
-                service: obj.Service || obj.service || "",
-            });
-        }
-        catch {
-        }
-    }
-    return containers;
-}
-async function parseDockerfile(dir, filename) {
-    const content = await safeReadFile(join(dir, filename));
-    if (!content)
-        return null;
-    const info = {
-        path: filename,
-        baseImage: "",
-        exposedPorts: [],
-        aiHints: [],
-    };
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (/^FROM\s+/i.test(trimmed)) {
-            const fromMatch = trimmed.match(/^FROM\s+(\S+)/i);
-            if (fromMatch && !info.baseImage) {
-                info.baseImage = fromMatch[1];
-            }
-        }
-        if (/^EXPOSE\s+/i.test(trimmed)) {
-            const ports = trimmed
-                .replace(/^EXPOSE\s+/i, "")
-                .split(/\s+/)
-                .map((p) => parseInt(p, 10))
-                .filter((p) => !isNaN(p));
-            info.exposedPorts.push(...ports);
-        }
-        if (trimmed.includes("pip install") || trimmed.includes("pip3 install")) {
-            for (const ai of PIP_AI_PACKAGES) {
-                if (trimmed.includes(ai.package)) {
-                    info.aiHints.push(`Installs ${ai.name} (${ai.package})`);
-                }
-            }
-        }
-        if (trimmed.includes("npm install") || trimmed.includes("pnpm add") || trimmed.includes("yarn add")) {
-            for (const ai of NPM_AI_PACKAGES) {
-                if (trimmed.includes(ai.package)) {
-                    info.aiHints.push(`Installs ${ai.name} (${ai.package})`);
-                }
-            }
-        }
-        if (/^FROM\s+/i.test(trimmed)) {
-            const image = trimmed.replace(/^FROM\s+/i, "").split(/\s+/)[0].toLowerCase();
-            if (image.includes("ollama"))
-                info.aiHints.push("Uses Ollama base image");
-            if (image.includes("vllm"))
-                info.aiHints.push("Uses vLLM base image");
-            if (image.includes("huggingface") || image.includes("transformers"))
-                info.aiHints.push("Uses HuggingFace base image");
-        }
-    }
-    return info;
-}
-function generateSuggestion(services, frameworks, envHints, dockerfiles) {
-    const reasons = [];
-    const appServices = services.filter((svc) => {
-        const image = (svc.image || "").toLowerCase();
-        return !INFRA_IMAGES.some((infra) => image.includes(infra));
-    });
-    const hasAiFrameworks = frameworks.length > 0;
-    const hasAiEnvKeys = envHints.length > 0;
-    const targetType = hasAiFrameworks || hasAiEnvKeys ? "ai_chat" : "api";
-    if (hasAiFrameworks) {
-        reasons.push(`Detected AI frameworks: ${frameworks.map((f) => f.name).join(", ")}`);
-    }
-    if (hasAiEnvKeys) {
-        reasons.push(`Found AI-related env vars: ${envHints.join(", ")}`);
-    }
-    let targetPort = null;
-    const runningApps = appServices.filter((svc) => svc.status === "running" && svc.ports.length > 0);
-    if (runningApps.length > 0) {
-        const preferred = runningApps.find((svc) => svc.ports.some((p) => p.host >= 3000 && p.host <= 9000));
-        const target = preferred || runningApps[0];
-        targetPort = target.ports[0].host;
-        reasons.push(`Service "${target.name}" is running on port ${targetPort}`);
-    }
-    else if (appServices.length > 0) {
-        const withPorts = appServices.find((svc) => svc.ports.length > 0);
-        if (withPorts) {
-            targetPort = withPorts.ports[0].host;
-            reasons.push(`Service "${withPorts.name}" has port ${targetPort} mapped`);
-        }
-    }
-    if (!targetPort) {
-        for (const df of dockerfiles) {
-            if (df.exposedPorts.length > 0) {
-                targetPort = df.exposedPorts[0];
-                reasons.push(`Dockerfile "${df.path}" exposes port ${targetPort}`);
-                break;
-            }
-        }
-    }
-    if (!targetPort) {
-        targetPort = 3000;
-        reasons.push("Using default port 3000 (no port mapping found)");
-    }
-    const chatEndpoint = inferChatEndpoint(frameworks);
-    if (chatEndpoint) {
-        reasons.push(`Inferred endpoint ${chatEndpoint} from framework detection`);
-    }
-    const { requestTemplate, responsePath } = inferRequestFormat(frameworks);
-    let confidence = "low";
-    if (hasAiFrameworks && targetPort && runningApps.length > 0) {
-        confidence = "high";
-    }
-    else if (hasAiFrameworks || hasAiEnvKeys) {
-        confidence = "medium";
-    }
-    return {
-        target_url: `http://localhost:${targetPort}`,
-        target_type: targetType,
-        chat_endpoint: chatEndpoint,
-        request_template: requestTemplate,
-        response_path: responsePath,
-        confidence,
-        reasoning: reasons.join(". ") + ".",
-    };
-}
-function inferChatEndpoint(frameworks) {
-    const names = new Set(frameworks.map((f) => f.name));
-    if (names.has("Vercel AI SDK") || names.has("Vercel AI SDK (OpenAI)") || names.has("Vercel AI SDK (Anthropic)"))
-        return "/api/chat";
-    if (names.has("Ollama"))
-        return "/api/chat";
-    if (names.has("OpenAI SDK") || names.has("Azure OpenAI"))
-        return "/v1/chat/completions";
-    if (names.has("LiteLLM"))
-        return "/chat/completions";
-    if (names.has("vLLM"))
-        return "/v1/chat/completions";
-    if (names.has("Gradio"))
-        return "/api/predict";
-    if (frameworks.length > 0)
-        return "/api/chat";
-    return undefined;
-}
-function inferRequestFormat(frameworks) {
-    const names = new Set(frameworks.map((f) => f.name));
-    if (names.has("OpenAI SDK") ||
-        names.has("Azure OpenAI") ||
-        names.has("vLLM") ||
-        names.has("LiteLLM")) {
-        return {
-            requestTemplate: JSON.stringify({
-                model: "gpt-4",
-                messages: [{ role: "user", content: "{{message}}" }],
-            }),
-            responsePath: "choices[0].message.content",
-        };
-    }
-    if (names.has("Vercel AI SDK") || names.has("Vercel AI SDK (OpenAI)") || names.has("Vercel AI SDK (Anthropic)")) {
-        return {
-            requestTemplate: JSON.stringify({
-                messages: [{ role: "user", content: "{{message}}" }],
-            }),
-            responsePath: undefined,
-        };
-    }
-    if (names.has("Ollama")) {
-        return {
-            requestTemplate: JSON.stringify({
-                model: "llama3",
-                messages: [{ role: "user", content: "{{message}}" }],
-                stream: false,
-            }),
-            responsePath: "message.content",
-        };
-    }
-    return {};
-}