@vtstech/pi-model-test 1.0.3

package/model-test.js

@@ -0,0 +1,1649 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// .build-npm/model-test/model-test.temp.ts
+var model_test_temp_exports = {};
+__export(model_test_temp_exports, {
+  default: () => model_test_temp_default
+});
+module.exports = __toCommonJS(model_test_temp_exports);
+var fs = __toESM(require("node:fs"));
+var os = __toESM(require("node:os"));
+var path = __toESM(require("node:path"));
+var import_format = require("@vtstech/pi-shared/format");
+var import_ollama = require("@vtstech/pi-shared/ollama");
+var BUILTIN_PROVIDERS = {
+  openrouter: { api: "openai-completions", baseUrl: "https://openrouter.ai/api/v1", envKey: "OPENROUTER_API_KEY" },
+  anthropic: { api: "anthropic-messages", baseUrl: "https://api.anthropic.com/v1", envKey: "ANTHROPIC_API_KEY" },
+  google: { api: "gemini", baseUrl: "https://generativelanguage.googleapis.com", envKey: "GOOGLE_API_KEY" },
+  openai: { api: "openai-completions", baseUrl: "https://api.openai.com/v1", envKey: "OPENAI_API_KEY" },
+  groq: { api: "openai-completions", baseUrl: "https://api.groq.com/v1", envKey: "GROQ_API_KEY" },
+  deepseek: { api: "openai-completions", baseUrl: "https://api.deepseek.com/v1", envKey: "DEEPSEEK_API_KEY" },
+  mistral: { api: "openai-completions", baseUrl: "https://api.mistral.ai/v1", envKey: "MISTRAL_API_KEY" },
+  xai: { api: "openai-completions", baseUrl: "https://api.x.ai/v1", envKey: "XAI_API_KEY" },
+  together: { api: "openai-completions", baseUrl: "https://api.together.xyz/v1", envKey: "TOGETHER_API_KEY" },
+  fireworks: { api: "openai-completions", baseUrl: "https://api.fireworks.ai/inference/v1", envKey: "FIREWORKS_API_KEY" },
+  cohere: { api: "cohere-chat", baseUrl: "https://api.cohere.com/v1", envKey: "COHERE_API_KEY" }
+};
+function detectProvider(ctx) {
+  const model = ctx.model;
+  if (!model) return { kind: "unknown", name: "none" };
+  const providerName = model.provider || "";
+  if (!providerName) return { kind: "unknown", name: "none" };
+  const modelsJson = (0, import_ollama.readModelsJson)();
+  const userProviderCfg = (modelsJson.providers || {})[providerName];
+  if (userProviderCfg) {
+    const baseUrl = userProviderCfg.baseUrl || "";
+    const apiMode = userProviderCfg.api || "";
+    const apiKey = userProviderCfg.apiKey || "";
+    const isOllama = /ollama/i.test(providerName) || /localhost:\d+/.test(baseUrl) || /127\.0\.0\.1:\d+/.test(baseUrl) || /\/api\/chat/.test(baseUrl) || apiMode === "ollama";
+    if (isOllama) {
+      return { kind: "ollama", name: providerName, apiMode: "ollama", baseUrl, apiKey };
+    }
+    if (/\/api\/chat/.test(baseUrl)) {
+      return { kind: "ollama", name: providerName, apiMode: "ollama", baseUrl, apiKey };
+    }
+    return {
+      kind: "builtin",
+      name: providerName,
+      apiMode: apiMode || userProviderCfg.api || "openai-completions",
+      baseUrl,
+      apiKey
+    };
+  }
+  const builtin = BUILTIN_PROVIDERS[providerName];
+  if (builtin) {
+    const apiKey = process.env[builtin.envKey] || "";
+    return {
+      kind: "builtin",
+      name: providerName,
+      apiMode: builtin.api,
+      baseUrl: builtin.baseUrl,
+      envKey: builtin.envKey,
+      apiKey
+    };
+  }
+  return { kind: "unknown", name: providerName };
+}
+var CONFIG = {
+  // General API settings
+  DEFAULT_TIMEOUT_MS: 6e5,
+  // 8.3 minutes - default timeout for model responses
+  CONNECT_TIMEOUT_S: 30,
+  // 30 seconds to establish connection
+  MAX_RETRIES: 1,
+  // Single retry for transient failures
+  RETRY_DELAY_MS: 2e3,
+  // 2 seconds between retries
+  EXEC_BUFFER_MS: 5e3,
+  // Extra buffer for exec timeout over curl timeout
+  // Model generation settings
+  NUM_PREDICT: 1024,
+  // Max tokens in response
+  TEMPERATURE: 0.1,
+  // Low temperature for more deterministic output
+  // Test-specific settings
+  MIN_THINKING_LENGTH: 10,
+  // Minimum chars to consider thinking tokens valid
+  TOOL_TEST_TIMEOUT_MS: 9e4,
+  // 90 seconds for tool usage tests
+  TOOL_TEST_MAX_TIME_S: 9999,
+  // Max curl time for tool tests (effectively unlimited)
+  TOOL_SUPPORT_TIMEOUT_MS: 26e4,
+  // 2+ minutes for tool support detection
+  TOOL_SUPPORT_MAX_TIME_S: 240,
+  // Max curl time for tool support detection
+  // Metadata retrieval
+  TAGS_TIMEOUT_MS: 15e3,
+  // 15 seconds for /api/tags
+  TAGS_CONNECT_TIMEOUT_S: 10,
+  // 10 seconds connection timeout for tags
+  MODEL_INFO_TIMEOUT_MS: 1e4,
+  // 10 seconds for model info lookup
+  // Provider API settings
+  PROVIDER_TIMEOUT_MS: 12e4,
+  // 2 minutes for cloud provider API calls
+  PROVIDER_TOOL_TIMEOUT_MS: 6e4,
+  // 60 seconds for tool usage tests on providers
+  // Rate limiting
+  TEST_DELAY_MS: 3e4
+  // 30 seconds between tests to avoid rate limiting
+};
+var TOOL_SUPPORT_CACHE_DIR = path.join(os.homedir(), ".pi", "agent", "cache");
+var TOOL_SUPPORT_CACHE_PATH = path.join(TOOL_SUPPORT_CACHE_DIR, "tool_support.json");
+function readToolSupportCache() {
+  try {
+    if (fs.existsSync(TOOL_SUPPORT_CACHE_PATH)) {
+      const raw = fs.readFileSync(TOOL_SUPPORT_CACHE_PATH, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function writeToolSupportCache(cache) {
+  if (!fs.existsSync(TOOL_SUPPORT_CACHE_DIR)) {
+    fs.mkdirSync(TOOL_SUPPORT_CACHE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(TOOL_SUPPORT_CACHE_PATH, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+}
+function getCachedToolSupport(model) {
+  const cache = readToolSupportCache();
+  const entry = cache[model];
+  if (!entry) return null;
+  if (!entry.support || !["native", "react", "none"].includes(entry.support)) return null;
+  return entry;
+}
+function cacheToolSupport(model, support, family) {
+  const cache = readToolSupportCache();
+  cache[model] = {
+    support,
+    testedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    family
+  };
+  writeToolSupportCache(cache);
+}
+function model_test_temp_default(pi) {
+  const OLLAMA_BASE = (0, import_ollama.getOllamaBaseUrl)();
+  async function rateLimitDelay(lines) {
+    if (CONFIG.TEST_DELAY_MS > 0) {
+      lines.push((0, import_format.info)(`Waiting ${(0, import_format.msHuman)(CONFIG.TEST_DELAY_MS)} to avoid rate limiting...`));
+      await new Promise((r) => setTimeout(r, CONFIG.TEST_DELAY_MS));
+    }
+  }
+  async function ollamaChat(model, messages, options = {}, timeoutMs = CONFIG.DEFAULT_TIMEOUT_MS, retries = CONFIG.MAX_RETRIES) {
+    const body = { model, messages, stream: false, options: { num_predict: CONFIG.NUM_PREDICT, temperature: CONFIG.TEMPERATURE, ...options } };
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      const start = Date.now();
+      try {
+        const result = await pi.exec("curl", [
+          "-s",
+          "--fail-with-body",
+          "-X",
+          "POST",
+          "--connect-timeout",
+          String(CONFIG.CONNECT_TIMEOUT_S),
+          "--max-time",
+          String(Math.ceil(timeoutMs / 1e3)),
+          `${OLLAMA_BASE}/api/chat`,
+          "-H",
+          "Content-Type: application/json",
+          "-d",
+          JSON.stringify(body)
+        ], { timeout: timeoutMs + CONFIG.EXEC_BUFFER_MS });
+        const elapsedMs = Date.now() - start;
+        if (result.code !== 0) {
+          const detail = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+          throw new Error(`curl exited ${result.code}: ${detail}`);
+        }
+        if (!result.stdout.trim()) {
+          if (attempt < retries) {
+            await new Promise((r) => setTimeout(r, CONFIG.RETRY_DELAY_MS));
+            continue;
+          }
+          throw new Error(`Empty response from Ollama after ${attempt + 1} attempt(s)`);
+        }
+        const parsed = JSON.parse(result.stdout);
+        return { response: parsed, elapsedMs };
+      } catch (e) {
+        if (attempt < retries && (e.message.includes("Empty response") || e.message.includes("timed out") || e.message.includes("curl exited 22") || e.message.includes("curl exited 28") || e.message.includes("curl exited 35") || e.message.includes("curl exited 52"))) {
+          await new Promise((r) => setTimeout(r, CONFIG.RETRY_DELAY_MS));
+          continue;
+        }
+        throw e;
+      }
+    }
+    throw new Error("Unreachable");
+  }
+  async function providerChat(providerInfo, model, messages, options = {}) {
+    const { baseUrl, apiKey } = providerInfo;
+    const maxTokens = options.maxTokens ?? CONFIG.NUM_PREDICT;
+    const temperature = options.temperature ?? CONFIG.TEMPERATURE;
+    const timeoutMs = options.timeoutMs ?? CONFIG.PROVIDER_TIMEOUT_MS;
+    if (!baseUrl) throw new Error(`No base URL for provider "${providerInfo.name}"`);
+    if (!apiKey) throw new Error(`No API key for provider "${providerInfo.name}". Set ${providerInfo.envKey || "the appropriate env var"}.`);
+    const url = `${baseUrl}/chat/completions`;
+    const body = {
+      model,
+      messages,
+      max_tokens: maxTokens,
+      temperature,
+      stream: false
+    };
+    if (options.tools && options.tools.length > 0) {
+      body.tools = options.tools;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const start = Date.now();
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const elapsedMs = Date.now() - start;
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => "unknown error");
+        throw new Error(`API returned ${res.status}: ${(0, import_format.truncate)(errorText, 200)}`);
+      }
+      const data = await res.json();
+      const choice = data.choices?.[0];
+      const message = choice?.message || {};
+      const content = message.content || "";
+      const toolCalls = message.tool_calls || void 0;
+      return {
+        content,
+        toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0,
+        elapsedMs,
+        usage: data.usage
+      };
+    } catch (e) {
+      const elapsedMs = Date.now() - start;
+      if (e.name === "AbortError") {
+        throw new Error(`Provider API timed out after ${(0, import_format.msHuman)(elapsedMs)}`);
+      }
+      throw e;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async function testConnectivity(providerInfo, model) {
+    try {
+      const start = Date.now();
+      const result = await providerChat(providerInfo, model, [
+        { role: "user", content: "Reply with exactly: PONG" }
+      ], { maxTokens: 10, timeoutMs: 3e4 });
+      const elapsedMs = Date.now() - start;
+      const content = result.content.trim().toUpperCase();
+      const reachable = true;
+      const authValid = true;
+      const hasPong = content.includes("PONG");
+      return {
+        pass: reachable && authValid,
+        reachable,
+        authValid,
+        modelName: model,
+        elapsedMs
+      };
+    } catch (e) {
+      const start = Date.now();
+      let reachable = false;
+      let authValid = false;
+      const msg = e.message || "";
+      if (msg.includes("timed out") || msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed")) {
+        reachable = false;
+        authValid = false;
+      } else if (msg.includes("401") || msg.includes("403") || msg.includes("authentication") || msg.includes("unauthorized") || msg.includes("invalid API key")) {
+        reachable = true;
+        authValid = false;
+      } else if (msg.includes("404") || msg.includes("model")) {
+        reachable = true;
+        authValid = true;
+      } else {
+        reachable = true;
+        authValid = false;
+      }
+      return {
+        pass: false,
+        reachable,
+        authValid,
+        modelName: model,
+        elapsedMs: 0,
+        error: msg
+      };
+    }
+  }
+  async function testReasoning(model) {
+    const prompt = `A snail climbs 3 feet up a wall each day, but slides back 2 feet each night. The wall is 10 feet tall. How many days does it take the snail to reach the top? Think step by step and give the final answer on its own line like: ANSWER: <number>`;
+    try {
+      let response, elapsedMs;
+      let usedThinkingFallback = false;
+      try {
+        const result = await ollamaChat(model, [
+          { role: "user", content: prompt }
+        ]);
+        response = result.response;
+        elapsedMs = result.elapsedMs;
+        const msg2 = response?.message?.content || "";
+        const thinking2 = response?.message?.thinking || "";
+        if (msg2.trim().length === 0 && thinking2.trim().length === 0) {
+          throw new Error("empty \u2014 will retry with thinking");
+        }
+      } catch (firstErr) {
+        if (firstErr.message?.includes("empty \u2014 will retry with thinking")) {
+          const retry = await ollamaChat(model, [
+            { role: "user", content: prompt }
+          ], { think: true });
+          response = retry.response;
+          elapsedMs = retry.elapsedMs;
+          usedThinkingFallback = true;
+        } else {
+          throw firstErr;
+        }
+      }
+      let msg = response?.message?.content || "";
+      const thinking = response?.message?.thinking || "";
+      const effectiveMsg = msg.trim().length > 0 ? msg : thinking;
+      if (effectiveMsg.trim().length === 0) {
+        return { pass: false, score: "ERROR", reasoning: "Empty response from Ollama (no content or thinking tokens)", answer: "?", elapsedMs };
+      }
+      const allNumbers = effectiveMsg.match(/\b(\d+)\b/g) || [];
+      const answer = allNumbers.length > 0 ? allNumbers[allNumbers.length - 1] : "?";
+      const isCorrect = answer === "8";
+      const reasoningPatterns = [
+        "because",
+        "therefore",
+        "since",
+        "step",
+        "subtract",
+        "minus",
+        "each day",
+        "each night",
+        "slides",
+        "climbs",
+        "night",
+        "reaches",
+        "finally",
+        "last day"
+      ];
+      const hasReasoningWords = reasoningPatterns.some((w) => effectiveMsg.toLowerCase().includes(w));
+      const hasNumberedSteps = /^\s*\d+\.\s/m.test(effectiveMsg);
+      const hasReasoning = hasReasoningWords || hasNumberedSteps;
+      let score;
+      let pass;
+      if (isCorrect && hasReasoning) {
+        score = "STRONG";
+        pass = true;
+      } else if (isCorrect) {
+        score = "MODERATE";
+        pass = true;
+      } else if (hasReasoning) {
+        score = "WEAK";
+        pass = false;
+      } else {
+        score = "FAIL";
+        pass = false;
+      }
+      const displayMsg = msg.trim().length > 0 ? effectiveMsg : `[thinking tokens] ${effectiveMsg}`;
+      return { pass, score, reasoning: displayMsg, answer, elapsedMs };
+    } catch (e) {
+      return { pass: false, score: "ERROR", reasoning: e.message, answer: "?", elapsedMs: 0 };
+    }
+  }
+  async function testReasoningProvider(providerInfo, model) {
+    const prompt = `A snail climbs 3 feet up a wall each day, but slides back 2 feet each night. The wall is 10 feet tall. How many days does it take the snail to reach the top? Think step by step and give the final answer on its own line like: ANSWER: <number>`;
+    try {
+      const result = await providerChat(providerInfo, model, [
+        { role: "user", content: prompt }
+      ]);
+      const msg = result.content.trim();
+      if (msg.length === 0) {
+        return { pass: false, score: "ERROR", reasoning: "Empty response from provider", answer: "?", elapsedMs: result.elapsedMs };
+      }
+      const allNumbers = msg.match(/\b(\d+)\b/g) || [];
+      const answer = allNumbers.length > 0 ? allNumbers[allNumbers.length - 1] : "?";
+      const isCorrect = answer === "8";
+      const reasoningPatterns = [
+        "because",
+        "therefore",
+        "since",
+        "step",
+        "subtract",
+        "minus",
+        "each day",
+        "each night",
+        "slides",
+        "climbs",
+        "night",
+        "reaches",
+        "finally",
+        "last day"
+      ];
+      const hasReasoningWords = reasoningPatterns.some((w) => msg.toLowerCase().includes(w));
+      const hasNumberedSteps = /^\s*\d+\.\s/m.test(msg);
+      const hasReasoning = hasReasoningWords || hasNumberedSteps;
+      let score;
+      let pass;
+      if (isCorrect && hasReasoning) {
+        score = "STRONG";
+        pass = true;
+      } else if (isCorrect) {
+        score = "MODERATE";
+        pass = true;
+      } else if (hasReasoning) {
+        score = "WEAK";
+        pass = false;
+      } else {
+        score = "FAIL";
+        pass = false;
+      }
+      return { pass, score, reasoning: msg, answer, elapsedMs: result.elapsedMs };
+    } catch (e) {
+      return { pass: false, score: "ERROR", reasoning: e.message, answer: "?", elapsedMs: 0 };
+    }
+  }
+  async function testThinking(model) {
+    const prompt = "Multiply 37 by 43. Explain your reasoning step by step and give the final answer.";
+    try {
+      const { response, elapsedMs } = await ollamaChat(model, [
+        { role: "user", content: prompt }
+      ], { think: true });
+      const msg = response?.message?.content || "";
+      const thinking = response?.message?.thinking || "";
+      const hasThinking = !!thinking && thinking.length > CONFIG.MIN_THINKING_LENGTH;
+      const thinkTagMatch = msg.match(/<think[^>]*>([\s\S]*?)<\/think>/i);
+      const hasThinkTags = !!thinkTagMatch;
+      return {
+        supported: hasThinking || hasThinkTags,
+        thinkingContent: hasThinking ? thinking : hasThinkTags ? thinkTagMatch[1] : "none",
+        answerContent: hasThinkTags ? msg.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, "").trim() : msg,
+        elapsedMs
+      };
+    } catch (e) {
+      return { supported: false, thinkingContent: `error: ${e.message}`, answerContent: "", elapsedMs: 0 };
+    }
+  }
+  async function testToolUsage(model) {
+    const tools = [
+      {
+        type: "function",
+        function: {
+          name: "get_weather",
+          description: "Get the current weather for a location",
+          parameters: {
+            type: "object",
+            properties: {
+              location: { type: "string", description: "City name" },
+              unit: { type: "string", enum: ["celsius", "fahrenheit"] }
+            },
+            required: ["location"]
+          }
+        }
+      }
+    ];
+    const body = {
+      model,
+      messages: [
+        { role: "system", content: "You are a helpful assistant. Use the available tools when needed." },
+        { role: "user", content: "What's the weather like in Paris right now?" }
+      ],
+      tools,
+      stream: false,
+      options: { num_predict: CONFIG.NUM_PREDICT, temperature: CONFIG.TEMPERATURE }
+    };
+    try {
+      const start = Date.now();
+      const result = await pi.exec("curl", [
+        "-s",
+        "--fail-with-body",
+        "-X",
+        "POST",
+        "--connect-timeout",
+        String(CONFIG.CONNECT_TIMEOUT_S),
+        "--max-time",
+        String(CONFIG.TOOL_TEST_MAX_TIME_S),
+        `${OLLAMA_BASE}/api/chat`,
+        "-H",
+        "Content-Type: application/json",
+        "-d",
+        JSON.stringify(body)
+      ], { timeout: CONFIG.TOOL_TEST_TIMEOUT_MS });
+      const elapsedMs = Date.now() - start;
+      if (result.code !== 0) {
+        const detail = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+        return { pass: false, score: "ERROR", hasToolCalls: false, toolCall: `curl error: ${result.code}: ${detail}`, response: "", elapsedMs };
+      }
+      if (!result.stdout.trim()) throw new Error("Empty response from Ollama");
+      const parsed = JSON.parse(result.stdout);
+      const toolCalls = parsed?.message?.tool_calls;
+      const content = parsed?.message?.content || "";
+      if (toolCalls && toolCalls.length > 0) {
+        const call = toolCalls[0];
+        const fn = call.function || {};
+        let args = {};
+        try {
+          args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments || {};
+        } catch {
+          return {
+            pass: true,
+            score: "WEAK",
+            hasToolCalls: true,
+            toolCall: `malformed args: ${String(fn.arguments)}`,
+            response: content,
+            elapsedMs
+          };
+        }
+        const hasCorrectTool = fn.name === "get_weather";
+        const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
+        let score;
+        if (hasCorrectTool && hasLocation) {
+          score = "STRONG";
+        } else if (hasCorrectTool) {
+          score = "MODERATE";
+        } else {
+          score = "WEAK";
+        }
+        return {
+          pass: true,
+          score,
+          hasToolCalls: true,
+          toolCall: `${fn.name}(${JSON.stringify(args)})`,
+          response: content,
+          elapsedMs
+        };
+      }
+      const firstBrace = content.indexOf("{");
+      let textToolParsed = null;
+      if (firstBrace !== -1) {
+        const lastBrace = content.lastIndexOf("}");
+        if (lastBrace > firstBrace) {
+          const jsonCandidate = content.slice(firstBrace, lastBrace + 1);
+          try {
+            textToolParsed = JSON.parse(jsonCandidate);
+          } catch {
+          }
+        }
+      }
+      if (textToolParsed && typeof textToolParsed.name === "string") {
+        const fnName = textToolParsed.name;
+        const rawArgs = textToolParsed.arguments || { ...textToolParsed };
+        const { name: _, ...fnArgs } = rawArgs;
+        const isWeatherTool = fnName === "get_weather";
+        const hasLocation = typeof fnArgs.location === "string" && fnArgs.location.toLowerCase().includes("paris");
+        let score;
+        if (isWeatherTool && hasLocation) {
+          score = "STRONG";
+        } else if (isWeatherTool) {
+          score = "MODERATE";
+        } else {
+          score = "WEAK";
+        }
+        return {
+          pass: true,
+          score,
+          hasToolCalls: true,
+          toolCall: `${fnName}(${JSON.stringify(fnArgs)})`,
+          response: content,
+          elapsedMs
+        };
+      }
+      return {
+        pass: false,
+        score: "FAIL",
+        hasToolCalls: false,
+        toolCall: "none",
+        response: content,
+        elapsedMs
+      };
+    } catch (e) {
+      return { pass: false, score: "ERROR", hasToolCalls: false, toolCall: `error: ${e.message}`, response: "", elapsedMs: 0 };
+    }
+  }
+  async function testToolUsageProvider(providerInfo, model) {
+    const tools = [
+      {
+        type: "function",
+        function: {
+          name: "get_weather",
+          description: "Get the current weather for a location",
+          parameters: {
+            type: "object",
+            properties: {
+              location: { type: "string", description: "City name" },
+              unit: { type: "string", enum: ["celsius", "fahrenheit"] }
+            },
+            required: ["location"]
+          }
+        }
+      }
+    ];
+    try {
+      const result = await providerChat(providerInfo, model, [
+        { role: "system", content: "You are a helpful assistant. Use the available tools when needed." },
+        { role: "user", content: "What's the weather like in Paris right now?" }
+      ], {
+        maxTokens: CONFIG.NUM_PREDICT,
+        tools,
+        timeoutMs: CONFIG.PROVIDER_TOOL_TIMEOUT_MS
+      });
+      const content = result.content;
+      const toolCalls = result.toolCalls;
+      if (toolCalls && toolCalls.length > 0) {
+        const call = toolCalls[0];
+        const fn = call.function || {};
+        let args = {};
+        try {
+          args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments || {};
+        } catch {
+          return {
+            pass: true,
+            score: "WEAK",
+            hasToolCalls: true,
+            toolCall: `malformed args: ${String(fn.arguments)}`,
+            response: content,
+            elapsedMs: result.elapsedMs
+          };
+        }
+        const hasCorrectTool = fn.name === "get_weather";
+        const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
+        let score;
+        if (hasCorrectTool && hasLocation) {
+          score = "STRONG";
+        } else if (hasCorrectTool) {
+          score = "MODERATE";
+        } else {
+          score = "WEAK";
+        }
+        return {
+          pass: true,
+          score,
+          hasToolCalls: true,
+          toolCall: `${fn.name}(${JSON.stringify(args)})`,
+          response: content,
+          elapsedMs: result.elapsedMs
+        };
+      }
+      const firstBrace = content.indexOf("{");
+      let textToolParsed = null;
+      if (firstBrace !== -1) {
+        const lastBrace = content.lastIndexOf("}");
+        if (lastBrace > firstBrace) {
+          const jsonCandidate = content.slice(firstBrace, lastBrace + 1);
+          try {
+            textToolParsed = JSON.parse(jsonCandidate);
+          } catch {
+          }
+        }
+      }
+      if (textToolParsed && typeof textToolParsed.name === "string") {
+        const fnName = textToolParsed.name;
+        const rawArgs = textToolParsed.arguments || { ...textToolParsed };
+        const { name: _, ...fnArgs } = rawArgs;
+        const isWeatherTool = fnName === "get_weather";
+        const hasLocation = typeof fnArgs.location === "string" && fnArgs.location.toLowerCase().includes("paris");
+        let score;
+        if (isWeatherTool && hasLocation) {
+          score = "STRONG";
+        } else if (isWeatherTool) {
+          score = "MODERATE";
+        } else {
+          score = "WEAK";
+        }
+        return {
+          pass: true,
+          score,
+          hasToolCalls: true,
+          toolCall: `${fnName}(${JSON.stringify(fnArgs)})`,
+          response: content,
+          elapsedMs: result.elapsedMs
+        };
+      }
+      return {
+        pass: false,
+        score: "FAIL",
+        hasToolCalls: false,
+        toolCall: "none",
+        response: content,
+        elapsedMs: result.elapsedMs
+      };
+    } catch (e) {
+      return { pass: false, score: "ERROR", hasToolCalls: false, toolCall: `error: ${e.message}`, response: "", elapsedMs: 0 };
+    }
+  }
+  async function testReactParsing(model) {
+    const systemPrompt = [
+      "You are a helpful assistant with access to tools.",
+      "When you need to use a tool, you MUST output in this EXACT format:",
+      "Thought: <your reasoning about what to do>",
+      "Action: <tool_name>",
+      "Action Input: <JSON object with arguments>",
+      "Do NOT output anything after the Action Input line.",
+      "The available tools are: get_weather (parameters: location: string), calculate (parameters: expression: string)."
+    ].join("\n");
+    const body = {
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: "What's the weather like in Tokyo? Use the get_weather tool." }
+      ],
+      stream: false,
+      options: { num_predict: CONFIG.NUM_PREDICT, temperature: CONFIG.TEMPERATURE }
+    };
+    try {
+      const start = Date.now();
+      const result = await pi.exec("curl", [
+        "-s",
+        "--fail-with-body",
+        "-X",
+        "POST",
+        "--connect-timeout",
+        String(CONFIG.CONNECT_TIMEOUT_S),
+        "--max-time",
+        String(CONFIG.TOOL_TEST_MAX_TIME_S),
+        `${OLLAMA_BASE}/api/chat`,
+        "-H",
+        "Content-Type: application/json",
+        "-d",
+        JSON.stringify(body)
+      ], { timeout: CONFIG.TOOL_TEST_TIMEOUT_MS });
+      const elapsedMs = Date.now() - start;
+      if (result.code !== 0) {
+        const detail = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+        return { pass: false, score: "ERROR", toolCall: `curl error: ${result.code}: ${detail}`, thought: "", response: "", elapsedMs };
+      }
+      if (!result.stdout.trim()) throw new Error("Empty response from Ollama");
+      const parsed = JSON.parse(result.stdout);
+      const content = (parsed?.message?.content || "").trim();
+      if (!content) {
+        return { pass: false, score: "FAIL", toolCall: "empty response", thought: "", response: "", elapsedMs };
+      }
+      const THOUGHT_RE = /Thought:\s*(.*?)(?=Action:|Final Answer:|$)/is;
+      const ACTION_RE = /Action:\s*[`"']?(\w+)[`"']?\s*\n?\s*Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:|Action:)|$)/is;
+      const ACTION_RE_SAMELINE = /Action:\s*[`"']?(\w+)[`"']?\s+Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:)|$)/is;
+      const ACTION_RE_LOOSE = /Action:\s*(.+?)\n\s*Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:|Action:)|$)/is;
+      const ACTION_RE_PAREN = /Action:\s*(\w+)\s*\(([^)]*)\)/i;
+      let thought = "";
+      const thoughtMatch = THOUGHT_RE.exec(content);
+      if (thoughtMatch) thought = thoughtMatch[1].trim();
+      let match = ACTION_RE.exec(content);
+      if (!match) match = ACTION_RE_SAMELINE.exec(content);
+      let looseMatch = false;
+      if (!match) match = ACTION_RE_LOOSE.exec(content), looseMatch = true;
+      let parenMatch = false;
+      if (!match) match = ACTION_RE_PAREN.exec(content), parenMatch = true;
+      if (match) {
+        let toolName = match[1].trim().replace(/[`"']/g, "");
+        if (looseMatch) {
+          const actionText = toolName.toLowerCase();
+          if (actionText.includes("get_weather")) toolName = "get_weather";
+          else {
+            const toolWords = actionText.match(/\b[a-z][a-z0-9]*(?:[_-][a-z0-9]+)+\b/gi) || [];
+            if (toolWords.length > 0) toolName = toolWords[0];
+          }
+        }
+        const rawArgs = parenMatch ? match[2].trim().replace(/^```\w*\s*/gm, "").replace(/```\s*$/gm, "").trim() : match[2].trim().replace(/^```\w*\s*/gm, "").replace(/```\s*$/gm, "").trim();
+        let argsParsed = false;
+        let argsStr = rawArgs;
+        if (parenMatch && rawArgs && !rawArgs.startsWith("{")) {
+          const pairs = rawArgs.match(/(\w+)\s*:\s*("[^"]*"|'[^']*'|\S+)/g);
+          if (pairs) {
+            const obj = {};
+            for (const p of pairs) {
+              const colonIdx = p.indexOf(":");
+              const key = p.slice(0, colonIdx).trim();
+              let val = p.slice(colonIdx + 1).trim();
+              if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+                val = val.slice(1, -1);
+              }
+              obj[key] = val;
+            }
+            try {
+              argsStr = JSON.stringify(obj);
+              argsParsed = true;
+            } catch {
+            }
+          }
+        }
+        if (!argsParsed) {
+          const jsonStart = rawArgs.indexOf("{");
+          if (jsonStart !== -1) {
+            let depth = 0;
+            let jsonEnd = -1;
+            for (let i = jsonStart; i < rawArgs.length; i++) {
+              if (rawArgs[i] === "{") depth++;
+              else if (rawArgs[i] === "}") {
+                depth--;
+                if (depth === 0) {
+                  jsonEnd = i;
+                  break;
+                }
+              }
+            }
+            if (jsonEnd !== -1) {
+              const jsonStr = rawArgs.slice(jsonStart, jsonEnd + 1);
+              try {
+                JSON.parse(jsonStr);
+                argsParsed = true;
+                argsStr = jsonStr;
+              } catch {
+              }
+            }
+          }
+        }
+        let score;
+        const isWeatherTool = toolName.toLowerCase().includes("get_weather") || toolName.toLowerCase() === "get_weather";
+        if (isWeatherTool && argsParsed) {
+          score = "STRONG";
+        } else if (isWeatherTool) {
+          score = "MODERATE";
+        } else {
+          score = "WEAK";
+        }
+        return {
+          pass: true,
+          score,
+          toolCall: `${toolName}(${argsStr})`,
+          thought,
+          response: content,
+          elapsedMs
+        };
+      }
+      const hasToolMention = /\bget_weather\b/i.test(content) || /\btool\b/i.test(content);
+      if (hasToolMention) {
+        return {
+          pass: false,
+          score: "FAIL",
+          toolCall: "none \u2014 model mentioned tool but not in ReAct format",
+          thought: "",
+          response: content,
+          elapsedMs
+        };
+      }
+      return {
+        pass: false,
+        score: "FAIL",
+        toolCall: "none",
+        thought: "",
+        response: content,
+        elapsedMs
+      };
+    } catch (e) {
+      return { pass: false, score: "ERROR", toolCall: `error: ${e.message}`, thought: "", response: "", elapsedMs: 0 };
+    }
+  }
+  async function testInstructionFollowing(model) {
+    const prompt = `You must respond with ONLY a valid JSON object. No markdown, no explanation, no backticks, no extra text.
+
+The JSON object must have exactly these 4 keys:
+- "name" (string): your model name
+- "can_count" (boolean): true
+- "sum" (number): the result of 15 + 27
+- "language" (string): the language you are responding in`;
+    try {
+      const { response, elapsedMs } = await ollamaChat(model, [
+        { role: "user", content: prompt }
+      ], { num_predict: CONFIG.NUM_PREDICT });
+      const msg = (response?.message?.content || "").trim();
+      let parsed = null;
+      let repairNote = "";
+      try {
+        const cleaned = msg.replace(/```json?\s*/gi, "").replace(/```/g, "").trim();
+        parsed = JSON.parse(cleaned);
+      } catch {
+        const cleaned = msg.replace(/```json?\s*/gi, "").replace(/```/g, "").trim();
+        const openBraces = (cleaned.match(/\{/g) || []).length;
+        const closeBraces = (cleaned.match(/\}/g) || []).length;
+        const openBrackets = (cleaned.match(/\[/g) || []).length;
+        const closeBrackets = (cleaned.match(/\]/g) || []).length;
+        if (openBraces > closeBraces || openBrackets > closeBrackets) {
+          const repaired = cleaned + "}".repeat(Math.max(0, openBraces - closeBraces)) + "]".repeat(Math.max(0, openBrackets - closeBrackets));
+          try {
+            parsed = JSON.parse(repaired);
+            repairNote = " (repaired truncated JSON)";
+          } catch {
+          }
+        }
+      }
+      if (!parsed) {
+        return { pass: false, score: "FAIL", output: (0, import_format.sanitizeForReport)(msg), elapsedMs };
+      }
+      const hasKeys = parsed.name && parsed.can_count !== void 0 && parsed.sum !== void 0 && parsed.language;
+      const correctSum = parsed.sum === 42;
+      const hasCorrectCount = parsed.can_count === true;
+      let score;
+      if (hasKeys && correctSum && hasCorrectCount) {
+        score = "STRONG";
+      } else if (hasKeys && (correctSum || hasCorrectCount)) {
+        score = "MODERATE";
+      } else if (parsed.sum !== void 0 || parsed.name) {
+        score = "WEAK";
+      } else {
+        score = "FAIL";
+      }
+      return {
+        pass: hasKeys,
+        score,
+        output: JSON.stringify(parsed) + repairNote,
+        elapsedMs
+      };
+    } catch (e) {
+      return { pass: false, score: "ERROR", output: e.message, elapsedMs: 0 };
+    }
+  }
+  async function testInstructionFollowingProvider(providerInfo, model) {
+    const prompt = `You must respond with ONLY a valid JSON object. No markdown, no explanation, no backticks, no extra text.
+
+The JSON object must have exactly these 4 keys:
+- "name" (string): your model name
+- "can_count" (boolean): true
+- "sum" (number): the result of 15 + 27
+- "language" (string): the language you are responding in`;
+    try {
+      const result = await providerChat(providerInfo, model, [
+        { role: "user", content: prompt }
+      ]);
+      const msg = result.content.trim();
+      let parsed = null;
+      let repairNote = "";
+      try {
+        const cleaned = msg.replace(/```json?\s*/gi, "").replace(/```/g, "").trim();
+        parsed = JSON.parse(cleaned);
+      } catch {
+        const cleaned = msg.replace(/```json?\s*/gi, "").replace(/```/g, "").trim();
+        const openBraces = (cleaned.match(/\{/g) || []).length;
+        const closeBraces = (cleaned.match(/\}/g) || []).length;
+        const openBrackets = (cleaned.match(/\[/g) || []).length;
+        const closeBrackets = (cleaned.match(/\]/g) || []).length;
+        if (openBraces > closeBraces || openBrackets > closeBrackets) {
+          const repaired = cleaned + "}".repeat(Math.max(0, openBraces - closeBraces)) + "]".repeat(Math.max(0, openBrackets - closeBrackets));
+          try {
+            parsed = JSON.parse(repaired);
+            repairNote = " (repaired truncated JSON)";
+          } catch {
+          }
+        }
+      }
+      if (!parsed) {
+        return { pass: false, score: "FAIL", output: (0, import_format.sanitizeForReport)(msg), elapsedMs: result.elapsedMs };
+      }
+      const hasKeys = parsed.name && parsed.can_count !== void 0 && parsed.sum !== void 0 && parsed.language;
+      const correctSum = parsed.sum === 42;
+      const hasCorrectCount = parsed.can_count === true;
+      let score;
+      if (hasKeys && correctSum && hasCorrectCount) {
+        score = "STRONG";
+      } else if (hasKeys && (correctSum || hasCorrectCount)) {
+        score = "MODERATE";
+      } else if (parsed.sum !== void 0 || parsed.name) {
+        score = "WEAK";
+      } else {
+        score = "FAIL";
+      }
+      return {
+        pass: hasKeys,
+        score,
+        output: JSON.stringify(parsed) + repairNote,
+        elapsedMs: result.elapsedMs
+      };
+    } catch (e) {
+      return { pass: false, score: "ERROR", output: e.message, elapsedMs: 0 };
+    }
+  }
+  async function testToolSupport(model, family) {
+    const cached = getCachedToolSupport(model);
+    if (cached) {
+      return {
+        level: cached.support,
+        cached: true,
+        evidence: `cached (tested ${cached.testedAt})`,
+        elapsedMs: 0
+      };
+    }
+    const tools = [
+      {
+        type: "function",
+        function: {
+          name: "get_weather",
+          description: "Get the current weather for a location",
+          parameters: {
+            type: "object",
+            properties: {
+              location: { type: "string", description: "City name" },
+              unit: { type: "string", enum: ["celsius", "fahrenheit"] }
+            },
+            required: ["location"]
+          }
+        }
+      }
+    ];
+    const body = {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: "You are a helpful assistant with access to tools. When you need to look up information, use the available tools. Always use tools when asked about real-time data like weather."
+        },
+        { role: "user", content: "What's the weather like in Tokyo right now? Use the get_weather tool to find out." }
+      ],
+      tools,
+      stream: false,
+      options: { num_predict: 1024, temperature: 0.1 }
+    };
+    try {
+      const start = Date.now();
+      const result = await pi.exec("curl", [
+        "-s",
+        "--fail-with-body",
+        "-X",
+        "POST",
+        "--connect-timeout",
+        "30",
+        "--max-time",
+        "120",
+        `${OLLAMA_BASE}/api/chat`,
+        "-H",
+        "Content-Type: application/json",
+        "-d",
+        JSON.stringify(body)
+      ], { timeout: 13e4 });
+      const elapsedMs = Date.now() - start;
+      if (result.code !== 0 || !result.stdout.trim()) {
+        const detail = result.stderr?.trim() || result.stdout?.trim() || "empty response";
+        const level2 = "none";
+        cacheToolSupport(model, level2, family);
+        return { level: level2, cached: false, evidence: `API error: ${(0, import_format.truncate)(detail, 100)}`, elapsedMs };
+      }
+      const parsed = JSON.parse(result.stdout);
+      const toolCalls = parsed?.message?.tool_calls;
+      const content = (parsed?.message?.content || "").trim();
+      if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
+        const fn = toolCalls[0].function || {};
+        const fnName = fn.name || "unknown";
+        let argsStr;
+        try {
+          const args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments || {};
+          argsStr = JSON.stringify(args);
+        } catch {
+          argsStr = String(fn.arguments);
+        }
+        const level2 = "native";
+        cacheToolSupport(model, level2, family);
+        return {
+          level: level2,
+          cached: false,
+          evidence: `API returned tool_calls: ${fnName}(${argsStr})`,
+          elapsedMs
+        };
+      }
+      const reactPatterns = [
+        /^\s*Action:\s*/im,
+        // "Action: get_weather"
+        /^\s*Action Input:\s*/im,
+        // "Action Input: {"location": "Tokyo"}"
+        /^\s*Thought:\s*/im,
+        // "Thought: I need to look up the weather"
+        /Action:\s*\w+/i,
+        // "Action: get_weather" anywhere
+        /Action Input:\s*\{/i
+        // "Action Input: {..." anywhere
+      ];
+      const hasReActPattern = reactPatterns.some((p) => p.test(content));
+      if (hasReActPattern) {
+        const level2 = "react";
+        cacheToolSupport(model, level2, family);
+        return {
+          level: level2,
+          cached: false,
+          evidence: `ReAct format detected in text response`,
+          elapsedMs
+        };
+      }
+      const strippedContent = content.replace(/^\s*```\w*\s*/gm, "").replace(/```\s*$/gm, "").trim();
+      const textToolPatterns = [
+        /\bget_weather\b/i,
+        // Model mentions the tool name
+        /\bfunction_call\b/i,
+        // Explicit function call marker
+        /\btool_call\b/i,
+        // Explicit tool call marker
+        /"name"\s*:\s*"get_weather"/
+        // JSON with tool name
+      ];
+      const hasTextToolSignal = textToolPatterns.some((p) => p.test(strippedContent));
+      const hasJsonToolCall = /"name"\s*:\s*"get_weather"/i.test(strippedContent) && /"arguments"\s*:\s*\{/i.test(strippedContent);
+      if (hasJsonToolCall) {
+        const level2 = "react";
+        cacheToolSupport(model, level2, family);
+        return {
+          level: level2,
+          cached: false,
+          evidence: `JSON tool call in text (no native API tool_calls \u2014 will use react-fallback)`,
+          elapsedMs
+        };
+      }
+      const level = "none";
+      cacheToolSupport(model, level, family);
+      const cleanContent = (0, import_format.truncate)(strippedContent, 150);
+      const evidenceDetail = hasTextToolSignal ? `no structured tool calling (text mentions tool: ${cleanContent})` : `no tool calling patterns (text: ${cleanContent})`;
+      return { level, cached: false, evidence: evidenceDetail, elapsedMs };
+    } catch (e) {
+      const level = "none";
+      cacheToolSupport(model, level, family);
+      return { level, cached: false, evidence: `error: ${e.message}`, elapsedMs: 0 };
+    }
+  }
+  async function getOllamaModels() {
+    try {
+      const result = await pi.exec("curl", ["-s", "--connect-timeout", "10", `${OLLAMA_BASE}/api/tags`], { timeout: 15e3 });
+      if (result.code !== 0 || !result.stdout.trim()) return [];
+      const data = JSON.parse(result.stdout);
+      return (data.models || []).map((m) => m.name).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  function getCurrentModel(ctx) {
+    return ctx.model?.id;
+  }
+  function updateModelsJsonReasoning(model, hasReasoning) {
+    const agentDir = path.join(os.homedir(), ".pi", "agent");
+    const modelsJsonPath = path.join(agentDir, "models.json");
+    if (!fs.existsSync(modelsJsonPath)) {
+      return { updated: false, message: "models.json not found \u2014 skipped" };
+    }
+    try {
+      const raw = fs.readFileSync(modelsJsonPath, "utf-8");
+      const config = JSON.parse(raw);
+      let updated = false;
+      for (const provider of Object.values(config.providers || {})) {
+        const models = provider.models || [];
+        for (const m of models) {
+          if (m.id === model) {
+            const current = m.reasoning;
+            if (current === hasReasoning) {
+              return { updated: false, message: `reasoning already "${hasReasoning}" for ${model} \u2014 no change` };
+            }
+            m.reasoning = hasReasoning;
+            updated = true;
+            break;
+          }
+        }
+        if (updated) break;
+      }
+      if (!updated) {
+        return { updated: false, message: `${model} not found in models.json \u2014 skipped` };
+      }
+      fs.writeFileSync(modelsJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      const action = hasReasoning ? "set reasoning: true" : "set reasoning: false";
+      return { updated: true, message: `\u2705 Updated ${model}: ${action}` };
+    } catch (e) {
+      return { updated: false, message: `Failed to update models.json: ${e.message}` };
+    }
+  }
+  const branding = [
+    `  \u26A1 Pi Model Benchmark v1.0.3`,
+    `  Written by VTSTech`,
+    `  GitHub: https://github.com/VTSTech`,
+    `  Website: www.vts-tech.org`
+  ].join("\n");
+  async function testModelOllama(model) {
+    const lines = [];
+    const totalStart = Date.now();
+    lines.push(branding);
+    lines.push((0, import_format.section)(`MODEL: ${model}`));
+    lines.push((0, import_format.info)("Provider: Ollama (local/remote)"));
+    let modelSize = "unknown";
+    let modelFamily = "unknown";
+    let modelParams = "unknown";
+    let modelQuant = "unknown";
+    let modelModified = "unknown";
+    try {
+      const tagsResult = await pi.exec("curl", ["-s", `${OLLAMA_BASE}/api/tags`], { timeout: 1e4 });
+      if (tagsResult.code === 0 && tagsResult.stdout.trim()) {
+        const tags = JSON.parse(tagsResult.stdout);
+        const entry = (tags.models || []).find((m) => m.name === model);
+        if (entry) {
+          const details = entry.details || {};
+          const sizeBytes = entry.size || 0;
+          const sizeGB = sizeBytes / (1024 * 1024 * 1024);
+          const sizeMB = sizeBytes / (1024 * 1024);
+          modelSize = sizeGB >= 1 ? `${sizeGB.toFixed(1)} GB` : `${sizeMB.toFixed(0)} MB`;
+          modelFamily = details.family || details.families?.[0] || "unknown";
+          modelParams = details.parameter_size || "unknown";
+          modelQuant = details.quantization_level || "unknown";
+          const modDate = entry.modified_at ? new Date(entry.modified_at) : null;
+          modelModified = modDate ? modDate.toLocaleDateString() : "unknown";
+        }
+      }
+    } catch {
+    }
+    const detectedFamily = (0, import_ollama.detectModelFamily)(model);
+    lines.push((0, import_format.info)(`Size: ${modelSize}  |  Params: ${modelParams}  |  Quant: ${modelQuant}`));
+    lines.push((0, import_format.info)(`Family: ${modelFamily}  |  Detected: ${detectedFamily}  |  Modified: ${modelModified}`));
+    lines.push((0, import_format.section)("REASONING TEST"));
+    lines.push((0, import_format.info)("Prompt: A snail climbs 3ft up a wall each day, slides 2ft back each night. Wall is 10ft. How many days?"));
+    lines.push((0, import_format.info)("Testing..."));
+    const reasoning = await testReasoning(model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(reasoning.elapsedMs)}`));
+    if (reasoning.score === "STRONG") {
+      lines.push((0, import_format.ok)(`Answer: ${reasoning.answer} \u2014 Correct with clear reasoning (${reasoning.score})`));
+    } else if (reasoning.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`Answer: ${reasoning.answer} \u2014 Correct but weak reasoning (${reasoning.score})`));
+    } else if (reasoning.score === "WEAK") {
+      lines.push((0, import_format.fail)(`Answer: ${reasoning.answer} \u2014 Reasoned but wrong answer (${reasoning.score})`));
+    } else if (reasoning.score === "FAIL") {
+      lines.push((0, import_format.fail)(`Answer: ${reasoning.answer} \u2014 No reasoning detected (${reasoning.score})`));
+    } else {
+      const errMsg = reasoning.reasoning.includes("<!DOCTYPE") || reasoning.reasoning.includes("<html") ? reasoning.reasoning.split("\n")[0].slice(0, 100) + "..." : (0, import_format.truncate)(reasoning.reasoning, 300);
+      lines.push((0, import_format.fail)(`Error: ${errMsg}`));
+    }
+    lines.push((0, import_format.info)(`Response: ${(0, import_format.sanitizeForReport)(reasoning.reasoning)}`));
+    lines.push((0, import_format.section)("THINKING TEST"));
+    lines.push((0, import_format.info)('Prompt: "Multiply 37 by 43. Explain your reasoning step by step."'));
+    await rateLimitDelay(lines);
+    const thinking = await testThinking(model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(thinking.elapsedMs)}`));
+    if (thinking.supported) {
+      lines.push((0, import_format.ok)(`Thinking/reasoning tokens: SUPPORTED`));
+      lines.push((0, import_format.info)(`Thinking content: ${(0, import_format.sanitizeForReport)(thinking.thinkingContent)}`));
+    } else {
+      lines.push((0, import_format.fail)(`Thinking/reasoning tokens: NOT SUPPORTED`));
+    }
+    lines.push((0, import_format.info)(`Answer output: ${(0, import_format.sanitizeForReport)(thinking.answerContent)}`));
+    lines.push((0, import_format.section)("MODELS.JSON SYNC"));
+    const reasoningUpdate = updateModelsJsonReasoning(model, thinking.supported);
+    lines.push((0, import_format.info)(reasoningUpdate.message));
+    lines.push((0, import_format.section)("TOOL USAGE TEST"));
+    lines.push((0, import_format.info)(`Prompt: "What's the weather in Paris?" (with get_weather tool available)`));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const tools = await testToolUsage(model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(tools.elapsedMs)}`));
+    if (tools.score === "STRONG") {
+      lines.push((0, import_format.ok)(`Tool call: ${tools.toolCall} (${tools.score})`));
+      if (tools.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(tools.response)}`));
+      }
+    } else if (tools.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`Tool call: ${tools.toolCall} (${tools.score})`));
+      if (tools.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(tools.response)}`));
+      }
+    } else if (tools.score === "WEAK") {
+      lines.push((0, import_format.warn)(`Tool call: ${tools.toolCall} (${tools.score}) \u2014 malformed call`));
+      if (tools.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(tools.response)}`));
+      }
+    } else if (tools.score === "FAIL") {
+      const hasResponse = tools.response && tools.response.trim().length > 0;
+      lines.push((0, import_format.fail)(`Tool call: none \u2014 ${hasResponse ? "model responded in text instead" : "model returned empty response"} (${tools.score})`));
+      if (hasResponse) {
+        lines.push((0, import_format.info)(`Text response: ${(0, import_format.sanitizeForReport)(tools.response)}`));
+      } else {
+        lines.push((0, import_format.info)("Text response: (empty)"));
+      }
+    } else {
+      lines.push((0, import_format.fail)(`Error: ${tools.toolCall}`));
+    }
+    lines.push((0, import_format.section)("REACT PARSING TEST"));
+    lines.push((0, import_format.info)(`Prompt: "What's the weather in Tokyo?" (ReAct format, no native tools)`));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const react = await testReactParsing(model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(react.elapsedMs)}`));
+    if (react.score === "STRONG") {
+      lines.push((0, import_format.ok)(`ReAct parsed: ${react.toolCall} (${react.score})`));
+      if (react.thought) {
+        lines.push((0, import_format.info)(`Thought: ${(0, import_format.sanitizeForReport)(react.thought)}`));
+      }
+    } else if (react.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`ReAct parsed: ${react.toolCall} (${react.score})`));
+      if (react.thought) {
+        lines.push((0, import_format.info)(`Thought: ${(0, import_format.sanitizeForReport)(react.thought)}`));
+      }
+    } else if (react.score === "WEAK") {
+      lines.push((0, import_format.warn)(`ReAct parsed: ${react.toolCall} (${react.score}) \u2014 wrong tool or malformed args`));
+      if (react.thought) {
+        lines.push((0, import_format.info)(`Thought: ${(0, import_format.sanitizeForReport)(react.thought)}`));
+      }
+    } else if (react.score === "FAIL") {
+      lines.push((0, import_format.fail)(`ReAct parsing: ${react.toolCall} (${react.score})`));
+      if (react.response) {
+        lines.push((0, import_format.info)(`Response: ${(0, import_format.sanitizeForReport)(react.response)}`));
+      }
+    } else {
+      lines.push((0, import_format.fail)(`Error: ${react.toolCall}`));
+    }
+    lines.push((0, import_format.section)("INSTRUCTION FOLLOWING TEST"));
+    lines.push((0, import_format.info)("Prompt: Respond with ONLY a JSON object with keys: name, can_count, sum (15+27), language"));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const instructions = await testInstructionFollowing(model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(instructions.elapsedMs)}`));
+    if (instructions.score === "STRONG") {
+      lines.push((0, import_format.ok)(`JSON output valid with correct values (${instructions.score})`));
+    } else if (instructions.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`JSON output valid but some values incorrect (${instructions.score})`));
+    } else if (instructions.score === "WEAK") {
+      lines.push((0, import_format.warn)(`Partial JSON compliance (${instructions.score})`));
+    } else {
+      lines.push((0, import_format.fail)(`Failed to produce valid JSON (${instructions.score})`));
+    }
+    lines.push((0, import_format.info)(`Output: ${(0, import_format.sanitizeForReport)(instructions.output)}`));
+    lines.push((0, import_format.section)("TOOL SUPPORT DETECTION"));
+    lines.push((0, import_format.info)("Probing model for tool calling capability (native / ReAct / none)"));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const toolSupport = await testToolSupport(model, detectedFamily);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(toolSupport.elapsedMs)}`));
+    const supportLabel = (level) => {
+      switch (level) {
+        case "native":
+          return "NATIVE (structured API tool_calls)";
+        case "react":
+          return "REACT (Action:/Action Input: text format)";
+        case "none":
+          return "NONE (no tool support detected)";
+        default:
+          return "UNKNOWN";
+      }
+    };
+    if (toolSupport.cached) {
+      lines.push((0, import_format.info)(`Result: ${supportLabel(toolSupport.level)} \u2014 from cache`));
+    } else {
+      if (toolSupport.level === "native") {
+        lines.push((0, import_format.ok)(`Tool support: ${supportLabel(toolSupport.level)}`));
+      } else if (toolSupport.level === "react") {
+        lines.push((0, import_format.ok)(`Tool support: ${supportLabel(toolSupport.level)}`));
+      } else {
+        lines.push((0, import_format.warn)(`Tool support: ${supportLabel(toolSupport.level)}`));
+      }
+    }
+    lines.push((0, import_format.info)(`Evidence: ${toolSupport.evidence}`));
+    lines.push((0, import_format.info)(`Cache: ${TOOL_SUPPORT_CACHE_PATH}`));
+    lines.push((0, import_format.section)("SUMMARY"));
+    const totalMs = Date.now() - totalStart;
+    const tests = [
+      { name: "Reasoning", pass: reasoning.score === "STRONG" || reasoning.score === "MODERATE", score: reasoning.score },
+      { name: "Thinking", pass: thinking.supported, score: thinking.supported ? "YES" : "NO" },
+      { name: "Tool Usage", pass: tools.pass, score: tools.score },
+      { name: "ReAct Parse", pass: react.pass, score: react.score },
+      { name: "Instructions", pass: instructions.pass, score: instructions.score },
+      { name: "Tool Support", pass: toolSupport.level === "native" || toolSupport.level === "react", score: toolSupport.level.toUpperCase() }
+    ];
+    const passed = tests.filter((t) => t.pass).length;
+    const total = tests.length;
+    for (const t of tests) {
+      lines.push(t.pass ? (0, import_format.ok)(`${t.name}: ${t.score}`) : (0, import_format.fail)(`${t.name}: ${t.score}`));
+    }
+    lines.push((0, import_format.info)(`Total time: ${(0, import_format.msHuman)(totalMs)}`));
+    lines.push((0, import_format.info)(`Score: ${passed}/${total} tests passed`));
+    lines.push((0, import_format.section)("RECOMMENDATION"));
+    if (passed === 6) {
+      lines.push((0, import_format.ok)(`${model} is a STRONG model \u2014 full capability`));
+    } else if (passed >= 5) {
+      lines.push((0, import_format.ok)(`${model} is a GOOD model \u2014 most capabilities work`));
+    } else if (passed >= 4) {
+      lines.push((0, import_format.warn)(`${model} is USABLE \u2014 some capabilities are limited`));
+    } else {
+      lines.push((0, import_format.fail)(`${model} is WEAK \u2014 limited capabilities for agent use`));
+    }
+    return lines.join("\n");
+  }
+  async function testModelProvider(providerInfo, model) {
+    const lines = [];
+    const totalStart = Date.now();
+    lines.push(branding);
+    lines.push((0, import_format.section)(`MODEL: ${model}`));
+    lines.push((0, import_format.info)(`Provider: ${providerInfo.name} (built-in)`));
+    lines.push((0, import_format.info)(`API: ${providerInfo.apiMode || "openai-completions"}`));
+    lines.push((0, import_format.info)(`Base URL: ${providerInfo.baseUrl || "unknown"}`));
+    if (providerInfo.apiKey) {
+      lines.push((0, import_format.info)(`API Key: ****${providerInfo.apiKey.slice(-4)}`));
+    } else {
+      lines.push((0, import_format.warn)(`API Key: NOT SET (${providerInfo.envKey || "env var not found"})`));
+    }
+    lines.push((0, import_format.section)("CONNECTIVITY TEST"));
+    lines.push((0, import_format.info)("Sending minimal request to verify API reachability and key validity..."));
+    const connectivity = await testConnectivity(providerInfo, model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(connectivity.elapsedMs)}`));
+    if (connectivity.pass) {
+      lines.push((0, import_format.ok)(`API reachable and authenticated`));
+    } else {
+      if (!connectivity.reachable) {
+        lines.push((0, import_format.fail)(`API not reachable: ${connectivity.error || "unknown error"}`));
+      } else if (!connectivity.authValid) {
+        lines.push((0, import_format.fail)(`Authentication failed: ${connectivity.error || "invalid or missing API key"}`));
+      } else {
+        lines.push((0, import_format.fail)(`Connectivity error: ${connectivity.error || "unknown"}`));
+      }
+      lines.push((0, import_format.warn)("Skipping remaining tests \u2014 fix connectivity first"));
+      lines.push((0, import_format.info)("Tip: Check your API key is set correctly and the provider endpoint is accessible"));
+      return lines.join("\n");
+    }
+    lines.push((0, import_format.section)("REASONING TEST"));
+    lines.push((0, import_format.info)("Prompt: A snail climbs 3ft up a wall each day, slides 2ft back each night. Wall is 10ft. How many days?"));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const reasoning = await testReasoningProvider(providerInfo, model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(reasoning.elapsedMs)}`));
+    if (reasoning.score === "STRONG") {
+      lines.push((0, import_format.ok)(`Answer: ${reasoning.answer} \u2014 Correct with clear reasoning (${reasoning.score})`));
+    } else if (reasoning.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`Answer: ${reasoning.answer} \u2014 Correct but weak reasoning (${reasoning.score})`));
+    } else if (reasoning.score === "WEAK") {
+      lines.push((0, import_format.fail)(`Answer: ${reasoning.answer} \u2014 Reasoned but wrong answer (${reasoning.score})`));
+    } else if (reasoning.score === "FAIL") {
+      lines.push((0, import_format.fail)(`Answer: ${reasoning.answer} \u2014 No reasoning detected (${reasoning.score})`));
+    } else {
+      const errMsg = reasoning.reasoning.includes("<!DOCTYPE") || reasoning.reasoning.includes("<html") ? reasoning.reasoning.split("\n")[0].slice(0, 100) + "..." : (0, import_format.truncate)(reasoning.reasoning, 300);
+      lines.push((0, import_format.fail)(`Error: ${errMsg}`));
+    }
+    lines.push((0, import_format.info)(`Response: ${(0, import_format.sanitizeForReport)(reasoning.reasoning)}`));
+    lines.push((0, import_format.section)("INSTRUCTION FOLLOWING TEST"));
+    lines.push((0, import_format.info)("Prompt: Respond with ONLY a JSON object with keys: name, can_count, sum (15+27), language"));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const instructions = await testInstructionFollowingProvider(providerInfo, model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(instructions.elapsedMs)}`));
+    if (instructions.score === "STRONG") {
+      lines.push((0, import_format.ok)(`JSON output valid with correct values (${instructions.score})`));
+    } else if (instructions.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`JSON output valid but some values incorrect (${instructions.score})`));
+    } else if (instructions.score === "WEAK") {
+      lines.push((0, import_format.warn)(`Partial JSON compliance (${instructions.score})`));
+    } else {
+      lines.push((0, import_format.fail)(`Failed to produce valid JSON (${instructions.score})`));
+    }
+    lines.push((0, import_format.info)(`Output: ${(0, import_format.sanitizeForReport)(instructions.output)}`));
+    lines.push((0, import_format.section)("TOOL USAGE TEST"));
+    lines.push((0, import_format.info)(`Prompt: "What's the weather in Paris?" (with get_weather tool available)`));
+    lines.push((0, import_format.info)("Testing..."));
+    await rateLimitDelay(lines);
+    const toolTest = await testToolUsageProvider(providerInfo, model);
+    lines.push((0, import_format.info)(`Time: ${(0, import_format.msHuman)(toolTest.elapsedMs)}`));
+    if (toolTest.score === "STRONG") {
+      lines.push((0, import_format.ok)(`Tool call: ${toolTest.toolCall} (${toolTest.score})`));
+      if (toolTest.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(toolTest.response)}`));
+      }
+    } else if (toolTest.score === "MODERATE") {
+      lines.push((0, import_format.ok)(`Tool call: ${toolTest.toolCall} (${toolTest.score})`));
+      if (toolTest.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(toolTest.response)}`));
+      }
+    } else if (toolTest.score === "WEAK") {
+      lines.push((0, import_format.warn)(`Tool call: ${toolTest.toolCall} (${toolTest.score}) \u2014 malformed call`));
+      if (toolTest.response) {
+        lines.push((0, import_format.info)(`Raw response: ${(0, import_format.sanitizeForReport)(toolTest.response)}`));
+      }
+    } else if (toolTest.score === "FAIL") {
+      const hasResponse = toolTest.response && toolTest.response.trim().length > 0;
+      lines.push((0, import_format.fail)(`Tool call: none \u2014 ${hasResponse ? "model responded in text instead" : "model returned empty response"} (${toolTest.score})`));
+      if (hasResponse) {
+        lines.push((0, import_format.info)(`Text response: ${(0, import_format.sanitizeForReport)(toolTest.response)}`));
+      } else {
+        lines.push((0, import_format.info)("Text response: (empty)"));
+      }
+    } else {
+      lines.push((0, import_format.fail)(`Error: ${toolTest.toolCall}`));
+    }
+    lines.push((0, import_format.section)("SKIPPED TESTS (OLLAMA-ONLY)"));
+    lines.push((0, import_format.warn)("Thinking test \u2014 Ollama-specific think:true option and message.thinking field"));
+    lines.push((0, import_format.warn)("ReAct parsing test \u2014 only relevant for Ollama models without native tool calling"));
+    lines.push((0, import_format.warn)("Tool support detection \u2014 Ollama-specific tool support cache"));
+    lines.push((0, import_format.warn)("Model metadata \u2014 Ollama-specific /api/tags endpoint"));
+    lines.push((0, import_format.section)("SUMMARY"));
+    const totalMs = Date.now() - totalStart;
+    const tests = [
+      { name: "Connectivity", pass: connectivity.pass, score: connectivity.pass ? "OK" : "FAIL" },
+      { name: "Reasoning", pass: reasoning.score === "STRONG" || reasoning.score === "MODERATE", score: reasoning.score },
+      { name: "Instructions", pass: instructions.pass, score: instructions.score },
+      { name: "Tool Usage", pass: toolTest.pass, score: toolTest.score }
+    ];
+    const passed = tests.filter((t) => t.pass).length;
+    const total = tests.length;
+    for (const t of tests) {
+      lines.push(t.pass ? (0, import_format.ok)(`${t.name}: ${t.score}`) : (0, import_format.fail)(`${t.name}: ${t.score}`));
+    }
+    lines.push((0, import_format.info)(`Total time: ${(0, import_format.msHuman)(totalMs)}`));
+    lines.push((0, import_format.info)(`Score: ${passed}/${total} tests passed`));
+    lines.push((0, import_format.section)("RECOMMENDATION"));
+    if (passed === 4) {
+      lines.push((0, import_format.ok)(`${model} is a STRONG model via ${providerInfo.name} \u2014 full capability`));
+    } else if (passed >= 3) {
+      lines.push((0, import_format.ok)(`${model} is a GOOD model via ${providerInfo.name} \u2014 most capabilities work`));
+    } else if (passed >= 2) {
+      lines.push((0, import_format.warn)(`${model} is USABLE via ${providerInfo.name} \u2014 some capabilities are limited`));
+    } else {
+      lines.push((0, import_format.fail)(`${model} is WEAK via ${providerInfo.name} \u2014 limited capabilities for agent use`));
+    }
+    return lines.join("\n");
+  }
+  async function testModel(model, ctx) {
+    const providerInfo = ctx ? detectProvider(ctx) : { kind: "ollama", name: "ollama" };
+    if (providerInfo.kind === "ollama") {
+      return testModelOllama(model);
+    } else if (providerInfo.kind === "builtin") {
+      return testModelProvider(providerInfo, model);
+    } else {
+      return testModelOllama(model);
+    }
+  }
+  pi.registerCommand("model-test", {
+    description: "Test a model for reasoning, thinking, tool usage, ReAct parsing, instruction following, and tool support level. Supports both Ollama and cloud providers. Use: /model-test [model] or /model-test --all",
+    getArgumentCompletions: async (prefix) => {
+      try {
+        const models = await getOllamaModels();
+        return models.map((m) => ({ label: m, description: `Test ${m}` })).filter((m) => m.label.startsWith(prefix));
+      } catch {
+        return [];
+      }
+    },
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("model-test requires TUI mode", "error");
+        return;
+      }
+      const arg = args.trim();
+      if (arg === "--all") {
+        const providerInfo = detectProvider(ctx);
+        if (providerInfo.kind !== "ollama") {
+          ctx.ui.notify(`--all is only supported for Ollama models. Current provider: ${providerInfo.name} (${providerInfo.kind})`, "error");
+          return;
+        }
+        ctx.ui.notify("Testing all models \u2014 this will take a while...", "info");
+        let models;
+        try {
+          models = await getOllamaModels();
+        } catch {
+          ctx.ui.notify("Could not list Ollama models", "error");
+          return;
+        }
+        if (models.length === 0) {
+          ctx.ui.notify("No models found in Ollama", "error");
+          return;
+        }
+        for (const model2 of models) {
+          ctx.ui.notify(`Testing ${model2}...`, "info");
+          try {
+            const report = await testModel(model2, ctx);
+            pi.sendMessage({
+              customType: "model-test-report",
+              content: report,
+              display: { type: "content", content: report },
+              details: { model: model2, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          } catch (e) {
+            ctx.ui.notify(`Failed to test ${model2}: ${e.message}`, "error");
+          }
+        }
+        ctx.ui.notify(`Done testing ${models.length} models`, "info");
+        return;
+      }
+      const model = arg || getCurrentModel(ctx);
+      if (!model) {
+        ctx.ui.notify("No model specified and no model currently selected", "error");
+        return;
+      }
+      ctx.ui.notify(`Testing ${model}...`, "info");
+      try {
+        const report = await testModel(model, ctx);
+        pi.sendMessage({
+          customType: "model-test-report",
+          content: report,
+          display: { type: "content", content: report },
+          details: { model, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        });
+      } catch (e) {
+        ctx.ui.notify(`Model test failed: ${e.message}`, "error");
+      }
+    }
+  });
+  pi.registerTool({
+    name: "model_test",
+    label: "Model Test",
+    description: "Test a model for reasoning ability, thinking/reasoning token support, tool usage capability, instruction following, and tool support level. Supports both Ollama and built-in cloud providers (OpenRouter, Anthropic, Google, OpenAI, etc.). Returns a detailed report with scores.",
+    promptSnippet: "model_test - test a model's capabilities",
+    promptGuidelines: [
+      "When the user asks to test or evaluate a model, call model_test with the model name."
+    ],
+    parameters: {
+      type: "object",
+      properties: {
+        model: { type: "string", description: "Model name to test (e.g. qwen3:0.6b, anthropic/claude-3.5-sonnet). If omitted, tests the current model." }
+      }
+    },
+    execute: async (_toolCallId, _params, _signal, _onUpdate, ctx) => {
+      const model = _params?.model || getCurrentModel(ctx);
+      if (!model) {
+        return {
+          content: [{ type: "text", text: "No model currently selected to test." }],
+          isError: true
+        };
+      }
+      try {
+        const report = await testModel(model, ctx);
+        return {
+          content: [{ type: "text", text: report }],
+          isError: false
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Model test failed: ${e.message}` }],
+          isError: true
+        };
+      }
+    }
+  });
+}