create-walle 0.9.21 → 0.9.23

package/template/wall-e/external-action-controller.js

@@ -373,6 +373,18 @@ function findApprovalForEnvelope(envelope, approvals) {
     return approval.decision === 'allow'
       && approvedHash === envelope.payloadHash
       && (!approvedId || approvedId === envelope.id);
+  }) || list.find((approval) => {
+    if (!approval || approval.decision !== 'allow') return false;
+    const scope = approval.scope || approval.approvalScope || approval.approval_scope;
+    if (scope !== 'current_turn_external_actions') return false;
+    const domains = approval.domains || approval.allowedDomains || approval.allowed_domains || [];
+    if (Array.isArray(domains) && domains.length && !domains.includes(envelope.domain)) return false;
+    const toolNames = approval.toolNames || approval.allowedTools || approval.allowed_tools || [];
+    if (Array.isArray(toolNames) && toolNames.length && !toolNames.includes(envelope.toolName)) return false;
+    const issues = envelope.validation?.issues || [];
+    if (issues.length > 0) return false;
+    const confirmations = envelope.validation?.confirmations || [];
+    return confirmations.every((issue) => issue.code === 'external_action_confirmation_required');
   }) || null;
 }
 

package/template/wall-e/http/auth.js

@@ -11,6 +11,7 @@ const PUBLIC_ROUTES = new Set([
   '/api/wall-e/telemetry/storage',
   '/api/wall-e/telemetry/cleanup',
   '/api/wall-e/telemetry/events',
+  '/api/wall-e/telemetry/feedback',
 ]);
 
 function getAllowedOrigin(req) {

package/template/wall-e/http/chat-api.js

@@ -160,6 +160,7 @@ function buildChatOptionsFromRequestBody(body = {}, {
     codeReviewMode: body.codeReviewMode || undefined,
     context,
     cwd,
+    contextMessages: body.contextMessages || body.context_messages || body.historyOverride || body.history_override || undefined,
     externalActionApprovals: body.externalActionApprovals || body.external_action_approvals || undefined,
     locationRequest: req,
     allowNetworkLocationInference: true,
@@ -288,8 +289,13 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
                 return;
               }
               // No alternatives — caller can't recover; surface 415.
+              const providerHint = resolved.missing.includes('audio')
+                ? 'OpenAI or Google Gemini'
+                : (resolved.missing.includes('pdf')
+                  ? 'Anthropic or Google Gemini'
+                  : 'Anthropic, OpenAI, Google Gemini, or Moonshot/Kimi');
               jsonResponse(res, {
-                error: `No installed provider supports capability(ies): ${resolved.missing.join(', ')}. Install Anthropic, OpenAI, or Google Gemini to use this attachment type.`,
+                error: `No installed provider supports capability(ies): ${resolved.missing.join(', ')}. Install ${providerHint} to use this attachment type.`,
                 code: 'NO_CAPABLE_PROVIDER',
                 needed: [...needed],
                 missing: resolved.missing,
@@ -378,22 +384,41 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
           return;
         }
         try { require('../telemetry').trackError('chat-api', err); } catch {}
-        const isProviderError = err && (err.code === 'AI_PROVIDER_ERROR' || err.providerErrorCode === 'AI_PROVIDER_ERROR' || err.providerError);
-        const providerPayload = isProviderError
-          ? require('../llm/provider-error').toApiPayload(err)
-          : null;
+        // ALWAYS classify the failure into a clear, human message naming the
+        // provider/model — e.g. "AI provider network error: Anthropic (claude-opus-4-8):
+        // Wall-E could not reach the provider endpoint…" or "AI model unavailable: …" —
+        // instead of leaking a raw, cryptic "fetch failed". classifyProviderError handles
+        // any error shape; when the error wasn't decorated deeper in the stack (the path
+        // that leaked "fetch failed"), pass the request's provider/model so the message
+        // can still name them.
+        let providerPayload;
+        try {
+          const providerErrorMod = require('../llm/provider-error');
+          if (err && err.providerError) {
+            providerPayload = providerErrorMod.toApiPayload(err); // already carries the resolved provider/model
+          } else {
+            let defaultProviderType;
+            try { defaultProviderType = require('../llm/client').getDefaultProviderType(); } catch {}
+            providerPayload = providerErrorMod.toApiPayload(err, {
+              provider: body.provider || defaultProviderType || undefined,
+              model: body.model || undefined,
+            });
+          }
+        } catch {
+          providerPayload = { error: 'AI provider error', message: err.message, code: 'AI_PROVIDER_ERROR' };
+        }
         if (wantsStream) {
           try {
             res.write('data: ' + JSON.stringify({
               type: 'error',
-              error: providerPayload ? providerPayload.message : err.message,
-              ...(providerPayload || {}),
+              error: providerPayload.message || err.message,
+              ...providerPayload,
             }) + '\n\n');
           } catch {}
           try { res.end(); } catch {}
         } else {
           const status = providerPayload?.providerError?.status || err.status || 500;
-          jsonResponse(res, providerPayload || { error: err.message }, status);
+          jsonResponse(res, providerPayload, status);
         }
       }
     }).catch(e => {
@@ -491,14 +516,24 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
 
   if (p === '/api/wall-e/chat/branches' && m === 'POST') {
     if (!ensureChatBrain(res, brain, ensureBrainInit)) return true;
-    readBody(req).then(body => {
+    // A branch snapshot serializes the whole conversation (active history plus
+    // every stored branch version), so it routinely outgrows the 1MB default —
+    // use the same large limit as the chat-send endpoint, which carries the
+    // same message payloads.
+    readBody(req, { maxBytes: BODY_LIMIT_LARGE }).then(body => {
       try {
-        brain.saveChatBranches(body.session_id || 'default', body.branches || {}, body.active || {}, body.history || []);
+        const updatedAtMs = Number(body.updated_at_ms || body.saved_at_ms || body.updatedAtMs || body.savedAtMs || 0) || Date.now();
+        brain.saveChatBranches(body.session_id || 'default', body.branches || {}, body.active || {}, body.history || [], updatedAtMs);
         jsonResponse(res, { data: { ok: true } });
       } catch (e) {
         jsonResponse(res, { error: e.message }, 500);
       }
-    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    }).catch(e => {
+      // An oversize body is a 413, not a generic 400, so the client can tell
+      // "too big" from a malformed/aborted request.
+      if (e && e.code === 'BODY_TOO_LARGE') { send413(res, e); return; }
+      jsonResponse(res, { error: e.message }, 400);
+    });
     return true;
   }