create-walle 0.9.13 → 0.9.15

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

@@ -2,6 +2,37 @@
 
 const { toOpenAI, messagesToOpenAI, responseFromOpenAI } = require('./tool-adapter');
 
+function isGemma4Model(model) {
+  return /^gemma4:/i.test(String(model || ''));
+}
+
+function resolveThinkValue({ model, thinking, reasoningEffort } = {}) {
+  if (thinking === false || thinking === 'disabled' || thinking === 'off') return false;
+  if (thinking === true || thinking === 'enabled' || thinking === 'on') return true;
+  if (['low', 'medium', 'high'].includes(thinking)) return thinking;
+
+  // Ollama's GPT-OSS models accept effort levels. Gemma4's thinking renderer
+  // accepts the boolean form, so keep Gemma4 on true when callers ask for any
+  // non-disabled reasoning effort.
+  if (reasoningEffort && reasoningEffort !== 'disabled') {
+    if (/^gpt-oss/i.test(String(model || '')) && ['low', 'medium', 'high'].includes(reasoningEffort)) {
+      return reasoningEffort;
+    }
+    return true;
+  }
+  return undefined;
+}
+
+function buildOllamaOptions({ model, maxTokens, temperature, options } = {}) {
+  const out = { ...(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;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
 /**
  * Create an Ollama local-model LLM provider.
  * Uses Ollama's OpenAI-compatible API — no npm dependency needed.
@@ -9,11 +40,13 @@ const { toOpenAI, messagesToOpenAI, responseFromOpenAI } = require('./tool-adapt
  */
 function createOllamaProvider(config = {}) {
   const baseUrl = (config.baseUrl || 'http://localhost:11434').replace(/\/+$/, '');
+  const defaultThink = config.think ?? false;
 
   return {
     type: 'ollama',
 
-    async chat({ model, messages, tools, system, maxTokens, temperature, signal } = {}) {
+    async chat({ model, messages, tools, system, maxTokens, temperature, signal, thinking, reasoningEffort, options } = {}) {
+      const modelId = model || 'gemma4:e4b';
       const openaiMessages = [];
 
       // System prompt as first message
@@ -30,13 +63,15 @@ function createOllamaProvider(config = {}) {
       const useNativeApi = !tools || tools.length === 0;
 
       if (useNativeApi) {
+        const resolvedThink = resolveThinkValue({ model: modelId, thinking, reasoningEffort });
         const nativeBody = {
-          model: model || 'gemma4:e4b',
+          model: modelId,
           messages: openaiMessages,
           stream: false,
+          think: resolvedThink !== undefined ? resolvedThink : defaultThink,
         };
-        if (maxTokens != null) nativeBody.options = { ...nativeBody.options, num_predict: maxTokens };
-        if (temperature != null) nativeBody.options = { ...nativeBody.options, temperature };
+        const nativeOptions = buildOllamaOptions({ model: modelId, maxTokens, temperature, options });
+        if (nativeOptions) nativeBody.options = nativeOptions;
 
         const start = Date.now();
         const resp = await fetch(`${baseUrl}/api/chat`, {
@@ -54,6 +89,7 @@ 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;
@@ -65,6 +101,7 @@ function createOllamaProvider(config = {}) {
 
         return {
           content: msg.content || null,
+          reasoningContent,
           toolCalls: [],
           stopReason: 'end_turn',
           usage: {
@@ -76,17 +113,19 @@ function createOllamaProvider(config = {}) {
             promptEvalDurationMs: promptEvalDurationNs / 1e6,
           },
           latencyMs,
-          model: model || 'gemma4:e4b',
+          model: modelId,
           provider: 'ollama',
           raw,
         };
       }
 
       // Fall back to OpenAI-compat API for tool use
+      const resolvedThink = resolveThinkValue({ model: modelId, thinking, reasoningEffort });
       const body = {
-        model: model || 'gemma4:e4b',
+        model: modelId,
         messages: openaiMessages,
         stream: false,
+        think: resolvedThink !== undefined ? resolvedThink : defaultThink,
       };
 
       const openaiTools = toOpenAI(tools);
@@ -132,7 +171,7 @@ function createOllamaProvider(config = {}) {
       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: model || 'gemma4:e4b', provider: 'ollama', raw };
+      return { ...normalized, stopReason, latencyMs: Date.now() - start, model: modelId, provider: 'ollama', raw };
     },
 
     async listModels() {
@@ -169,4 +208,4 @@ function createOllamaProvider(config = {}) {
   };
 }
 
-module.exports = { createOllamaProvider };
+module.exports = { createOllamaProvider, buildOllamaOptions, resolveThinkValue };

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

@@ -13,7 +13,7 @@
     "chat": true,
     "tools": true,
     "vision": false,
-    "thinking": false,
+    "thinking": true,
     "streaming": true,
     "local": true
   },

package/template/wall-e/llm/tool-adapter.js

@@ -205,6 +205,7 @@ function responseFromOpenAI(resp) {
 
   return {
     content: msg.content || null,
+    reasoningContent: msg.reasoning_content || msg.reasoning || msg.thinking || null,
     toolCalls: (msg.tool_calls || []).map((tc, index) => ({
       id: tc.id || synthesizeOpenAIToolCallId(index),
       name: tc.function.name,

package/template/wall-e/loops/ingest.js

@@ -1,22 +1,39 @@
 const brain = require('../brain');
 const eventBus = require('../events/event-bus');
 
+function checkpointName(adapter) {
+  const name = adapter?.name || adapter?.constructor?.name || 'unknown';
+  return `ingest:${name}`;
+}
+
+function newerTimestamp(a, b) {
+  if (!a) return b || null;
+  if (!b) return a;
+  return b > a ? b : a;
+}
+
 async function runOnce(adapters) {
-  const checkpoint = brain.getCheckpoint('ingest');
-  const since = checkpoint?.last_memory_at || null;
+  const legacyCheckpoint = brain.getCheckpoint('ingest');
   let memoriesIngested = 0;
-  let latestTimestamp = since;
+  let latestTimestamp = legacyCheckpoint?.last_memory_at || null;
+  const adapterResults = {};
 
   for (const adapter of adapters) {
+    const adapterCheckpointName = checkpointName(adapter);
+    const adapterCheckpoint = brain.getCheckpoint(adapterCheckpointName);
+    const since = adapterCheckpoint?.last_memory_at || null;
+    let adapterIngested = 0;
+    let adapterLatestTimestamp = since;
+
     try {
       const memories = await adapter.poll(since);
       for (const mem of memories) {
+        adapterLatestTimestamp = newerTimestamp(adapterLatestTimestamp, mem.timestamp);
+        latestTimestamp = newerTimestamp(latestTimestamp, mem.timestamp);
         const result = brain.insertMemory(mem);
         if (result) {
           memoriesIngested++;
-          if (!latestTimestamp || mem.timestamp > latestTimestamp) {
-            latestTimestamp = mem.timestamp;
-          }
+          adapterIngested++;
           if (mem.importance >= 0.8 || mem.memory_type === 'message_received') {
             eventBus.emitHighImportance(result?.id, (mem.content || '').slice(0, 200));
           }
@@ -59,17 +76,34 @@ async function runOnce(adapters) {
           console.error('[ingest] Exchange chunking failed:', e.message);
         }
       }
+      brain.upsertCheckpoint(adapterCheckpointName, {
+        last_memory_at: adapterLatestTimestamp,
+        metadata: JSON.stringify({
+          adapter: adapter.name || adapter.constructor?.name || 'unknown',
+          memories_ingested: adapterIngested,
+          memories_seen: memories.length,
+        }),
+      });
+      adapterResults[adapter.name || adapter.constructor?.name || 'unknown'] = {
+        memoriesIngested: adapterIngested,
+        memoriesSeen: memories.length,
+        lastMemoryAt: adapterLatestTimestamp,
+      };
     } catch (err) {
       console.error(`[ingest] Adapter ${adapter.name} failed:`, err.message);
+      adapterResults[adapter.name || adapter.constructor?.name || 'unknown'] = {
+        error: err.message,
+        lastMemoryAt: adapterLatestTimestamp,
+      };
     }
   }
 
   brain.upsertCheckpoint('ingest', {
     last_memory_at: latestTimestamp,
-    metadata: JSON.stringify({ memories_ingested: memoriesIngested }),
+    metadata: JSON.stringify({ memories_ingested: memoriesIngested, adapters: adapterResults }),
   });
 
   return { memoriesIngested };
 }
 
-module.exports = { runOnce };
+module.exports = { checkpointName, runOnce };

package/template/wall-e/loops/initiative.js

@@ -3,12 +3,24 @@
 const brain = require('../brain');
 const { buildStateSnapshot, isStateEmpty, formatSnapshot } = require('../context/state-snapshot');
 const { canActAutonomously, getDomainConfidence } = require('../decision/confidence');
-const { getDefaultClient, getDefaultModel, resolveCompatibleModel } = require('../llm/client');
+const { getDefaultClient, getDefaultModel, getDefaultProviderType, resolveCompatibleModel } = require('../llm/client');
 const { v4: uuidv4 } = require('uuid');
 const { buildDisciplineHeader } = require('./loop-prompt-discipline');
 const { augmentSystemPrompt } = require('./loop-directives');
+const telemetry = require('../telemetry');
+const { classifyProviderError } = require('../llm/provider-error');
 
 const COOLDOWN_MS = 30 * 60 * 1000; // 30 minutes between same decisions
+const PROVIDER_COOLDOWN_MS = {
+  auth_error: 60 * 60 * 1000,
+  quota_exceeded: 60 * 60 * 1000,
+  rate_limited: 15 * 60 * 1000,
+  network: 10 * 60 * 1000,
+  provider_unavailable: 10 * 60 * 1000,
+  timeout: 10 * 60 * 1000,
+};
+const PROVIDER_COOLDOWN_TYPES = new Set(Object.keys(PROVIDER_COOLDOWN_MS));
+let providerCooldown = null;
 
 /**
  * Read ~/.walle/HEARTBEAT.md (or opts.heartbeatPath for tests). Returns
@@ -239,11 +251,60 @@ function isOnCooldown(decision, recentDecisions) {
   });
 }
 
+function getActiveProviderCooldown(now = Date.now()) {
+  if (!providerCooldown) return null;
+  if (providerCooldown.until <= now) {
+    providerCooldown = null;
+    return null;
+  }
+  return providerCooldown;
+}
+
+function setProviderCooldown(providerError, now = Date.now()) {
+  if (!providerError || !PROVIDER_COOLDOWN_TYPES.has(providerError.type)) return null;
+  const cooldownMs = PROVIDER_COOLDOWN_MS[providerError.type] || 10 * 60 * 1000;
+  providerCooldown = {
+    type: providerError.type,
+    provider: providerError.provider || null,
+    model: providerError.model || null,
+    message: providerError.userMessage || providerError.message || '',
+    until: now + cooldownMs,
+    cooldownMs,
+  };
+  try {
+    telemetry.track('initiative_provider_cooldown', {
+      type: providerCooldown.type,
+      provider: providerCooldown.provider,
+      model: providerCooldown.model,
+      cooldown_seconds: Math.round(cooldownMs / 1000),
+    });
+  } catch {}
+  return providerCooldown;
+}
+
+function skippedProviderCooldown(cooldown, reason = 'provider-cooldown') {
+  return {
+    skipped: true,
+    loop: 'initiative',
+    reason,
+    provider_error_type: cooldown.type,
+    provider: cooldown.provider,
+    model: cooldown.model,
+    retry_at: new Date(cooldown.until).toISOString(),
+  };
+}
+
 /**
  * Main initiative loop function. Called on an interval from agent.js
  */
 async function runInitiativeLoop(opts = {}) {
   const { shouldRunLoop, skipped } = require('./loop-precheck');
+  const now = typeof opts.now === 'function' ? opts.now() : Date.now();
+  const activeCooldown = getActiveProviderCooldown(now);
+  if (activeCooldown) {
+    return skippedProviderCooldown(activeCooldown);
+  }
+
   const pre = shouldRunLoop({ loopName: 'initiative' });
   if (!pre.run) {
     if (pre.reason === 'no-provider' && !runInitiativeLoop._pauseLogged) {
@@ -312,6 +373,23 @@ async function runInitiativeLoop(opts = {}) {
     const text = response.content || '';
 
     decision = parseDecision(text);
+    providerCooldown = null;
+  } catch (err) {
+    const providerError = classifyProviderError(err, {
+      provider: provider.type || getDefaultProviderType(),
+      model,
+    });
+    const cooldown = setProviderCooldown(providerError, now);
+    if (cooldown) {
+      try {
+        const { default: providerAvailability } = require('../llm/provider-availability');
+        const registeredProv = providerAvailability.getConfiguredProviders()
+          .find(p => p.providerType === providerError.provider || p.providerId === providerError.provider);
+        if (registeredProv) providerAvailability.recordFailure(registeredProv.providerId, providerError.userMessage || err.message);
+      } catch {}
+      return skippedProviderCooldown(cooldown, 'provider-cooldown-started');
+    }
+    throw err;
   } finally {
     clearTimeout(timeout);
   }
@@ -350,5 +428,12 @@ module.exports = {
   buildInitiativePrompt,
   isOnCooldown,
   // Exported for testing
-  _test: { logInitiative, executeDecision, getTier },
+  _test: {
+    logInitiative,
+    executeDecision,
+    getTier,
+    getActiveProviderCooldown,
+    setProviderCooldown,
+    resetProviderCooldown: () => { providerCooldown = null; },
+  },
 };