@vtstech/pi-model-test 1.1.0 → 1.1.1

package/README.md

@@ -43,12 +43,13 @@ pi install "npm:@vtstech/pi-model-test"
 ## Features
 
 - Auto-detects Ollama vs cloud provider (OpenRouter, Anthropic, Google, OpenAI, Groq, DeepSeek, Mistral, xAI, Together, Fireworks, Cohere)
-- Automatic remote Ollama URL resolution
+- Uses native `fetch()` for all HTTP communication (no shell subprocess or curl dependency)
+- Automatic remote Ollama URL resolution (reads from `models.json` on every call — picks up config changes immediately)
 - Timeout resilience with auto-retry on empty responses
 - Rate limit delay between tests (configurable)
 - Thinking model fallback (retries with `think: true`)
 - Tool support cache (`~/.pi/agent/cache/tool_support.json`)
-- JSON repair for truncated output
+- JSON repair for truncated output (stack-based nesting-aware parser)
 - Tab-completion for model names
 
 ## Links

package/model-test.js

@@ -23,8 +23,6 @@ var CONFIG = {
   // Single retry for transient failures
   RETRY_DELAY_MS: 1e4,
   // 10 seconds between retries
-  EXEC_BUFFER_MS: 8e3,
-  // Extra buffer for exec timeout over curl timeout
   // Model generation settings
   NUM_PREDICT: 1024,
   // Max tokens in response
@@ -35,17 +33,11 @@ var CONFIG = {
   // Minimum chars to consider thinking tokens valid
   TOOL_TEST_TIMEOUT_MS: 999999,
   // Effectively unlimited for slow tool usage tests
-  TOOL_TEST_MAX_TIME_S: 999999,
-  // Max curl time for tool tests (effectively unlimited)
   TOOL_SUPPORT_TIMEOUT_MS: 999999,
   // Effectively unlimited for tool support detection
-  TOOL_SUPPORT_MAX_TIME_S: 999999,
-  // Max curl time for tool support detection
   // Metadata retrieval
   TAGS_TIMEOUT_MS: 15e3,
   // 15 seconds for /api/tags
-  TAGS_CONNECT_TIMEOUT_S: 30,
-  // 30 seconds connection timeout for tags
   MODEL_INFO_TIMEOUT_MS: 3e4,
   // 30 seconds for model info lookup
   // Provider API settings
@@ -95,53 +87,120 @@ function cacheToolSupport(model, support, family) {
   writeToolSupportCache(cache);
 }
 function model_test_temp_default(pi) {
-  const OLLAMA_BASE = getOllamaBaseUrl();
+  function ollamaBase() {
+    return getOllamaBaseUrl();
+  }
   async function rateLimitDelay(lines) {
     if (CONFIG.TEST_DELAY_MS > 0) {
       lines.push(info(`Waiting ${msHuman(CONFIG.TEST_DELAY_MS)} to avoid rate limiting...`));
       await new Promise((r) => setTimeout(r, CONFIG.TEST_DELAY_MS));
     }
   }
+  function scoreReasoning(msg) {
+    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;
+    if (isCorrect && hasReasoning) return { score: "STRONG", pass: true };
+    if (isCorrect) return { score: "MODERATE", pass: true };
+    if (hasReasoning) return { score: "WEAK", pass: false };
+    return { score: "FAIL", pass: false };
+  }
+  function scoreNativeToolCall(fnName, args) {
+    const hasCorrectTool = fnName === "get_weather";
+    const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
+    const unitValid = args.unit === void 0 || typeof args.unit === "string" && ["celsius", "fahrenheit"].includes(args.unit.toLowerCase());
+    if (hasCorrectTool && hasLocation && unitValid) return { score: "STRONG", pass: true };
+    if (hasCorrectTool && hasLocation) return { score: "MODERATE", pass: true };
+    return { score: "WEAK", pass: false };
+  }
+  function scoreTextToolCall(fnName, args) {
+    const isWeatherTool = fnName === "get_weather";
+    const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
+    if (isWeatherTool && hasLocation) return { score: "STRONG", pass: true };
+    if (isWeatherTool) return { score: "MODERATE", pass: true };
+    return { score: "WEAK", pass: false };
+  }
+  function parseTextToolCall(content) {
+    const firstBrace = content.indexOf("{");
+    if (firstBrace === -1) return null;
+    const lastBrace = content.lastIndexOf("}");
+    if (lastBrace <= firstBrace) return null;
+    const jsonCandidate = content.slice(firstBrace, lastBrace + 1);
+    let textToolParsed = null;
+    try {
+      textToolParsed = JSON.parse(jsonCandidate);
+    } catch {
+      return null;
+    }
+    if (!textToolParsed || typeof textToolParsed.name !== "string") return null;
+    const rawArgs = textToolParsed.arguments || { ...textToolParsed };
+    const { name: _, ...fnArgs } = rawArgs;
+    return { fnName: textToolParsed.name, args: fnArgs };
+  }
   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 } };
+    const url = `${ollamaBase()}/api/chat`;
     for (let attempt = 0; attempt <= retries; attempt++) {
       const start = Date.now();
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
       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 res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
         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 (!res.ok) {
+          const errorText = await res.text().catch(() => "unknown error");
+          throw new Error(`Ollama API returned ${res.status}: ${truncate(errorText, 200)}`);
         }
-        if (!result.stdout.trim()) {
+        const text = await res.text();
+        if (!text.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);
+        const parsed = JSON.parse(text);
         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"))) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (e instanceof Error && e.name === "AbortError") {
+          if (attempt < retries) {
+            await new Promise((r) => setTimeout(r, CONFIG.RETRY_DELAY_MS));
+            continue;
+          }
+          throw new Error(`Ollama API timed out after ${msHuman(timeoutMs)}`);
+        }
+        if (attempt < retries && (msg.includes("Empty response") || msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET") || msg.includes("fetch failed"))) {
           await new Promise((r) => setTimeout(r, CONFIG.RETRY_DELAY_MS));
           continue;
         }
         throw e;
+      } finally {
+        clearTimeout(timeoutId);
       }
     }
     throw new Error("Unreachable");
@@ -280,41 +339,7 @@ function model_test_temp_default(pi) {
       }
       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 { score, pass } = scoreReasoning(effectiveMsg);
       const displayMsg = msg.trim().length > 0 ? effectiveMsg : `[thinking tokens] ${effectiveMsg}`;
       return { pass, score, reasoning: displayMsg, answer, elapsedMs };
     } catch (e) {
@@ -333,41 +358,7 @@ function model_test_temp_default(pi) {
       }
       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;
-      }
+      const { score, pass } = scoreReasoning(msg);
       return { pass, score, reasoning: msg, answer, elapsedMs: result.elapsedMs };
     } catch (e) {
       return { pass: false, score: "ERROR", reasoning: e.message, answer: "?", elapsedMs: 0 };
@@ -423,29 +414,24 @@ function model_test_temp_default(pi) {
       options: { num_predict: CONFIG.NUM_PREDICT, temperature: CONFIG.TEMPERATURE }
     };
     try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), CONFIG.TOOL_TEST_TIMEOUT_MS);
       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 res = await fetch(`${ollamaBase()}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
       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 };
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => "unknown error");
+        return { pass: false, score: "ERROR", hasToolCalls: false, toolCall: `fetch error: ${res.status}`, response: "", elapsedMs };
       }
-      if (!result.stdout.trim()) throw new Error("Empty response from Ollama");
-      const parsed = JSON.parse(result.stdout);
+      const text = await res.text();
+      if (!text.trim()) throw new Error("Empty response from Ollama");
+      const parsed = JSON.parse(text);
       const toolCalls = parsed?.message?.tool_calls;
       const content = parsed?.message?.content || "";
       if (toolCalls && toolCalls.length > 0) {
@@ -464,20 +450,7 @@ function model_test_temp_default(pi) {
             elapsedMs
           };
         }
-        const hasCorrectTool = fn.name === "get_weather";
-        const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
-        const unitValid = args.unit === void 0 || typeof args.unit === "string" && ["celsius", "fahrenheit"].includes(args.unit.toLowerCase());
-        let score;
-        if (hasCorrectTool && hasLocation && unitValid) {
-          score = "STRONG";
-        } else if (hasCorrectTool && hasLocation) {
-          score = "MODERATE";
-        } else if (hasCorrectTool) {
-          score = "WEAK";
-        } else {
-          score = "WEAK";
-        }
-        const pass = score !== "WEAK";
+        const { score, pass } = scoreNativeToolCall(fn.name || "", args);
         return {
           pass,
           score,
@@ -487,38 +460,14 @@ function model_test_temp_default(pi) {
           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";
-        }
-        const pass = score !== "WEAK";
+      const textParsed = parseTextToolCall(content);
+      if (textParsed) {
+        const { score, pass } = scoreTextToolCall(textParsed.fnName, textParsed.args);
         return {
           pass,
           score,
           hasToolCalls: true,
-          toolCall: `${fnName}(${JSON.stringify(fnArgs)})`,
+          toolCall: `${textParsed.fnName}(${JSON.stringify(textParsed.args)})`,
           response: content,
           elapsedMs
         };
@@ -580,20 +529,7 @@ function model_test_temp_default(pi) {
             elapsedMs: result.elapsedMs
           };
         }
-        const hasCorrectTool = fn.name === "get_weather";
-        const hasLocation = typeof args.location === "string" && args.location.toLowerCase().includes("paris");
-        const unitValid = args.unit === void 0 || typeof args.unit === "string" && ["celsius", "fahrenheit"].includes(args.unit.toLowerCase());
-        let score;
-        if (hasCorrectTool && hasLocation && unitValid) {
-          score = "STRONG";
-        } else if (hasCorrectTool && hasLocation) {
-          score = "MODERATE";
-        } else if (hasCorrectTool) {
-          score = "WEAK";
-        } else {
-          score = "WEAK";
-        }
-        const pass = score !== "WEAK";
+        const { score, pass } = scoreNativeToolCall(fn.name || "", args);
         return {
           pass,
           score,
@@ -603,38 +539,14 @@ function model_test_temp_default(pi) {
           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";
-        }
-        const pass = score !== "WEAK";
+      const textParsed = parseTextToolCall(content);
+      if (textParsed) {
+        const { score, pass } = scoreTextToolCall(textParsed.fnName, textParsed.args);
         return {
           pass,
           score,
           hasToolCalls: true,
-          toolCall: `${fnName}(${JSON.stringify(fnArgs)})`,
+          toolCall: `${textParsed.fnName}(${JSON.stringify(textParsed.args)})`,
           response: content,
           elapsedMs: result.elapsedMs
         };
@@ -671,29 +583,24 @@ function model_test_temp_default(pi) {
       options: { num_predict: CONFIG.NUM_PREDICT, temperature: CONFIG.TEMPERATURE }
     };
     try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), CONFIG.TOOL_TEST_TIMEOUT_MS);
       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 res = await fetch(`${ollamaBase()}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
       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 };
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => "unknown error");
+        return { pass: false, score: "ERROR", toolCall: `fetch error: ${res.status}`, thought: "", response: "", elapsedMs };
       }
-      if (!result.stdout.trim()) throw new Error("Empty response from Ollama");
-      const parsed = JSON.parse(result.stdout);
+      const text = await res.text();
+      if (!text.trim()) throw new Error("Empty response from Ollama");
+      const parsed = JSON.parse(text);
       const content = (parsed?.message?.content || "").trim();
       if (!content) {
         return { pass: false, score: "FAIL", toolCall: "empty response", thought: "", response: "", elapsedMs };
@@ -702,20 +609,20 @@ function model_test_temp_default(pi) {
       const sharedParser = pi._reactParser;
       if (sharedParser?.ALL_DIALECT_PATTERNS) {
         for (const dp of sharedParser.ALL_DIALECT_PATTERNS) {
-          const result2 = sharedParser.parseReactWithPatterns(content, dp, true);
-          if (result2) {
-            let toolName = result2.name;
+          const result = sharedParser.parseReactWithPatterns(content, dp, true);
+          if (result) {
+            let toolName = result.name;
             let argsStr;
-            const rawArgs = result2.args ? JSON.stringify(result2.args) : "";
+            const rawArgs = result.args ? JSON.stringify(result.args) : "";
             if (rawArgs && rawArgs !== "{}") {
               argsStr = rawArgs;
-            } else if (result2.raw) {
-              const jsonStart = result2.raw.indexOf("{");
+            } else if (result.raw) {
+              const jsonStart = result.raw.indexOf("{");
               if (jsonStart !== -1) {
                 let depth = 0, jsonEnd = -1;
-                for (let i = jsonStart; i < result2.raw.length; i++) {
-                  if (result2.raw[i] === "{") depth++;
-                  else if (result2.raw[i] === "}") {
+                for (let i = jsonStart; i < result.raw.length; i++) {
+                  if (result.raw[i] === "{") depth++;
+                  else if (result.raw[i] === "}") {
                     depth--;
                     if (depth === 0) {
                       jsonEnd = i;
@@ -723,14 +630,14 @@ function model_test_temp_default(pi) {
                     }
                   }
                 }
-                argsStr = jsonEnd !== -1 ? result2.raw.slice(jsonStart, jsonEnd + 1) : "";
+                argsStr = jsonEnd !== -1 ? result.raw.slice(jsonStart, jsonEnd + 1) : "";
               } else {
                 argsStr = "";
               }
             } else {
               argsStr = "";
             }
-            parsedResult = { name: toolName, args: argsStr, thought: result2.thought || "", dialect: result2.dialect };
+            parsedResult = { name: toolName, args: argsStr, thought: result.thought || "", dialect: result.dialect };
             break;
           }
         }
@@ -1051,29 +958,29 @@ The JSON object must have exactly these 4 keys:
     };
     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 controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 13e4);
+      const res = await fetch(`${ollamaBase()}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
       const elapsedMs = Date.now() - start;
-      if (result.code !== 0 || !result.stdout.trim()) {
-        const detail = result.stderr?.trim() || result.stdout?.trim() || "empty response";
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        const detail = await res.text().catch(() => "unknown error");
+        const level2 = "none";
+        cacheToolSupport(model, level2, family);
+        return { level: level2, cached: false, evidence: `API error ${res.status}: ${truncate(detail, 100)}`, elapsedMs };
+      }
+      const text = await res.text();
+      if (!text.trim()) {
         const level2 = "none";
         cacheToolSupport(model, level2, family);
-        return { level: level2, cached: false, evidence: `API error: ${truncate(detail, 100)}`, elapsedMs };
+        return { level: level2, cached: false, evidence: "empty response from Ollama", elapsedMs };
       }
-      const parsed = JSON.parse(result.stdout);
+      const parsed = JSON.parse(text);
       const toolCalls = parsed?.message?.tool_calls;
       const content = (parsed?.message?.content || "").trim();
       if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
@@ -1169,9 +1076,9 @@ The JSON object must have exactly these 4 keys:
   }
   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);
+      const res = await fetch(`${ollamaBase()}/api/tags`, { signal: AbortSignal.timeout(15e3) });
+      if (!res.ok) return [];
+      const data = await res.json();
       return (data.models || []).map((m) => m.name).filter(Boolean);
     } catch {
       return [];
@@ -1231,7 +1138,7 @@ The JSON object must have exactly these 4 keys:
       }
     }
     lines.push(info(`API: ${apiMode}`));
-    const nativeContext = await fetchModelContextLength(OLLAMA_BASE, model);
+    const nativeContext = await fetchModelContextLength(ollamaBase(), model);
     if (nativeContext !== void 0) {
       const ctxStr = nativeContext >= 1e3 ? `${(nativeContext / 1e3).toFixed(1)}k` : String(nativeContext);
       lines.push(info(`Context: ${ctxStr} tokens (native max)`));
@@ -1242,9 +1149,9 @@ The JSON object must have exactly these 4 keys:
     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 tagsRes = await fetch(`${ollamaBase()}/api/tags`, { signal: AbortSignal.timeout(1e4) });
+      if (tagsRes.ok) {
+        const tags = await tagsRes.json();
         const entry = (tags.models || []).find((m) => m.name === model);
         if (entry) {
           const details = entry.details || {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtstech/pi-model-test",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Model benchmark/testing extension for Pi Coding Agent",
   "main": "model-test.js",
   "keywords": ["pi-extensions"],
@@ -14,7 +14,7 @@
     "url": "https://github.com/VTSTech/pi-coding-agent"
   },
   "dependencies": {
-    "@vtstech/pi-shared": "1.1.0"
+    "@vtstech/pi-shared": "1.1.1"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.66"