create-walle 0.9.25 → 0.9.26

package/template/wall-e/llm/mlx.plugin.json

@@ -11,7 +11,7 @@
   "modelPrefixes": [],
   "capabilities": {
     "chat": true,
-    "tools": false,
+    "tools": true,
     "vision": false,
     "thinking": false,
     "streaming": true,

package/template/wall-e/llm/ollama.js

@@ -6,6 +6,21 @@ function isGemma4Model(model) {
   return /^gemma4:/i.test(String(model || ''));
 }
 
+function isFastGemma4Model(model) {
+  return /^gemma4:e4b(?:$|[-:])/i.test(String(model || ''));
+}
+
+function envPositiveInt(name, fallback) {
+  const raw = process.env[name];
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+
+function defaultNumCtxForModel(model) {
+  if (isGemma4Model(model)) return envPositiveInt('WALLE_OLLAMA_GEMMA_NUM_CTX', 16384);
+  return null;
+}
+
 function isReasoningCapableOllamaModel(model) {
   return /^(gemma4:|gpt-oss\b|deepseek-r1\b|qwen3\b|qwq\b|phi-?4.*reason)/i.test(String(model || ''));
 }
@@ -40,26 +55,201 @@ function buildOllamaOptions({ model, maxTokens, temperature, options } = {}) {
   if (maxTokens != null) out.num_predict = maxTokens;
   if (temperature != null) out.temperature = temperature;
   if (isGemma4Model(model) && out.num_ctx == null) {
-    out.num_ctx = 16384;
+    out.num_ctx = defaultNumCtxForModel(model);
   }
   return Object.keys(out).length ? out : undefined;
 }
 
+function compactError(err) {
+  const msg = String(err?.message || err || '').replace(/\s+/g, ' ').trim();
+  if (/aborted|timeout/i.test(msg)) return 'request_timeout';
+  if (/ECONNREFUSED|fetch failed|connection/i.test(msg)) return 'daemon_unreachable';
+  return msg.slice(0, 160) || 'unknown_error';
+}
+
+function durationNsToMs(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.round(n / 1e6) : null;
+}
+
+function usageFromOpenAICompat(raw, latencyMs) {
+  const base = raw?.usage
+    ? {
+        input: raw.usage.prompt_tokens ?? raw.usage.prompt_eval_count ?? 0,
+        output: raw.usage.completion_tokens ?? raw.usage.eval_count ?? 0,
+      }
+    : { input: 0, output: 0 };
+  const evalDurationNs = raw?.eval_duration || raw?.usage?.eval_duration || 0;
+  const evalCount = raw?.eval_count || raw?.usage?.eval_count || base.output || 0;
+  const promptEvalDurationNs = raw?.prompt_eval_duration || raw?.usage?.prompt_eval_duration || 0;
+  const promptEvalCount = raw?.prompt_eval_count || raw?.usage?.prompt_eval_count || base.input || 0;
+  const genTokPerSec = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : null;
+  const prefillTokPerSec = promptEvalDurationNs > 0 ? promptEvalCount / (promptEvalDurationNs / 1e9) : null;
+  return {
+    ...base,
+    requestLatencyMs: latencyMs,
+    openAiCompat: true,
+    genTokPerSec,
+    prefillTokPerSec,
+    evalDurationMs: durationNsToMs(evalDurationNs),
+    promptEvalDurationMs: durationNsToMs(promptEvalDurationNs),
+  };
+}
+
+function textFromContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (!part) return '';
+      if (typeof part === 'string') return part;
+      return part.text || part.content || '';
+    }).filter(Boolean).join('\n');
+  }
+  if (typeof content === 'object') {
+    if (content.text != null) return textFromContent(content.text);
+    if (content.content != null) return textFromContent(content.content);
+    try { return JSON.stringify(content); } catch { return String(content); }
+  }
+  return String(content);
+}
+
+function messagesToOllamaNative(messages = []) {
+  const out = [];
+  const toolNamesById = new Map();
+
+  for (const msg of messages || []) {
+    if (!msg || !msg.role) continue;
+    if (typeof msg.content === 'string') {
+      const converted = { role: msg.role, content: msg.content };
+      if (msg.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+        converted.tool_calls = msg.tool_calls.map((call, index) => {
+          const id = call.id || call.toolCallId || call.tool_use_id || `ollama_tool_${index}`;
+          const name = call.name || call.tool || call.function?.name || '';
+          if (id && name) toolNamesById.set(id, name);
+          return { function: { name, arguments: call.input || call.arguments || call.function?.arguments || {} } };
+        });
+      }
+      if (msg.role === 'tool') converted.tool_name = msg.tool_name || msg.name || toolNamesById.get(msg.tool_call_id) || '';
+      out.push(converted);
+      continue;
+    }
+
+    if (!Array.isArray(msg.content)) {
+      out.push({ role: msg.role, content: textFromContent(msg.content) });
+      continue;
+    }
+
+    const toolResults = msg.content.filter((part) => part?.type === 'tool_result');
+    if (toolResults.length > 0) {
+      for (const result of toolResults) {
+        const id = result.tool_use_id || result.id || result.toolCallId || '';
+        out.push({
+          role: 'tool',
+          content: textFromContent(result.content),
+          tool_name: result.tool_name || result.name || toolNamesById.get(id) || '',
+        });
+      }
+      continue;
+    }
+
+    const textParts = msg.content.filter((part) => part?.type === 'text');
+    const reasoningParts = msg.content.filter((part) => part?.type === 'reasoning');
+    const toolUses = msg.content.filter((part) => part?.type === 'tool_use');
+    const converted = {
+      role: msg.role,
+      content: textParts.map((part) => part.text || part.content || '').filter(Boolean).join('\n') || '',
+    };
+    if (reasoningParts.length > 0) {
+      converted.thinking = reasoningParts.map((part) => part.text || part.content || '').filter(Boolean).join('\n');
+    }
+    if (toolUses.length > 0) {
+      converted.tool_calls = toolUses.map((call, index) => {
+        const id = call.id || call.tool_use_id || call.toolCallId || `ollama_tool_${index}`;
+        if (id && call.name) toolNamesById.set(id, call.name);
+        return { function: { name: call.name || '', arguments: call.input || {} } };
+      });
+    }
+    out.push(converted);
+  }
+  return out;
+}
+
+function responseFromOllamaNative(raw, latencyMs) {
+  const msg = raw?.message || {};
+  const toolCalls = (msg.tool_calls || []).map((call, index) => ({
+    id: call.id || call.toolCallId || call.tool_use_id || `ollama_tool_${index}`,
+    name: call.name || call.tool || call.function?.name || '',
+    input: call.input || call.arguments || call.function?.arguments || {},
+  })).filter((call) => call.name);
+  const evalDurationNs = raw?.eval_duration || 0;
+  const evalCount = raw?.eval_count || 0;
+  const promptEvalDurationNs = raw?.prompt_eval_duration || 0;
+  const promptEvalCount = raw?.prompt_eval_count || 0;
+  const genTokPerSec = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : null;
+  const prefillTokPerSec = promptEvalDurationNs > 0 ? promptEvalCount / (promptEvalDurationNs / 1e9) : null;
+  return {
+    content: msg.content || null,
+    reasoningContent: msg.thinking || msg.reasoning || msg.reasoning_content || null,
+    toolCalls,
+    stopReason: toolCalls.length > 0 ? 'tool_use' : 'end_turn',
+    usage: {
+      input: promptEvalCount,
+      output: evalCount,
+      genTokPerSec,
+      prefillTokPerSec,
+      evalDurationMs: evalDurationNs / 1e6,
+      promptEvalDurationMs: promptEvalDurationNs / 1e6,
+      requestLatencyMs: latencyMs,
+    },
+    latencyMs,
+    raw,
+  };
+}
+
+async function fetchJson(url, opts = {}) {
+  const timeoutMs = opts.timeoutMs || 5000;
+  const init = { ...opts };
+  delete init.timeoutMs;
+  if (!init.signal && timeoutMs > 0) init.signal = AbortSignal.timeout(timeoutMs);
+  const resp = await fetch(url, init);
+  const text = await resp.text();
+  let json = null;
+  try { json = text ? JSON.parse(text) : null; } catch {}
+  if (!resp.ok) {
+    const detail = json?.error || text || `HTTP ${resp.status}`;
+    const err = new Error(`Ollama API error ${resp.status}: ${detail}`);
+    err.status = resp.status;
+    err.body = text;
+    throw err;
+  }
+  return json;
+}
+
+function ollamaModelName(model) {
+  return String(model?.name || model?.model || '').trim();
+}
+
 /**
  * Create an Ollama local-model LLM provider.
  * Uses Ollama's OpenAI-compatible API — no npm dependency needed.
  * @param {{ baseUrl?: string }} config
  */
 function createOllamaProvider(config = {}) {
-  const baseUrl = (config.baseUrl || 'http://localhost:11434').replace(/\/+$/, '');
+  const baseUrl = (config.baseUrl || 'http://127.0.0.1:11434').replace(/\/+$/, '');
   const defaultThink = config.think ?? false;
+  const defaultKeepAlive = config.keepAlive ?? process.env.OLLAMA_KEEP_ALIVE ?? '30m';
 
   return {
     type: 'ollama',
 
-    async chat({ model, messages, tools, system, maxTokens, temperature, signal, thinking, reasoningEffort, options } = {}) {
+    async chat({ model, messages, tools, system, maxTokens, temperature, signal, thinking, reasoningEffort, options, keepAlive } = {}) {
       const modelId = model || 'gemma4:e4b';
       const openaiMessages = [];
+      const nativeMessages = messagesToOllamaNative([
+        ...(system ? [{ role: 'system', content: system }] : []),
+        ...((messages && messages.length > 0) ? messages : []),
+      ]);
 
       // System prompt as first message
       if (system) {
@@ -71,28 +261,51 @@ function createOllamaProvider(config = {}) {
         openaiMessages.push(...messagesToOpenAI(messages));
       }
 
-      // Use native Ollama API when no tools — it returns eval_duration for accurate gen speed
-      const useNativeApi = !tools || tools.length === 0;
+      // Native Ollama API honors options/keep_alive and returns eval_duration
+      // timing. Keep tool calls on the OpenAI-compatible path by default: it is
+      // currently more reliable for Gemma4 coding-agent tool selection. Native
+      // tools remain available for explicit probes via config.useNativeTools.
+      const useNativeApi = !tools || tools.length === 0 || config.useNativeTools === true;
 
       if (useNativeApi) {
         const resolvedThink = resolveThinkValue({ model: modelId, thinking, reasoningEffort });
         const nativeBody = {
           model: modelId,
-          messages: openaiMessages,
+          messages: nativeMessages,
           stream: false,
           think: resolvedThink !== undefined ? resolvedThink : defaultThink,
         };
+        const resolvedKeepAlive = keepAlive ?? defaultKeepAlive;
+        if (resolvedKeepAlive != null && resolvedKeepAlive !== '') nativeBody.keep_alive = resolvedKeepAlive;
         const nativeOptions = buildOllamaOptions({ model: modelId, maxTokens, temperature, options });
         if (nativeOptions) nativeBody.options = nativeOptions;
+        const openaiTools = toOpenAI(tools);
+        if (openaiTools && openaiTools.length > 0) nativeBody.tools = openaiTools;
 
         const start = Date.now();
-        const resp = await fetch(`${baseUrl}/api/chat`, {
+        let resp = await fetch(`${baseUrl}/api/chat`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify(nativeBody),
           signal,
         });
 
+        if (!resp.ok && resp.status === 400 && nativeBody.tools) {
+          const errText = await resp.text().catch(() => '');
+          if (errText.includes('does not support tools')) {
+            console.log(`[ollama] ${model} does not support tools — retrying without`);
+            delete nativeBody.tools;
+            resp = await fetch(`${baseUrl}/api/chat`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(nativeBody),
+              signal,
+            });
+          } else {
+            throw new Error(`Ollama API error ${resp.status}: ${errText}`);
+          }
+        }
+
         if (!resp.ok) {
           const text = await resp.text().catch(() => '');
           throw new Error(`Ollama API error ${resp.status}: ${text}`);
@@ -100,34 +313,10 @@ function createOllamaProvider(config = {}) {
 
         const raw = await resp.json();
         const latencyMs = Date.now() - start;
-        const msg = raw.message || {};
-        const reasoningContent = msg.thinking || msg.reasoning || msg.reasoning_content || null;
-
-        // Extract accurate timing from native API (durations are in nanoseconds)
-        const evalDurationNs = raw.eval_duration || 0;
-        const evalCount = raw.eval_count || 0;
-        const promptEvalDurationNs = raw.prompt_eval_duration || 0;
-        const promptEvalCount = raw.prompt_eval_count || 0;
-        const genTokPerSec = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : null;
-        const prefillTokPerSec = promptEvalDurationNs > 0 ? promptEvalCount / (promptEvalDurationNs / 1e9) : null;
-
         return {
-          content: msg.content || null,
-          reasoningContent,
-          toolCalls: [],
-          stopReason: 'end_turn',
-          usage: {
-            input: promptEvalCount,
-            output: evalCount,
-            genTokPerSec,
-            prefillTokPerSec,
-            evalDurationMs: evalDurationNs / 1e6,
-            promptEvalDurationMs: promptEvalDurationNs / 1e6,
-          },
-          latencyMs,
+          ...responseFromOllamaNative(raw, latencyMs),
           model: modelId,
           provider: 'ollama',
-          raw,
         };
       }
 
@@ -145,7 +334,6 @@ function createOllamaProvider(config = {}) {
 
       if (maxTokens != null) body.max_tokens = maxTokens;
       if (temperature != null) body.temperature = temperature;
-
       const start = Date.now();
       let resp = await fetch(`${baseUrl}/v1/chat/completions`, {
         method: 'POST',
@@ -178,21 +366,54 @@ function createOllamaProvider(config = {}) {
 
       const raw = await resp.json();
       const normalized = responseFromOpenAI(raw);
+      const latencyMs = Date.now() - start;
 
       let stopReason = 'end_turn';
       if (normalized.stopReason === 'tool_calls') stopReason = 'tool_use';
       else if (normalized.stopReason === 'stop' || !normalized.stopReason) stopReason = 'end_turn';
 
-      return { ...normalized, stopReason, latencyMs: Date.now() - start, model: modelId, provider: 'ollama', raw };
+      return {
+        ...normalized,
+        usage: usageFromOpenAICompat(raw, latencyMs),
+        stopReason,
+        latencyMs,
+        model: modelId,
+        provider: 'ollama',
+        raw,
+      };
+    },
+
+    async prewarm({ model, keepAlive, timeoutMs = 120000 } = {}) {
+      const modelId = model || config.model || 'gemma4:e4b';
+      const body = {
+        model: modelId,
+        messages: [{ role: 'user', content: 'Reply OK.' }],
+        stream: false,
+        think: false,
+        keep_alive: keepAlive ?? defaultKeepAlive,
+        options: { num_predict: 8, num_ctx: Math.min(defaultNumCtxForModel(modelId) || 2048, 2048) },
+      };
+      const started = Date.now();
+      const raw = await fetchJson(`${baseUrl}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        timeoutMs,
+      });
+      return {
+        ok: Boolean(raw?.message?.content),
+        latencyMs: Date.now() - started,
+        totalDurationMs: durationNsToMs(raw?.total_duration),
+        loadDurationMs: durationNsToMs(raw?.load_duration),
+        promptEvalCount: raw?.prompt_eval_count ?? null,
+        evalCount: raw?.eval_count ?? null,
+        raw,
+      };
     },
 
     async listModels() {
       try {
-        const resp = await fetch(`${baseUrl}/api/tags`, {
-          signal: AbortSignal.timeout(3000),
-        });
-        if (!resp.ok) return [];
-        const data = await resp.json();
+        const data = await fetchJson(`${baseUrl}/api/tags`, { timeoutMs: 3000 });
         return (data.models || [])
           // Drop embedding models — they're not chat-capable.
           .filter((m) => !/embed|embedding/i.test(m.name || ''))
@@ -209,14 +430,91 @@ function createOllamaProvider(config = {}) {
 
     async isAvailable() {
       try {
-        const resp = await fetch(`${baseUrl}/api/tags`, {
-          signal: AbortSignal.timeout(3000),
-        });
-        return resp.ok;
+        await fetchJson(`${baseUrl}/api/tags`, { timeoutMs: 3000 });
+        return true;
       } catch {
         return false;
       }
     },
+
+    async probeConnection({ model, timeoutMs = 25000, chatTimeoutMs, keepAlive } = {}) {
+      const started = Date.now();
+      const modelId = model || config.model || 'gemma4:e4b';
+      const probe = {
+        ok: false,
+        provider: 'ollama',
+        model: modelId,
+        base_url: baseUrl,
+        checked_at: new Date().toISOString(),
+        daemon_ok: false,
+        model_present: false,
+        loaded: null,
+        diagnostics: {},
+      };
+      try {
+        const tags = await fetchJson(`${baseUrl}/api/tags`, { timeoutMs: Math.min(timeoutMs, 5000) });
+        probe.daemon_ok = true;
+        const models = Array.isArray(tags.models) ? tags.models : [];
+        probe.models = models
+          .map((m) => ollamaModelName(m))
+          .filter(Boolean)
+          .filter((name) => !/embed|embedding/i.test(name));
+        probe.model_present = probe.models.includes(modelId);
+        if (!probe.model_present) {
+          probe.error_type = 'model_missing';
+          probe.error = `Ollama model "${modelId}" is not installed.`;
+          probe.latency_ms = Date.now() - started;
+          return probe;
+        }
+
+        try {
+          const ps = await fetchJson(`${baseUrl}/api/ps`, { timeoutMs: Math.min(timeoutMs, 5000) });
+          const loadedModels = Array.isArray(ps.models) ? ps.models : [];
+          const loaded = loadedModels.find((m) => ollamaModelName(m) === modelId) || null;
+          probe.loaded = loaded ? {
+            loaded: true,
+            context_length: loaded.context_length ?? loaded.details?.context_length ?? null,
+            expires_at: loaded.expires_at || null,
+            size_vram: loaded.size_vram ?? null,
+          } : { loaded: false };
+        } catch (err) {
+          probe.loaded = { loaded: null, error: compactError(err) };
+        }
+
+        const chatStart = Date.now();
+        const chat = await fetchJson(`${baseUrl}/api/chat`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            model: modelId,
+            messages: [{ role: 'user', content: 'Reply with OK.' }],
+            stream: false,
+            think: false,
+            keep_alive: keepAlive ?? defaultKeepAlive,
+            options: { num_predict: 8, num_ctx: 2048 },
+          }),
+          timeoutMs: chatTimeoutMs || timeoutMs,
+        });
+        const content = String(chat?.message?.content || '').trim();
+        probe.ok = content.length > 0;
+        probe.error_type = probe.ok ? '' : 'empty_response';
+        probe.error = probe.ok ? '' : 'Ollama returned an empty probe response.';
+        probe.latency_ms = Date.now() - started;
+        probe.diagnostics = {
+          chat_latency_ms: Date.now() - chatStart,
+          total_duration_ms: durationNsToMs(chat?.total_duration),
+          load_duration_ms: durationNsToMs(chat?.load_duration),
+          prompt_eval_count: chat?.prompt_eval_count ?? null,
+          eval_count: chat?.eval_count ?? null,
+        };
+        return probe;
+      } catch (err) {
+        probe.error_type = compactError(err);
+        probe.error = String(err?.message || err || 'Ollama probe failed').slice(0, 240);
+        probe.latency_ms = Date.now() - started;
+        return probe;
+      }
+    },
   };
 }
 
@@ -224,6 +522,7 @@ module.exports = {
   createOllamaProvider,
   buildOllamaOptions,
   resolveThinkValue,
+  isFastGemma4Model,
   isReasoningCapableOllamaModel,
   capabilitiesForOllamaModel,
 };

package/template/wall-e/llm/provider-error.js

@@ -114,6 +114,11 @@ function classifyType(status, lower) {
   ) return 'auth_error';
   if (status === 404 || /model .*not found|not_found_error|model_not_found|does not exist|unknown model/i.test(lower)) return 'model_unavailable';
   if (/context length exceeded|context_length_exceeded|maximum context|token limit/i.test(lower)) return 'context_window';
+  // Connect-phase failures mean the endpoint was never reached (DNS, routing,
+  // VPN-only gateways). They must classify as 'network' even though undici
+  // spells them "Connect Timeout Error" — the generic 'timeout' advice
+  // ("switch provider/model") is wrong when nothing ever connected.
+  if (/und_err_connect_timeout|connecttimeouterror|connect timeout|ehostunreach|enetunreach|ehostdown/i.test(lower)) return 'network';
   if (status === 408 || /timeout|timed out|etimedout|aborterror|aborted/i.test(lower)) return 'timeout';
   if (status === 529 || status === 503 || /overloaded|service unavailable|temporarily unavailable|unavailable/i.test(lower)) return 'provider_unavailable';
   if (/fetch failed|network|eai_again|enotfound|econnreset|socket hang up|connection refused|econnrefused/i.test(lower)) return 'network';
@@ -157,7 +162,7 @@ function messageForType(type) {
     case 'network':
       return {
         title: 'AI provider network error',
-        body: 'Wall-E could not reach the provider endpoint. Check connectivity, base URL, or local provider status, then retry.',
+        body: 'Wall-E could not reach the provider endpoint. Check connectivity (VPN if the endpoint is internal), the base URL, or local provider status, then retry.',
       };
     case 'provider_unavailable':
       return {
@@ -258,6 +263,18 @@ function toApiPayload(err, context = {}) {
 function recordProviderFailureAlert(providerError, brain) {
   if (!providerError) return { alerted: false };
   try {
+    try {
+      const { recordProviderHealthStatus } = require('./provider-health-state');
+      recordProviderHealthStatus({
+        provider: providerError.provider || 'default',
+        model: providerError.model || '',
+        ok: false,
+        source: 'provider-error',
+        error_type: providerError.type || 'provider_error',
+        error: providerError.rawMessage || providerError.userMessage || providerError.title || '',
+        checked_at: providerError.createdAt || new Date().toISOString(),
+      }, { brain, clearTransientAlerts: false });
+    } catch {}
     const planner = require('../skills/skill-planner');
     const actionUrl = providerError.type === 'request_invariant'
       ? null