create-walle 0.9.11 → 0.9.13

package/template/wall-e/agent-runtime/spawn.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const { createAgentRunId, normalizeAgentMode, normalizeAgentRunResult } = require('../agent-runners/contract');
+const { createDefaultHarnessRegistry, selectAgentHarness } = require('./harness');
+const { createDefaultRuntimeRegistry } = require('./registry');
+const { defaultSessionStore } = require('./session-store');
+const {
+  attachTraceToResult,
+  createExecutionTrace,
+  finalizeTrace,
+  recordAttemptFinish,
+  recordAttemptStart,
+  recordSelection,
+} = require('../runtime/execution-trace');
+
+function normalizeAgentTaskRequest(input = {}) {
+  const task = input.task || input.prompt || '';
+  return {
+    id: input.id || input.runId || createAgentRunId(),
+    parentRunId: input.parentRunId || input.parentId || null,
+    harnessId: input.harnessId || null,
+    runtime: input.runtime || input.runtimePreference || 'cli-agent',
+    runnerId: input.runnerId || input.runner || input.agent || 'claude-code',
+    providerType: input.providerType || input.provider || 'unknown',
+    model: input.model || null,
+    mode: normalizeAgentMode(input.mode),
+    task,
+    prompt: task,
+    cwd: input.cwd || process.cwd(),
+    writeScope: Array.isArray(input.writeScope) ? input.writeScope : (input.writeScope ? [input.writeScope] : ['.']),
+    sandbox: input.sandbox || null,
+    timeoutMs: input.timeoutMs || 300000,
+    sessionId: input.sessionId || null,
+    persistent: Boolean(input.persistent),
+    cleanupPolicy: input.cleanupPolicy || (input.persistent ? 'manual' : 'delete-on-complete'),
+    threadId: input.threadId || null,
+    contextPolicy: input.contextPolicy || null,
+    attachments: Array.isArray(input.attachments) ? input.attachments : [],
+    reviewPolicy: input.reviewPolicy || null,
+    metadata: { ...(input.metadata || {}) },
+  };
+}
+
+async function spawnAgentSession(input = {}, deps = {}) {
+  const request = normalizeAgentTaskRequest(input);
+  const trace = deps.trace || createExecutionTrace({
+    runId: request.id,
+    parentRunId: request.parentRunId,
+    mode: request.mode,
+    provider: request.providerType,
+    model: request.model,
+    runnerId: request.runnerId,
+    harnessId: request.harnessId,
+    sessionId: request.sessionId || '',
+    cwd: request.cwd,
+    sandbox: request.sandbox,
+    taskType: 'agent-runtime',
+  });
+  if (deps.harnessRegistry || request.harnessId) {
+    const harnessRegistry = deps.harnessRegistry || createDefaultHarnessRegistry();
+    const selection = selectAgentHarness(request, [], {
+      registry: harnessRegistry,
+      providerAvailability: deps.providerAvailability,
+    });
+    if (!selection.selected) {
+      const error = `No supported agent harness found for ${request.harnessId || request.runnerId}`;
+      recordSelection(trace, selection);
+      finalizeTrace(trace, { status: 'failed', error });
+      return normalizeAgentRunResult({
+        runId: request.id,
+        parentRunId: request.parentRunId,
+        runnerId: request.runnerId,
+        providerType: request.providerType,
+        mode: request.mode,
+        sessionId: request.sessionId,
+        success: false,
+        stderr: error,
+        error,
+        trace,
+      });
+    }
+    recordSelection(trace, selection);
+    request.harnessId = selection.selected.id;
+    request.runnerId = selection.selected.runnerId;
+    request.providerType = selection.selected.providerType;
+    request.metadata = { ...request.metadata, harnessSelection: selection.reason };
+  }
+  const sessionStore = deps.sessionStore || defaultSessionStore;
+  const registry = deps.registry || createDefaultRuntimeRegistry({ runTask: deps.runTask });
+  const runtime = registry.getRuntime(request.runtime);
+  if (!runtime) {
+    const error = `Unknown agent runtime: ${request.runtime}`;
+    return normalizeAgentRunResult({
+      runId: request.id,
+      parentRunId: request.parentRunId,
+      runnerId: request.runnerId,
+      providerType: request.providerType,
+      mode: request.mode,
+      sessionId: request.sessionId,
+      success: false,
+      stderr: error,
+      error,
+    });
+  }
+
+  const existingSession = request.sessionId ? sessionStore.getSession(request.sessionId) : null;
+  const session = existingSession || sessionStore.createSession({
+    id: request.sessionId,
+    parentRunId: request.parentRunId,
+    runtime: request.runtime,
+    runnerId: request.runnerId,
+    harnessId: request.harnessId,
+    providerType: request.providerType,
+    model: request.model,
+    mode: request.mode,
+    cwd: request.cwd,
+    sandbox: request.sandbox,
+    task: request.task,
+    persistent: request.persistent,
+    cleanupPolicy: request.cleanupPolicy,
+    threadId: request.threadId,
+    metadata: request.metadata,
+  });
+
+  sessionStore.markRunning(session.id, {
+    parentRunId: request.parentRunId,
+    runtime: request.runtime,
+    runnerId: request.runnerId,
+    providerType: request.providerType,
+    model: request.model,
+    mode: request.mode,
+    cwd: request.cwd,
+    sandbox: request.sandbox,
+    task: request.task,
+  });
+
+  trace.sessionId = session.id;
+  trace.request.runnerId = request.runnerId;
+  trace.request.harnessId = request.harnessId;
+  trace.request.modelPreference = request.model || '';
+  const startedAt = Date.now();
+  const attempt = recordAttemptStart(trace, {
+    providerType: request.providerType,
+    model: request.model,
+    runnerId: request.runnerId,
+    harnessId: request.harnessId,
+  });
+
+  try {
+    const raw = await runtime.run({
+      ...request,
+      sessionId: session.id,
+      resumeHandle: session.resumeHandle,
+    });
+    const completedSession = sessionStore.markCompleted(session.id, raw || {}) || sessionStore.getSession(session.id);
+    recordAttemptFinish(trace, attempt.id, {
+      success: raw?.success !== false,
+      status: raw?.success === false ? 'failed' : 'completed',
+      error: raw?.error || raw?.stderr || null,
+      usage: raw?.usage || null,
+    });
+    trace.latencyMs = Date.now() - startedAt;
+    finalizeTrace(trace, { status: raw?.success === false ? 'failed' : 'completed' });
+
+    const normalized = normalizeAgentRunResult(raw || {}, {
+      runId: request.id,
+      parentRunId: request.parentRunId,
+      runnerId: request.runnerId,
+      harnessId: request.harnessId,
+      providerType: request.providerType,
+      mode: request.mode,
+      sessionId: session.id,
+      persistent: completedSession?.persistent,
+      cleanupPolicy: completedSession?.cleanupPolicy,
+      threadId: completedSession?.threadId,
+      sessionStatus: completedSession?.status,
+      trace,
+    });
+    return attachTraceToResult(normalized, trace);
+  } catch (err) {
+    const failedSession = sessionStore.markFailed(session.id, err) || sessionStore.getSession(session.id);
+    recordAttemptFinish(trace, attempt.id, { status: 'failed', error: err.message });
+    trace.latencyMs = Date.now() - startedAt;
+    finalizeTrace(trace, { status: 'failed', error: err.message });
+    return normalizeAgentRunResult({
+      runId: request.id,
+      parentRunId: request.parentRunId,
+      runnerId: request.runnerId,
+      harnessId: request.harnessId,
+      providerType: request.providerType,
+      mode: request.mode,
+      sessionId: session.id,
+      persistent: failedSession?.persistent,
+      cleanupPolicy: failedSession?.cleanupPolicy,
+      threadId: failedSession?.threadId,
+      sessionStatus: failedSession?.status,
+      success: false,
+      stderr: err.message,
+      error: err.message,
+      trace,
+    });
+  }
+}
+
+module.exports = {
+  normalizeAgentTaskRequest,
+  spawnAgentSession,
+};

package/template/wall-e/api-walle.js

@@ -124,13 +124,25 @@ function _invalidateSkillSnapshot() {
 // Inspired by OpenCode Question service (packages/opencode/src/question/index.ts)
 const { QuestionManager } = require('./tools/question-manager');
 const _questionRegistry = new QuestionManager(null);
+const { PermissionService } = require('./coding/permission-service');
+const _permissionRegistry = new PermissionService();
 
 let _tasksBootstrapped = false;
+let _runtimeDefaultsSynced = false;
 function ensureBrainInit() {
   if (!brain) return false;
   try { brain.getDb(); } catch {
     try { brain.initDb(); } catch { return false; }
   }
+  if (!_runtimeDefaultsSynced) {
+    try {
+      const provider = brain.getKv('walle_provider');
+      const model = brain.getKv('walle_model');
+      if (provider) process.env.WALLE_PROVIDER = provider;
+      if (model) process.env.WALLE_MODEL = model;
+      _runtimeDefaultsSynced = true;
+    } catch {}
+  }
   // Bootstrap core tasks if DB is empty (first run)
   if (!_tasksBootstrapped) {
     _tasksBootstrapped = true;
@@ -830,6 +842,18 @@ function handleWalleApi(req, res, url) {
     }
     if (!hasApiKey && walleProvider === 'openai' && process.env.OPENAI_API_KEY) hasApiKey = true;
     if (!hasApiKey && walleProvider === 'google' && (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY)) hasApiKey = true;
+    if (!hasApiKey && walleProvider === 'anthropic') {
+      let authMethod = process.env.WALLE_AUTH_METHOD || '';
+      try { authMethod = brain?.getProviderAuthMethod?.('anthropic') || authMethod; } catch {}
+      if (authMethod === 'oauth_proxy' || authMethod === 'claude_cli' || authMethod === 'devbox') hasApiKey = true;
+      if (process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_BASE_URL) hasApiKey = true;
+    }
+    if (!hasApiKey && walleProvider === 'openai') {
+      let authMethod = process.env.WALLE_AUTH_METHOD || '';
+      try { authMethod = brain?.getProviderAuthMethod?.('openai') || authMethod; } catch {}
+      if (authMethod === 'codex_cli') hasApiKey = true;
+    }
+    if (!hasApiKey && walleProvider === 'deepseek' && process.env.DEEPSEEK_API_KEY) hasApiKey = true;
     if (!hasApiKey && (walleProvider === 'ollama' || walleProvider === 'mlx')) hasApiKey = true;
 
     let serviceAlerts = [];
@@ -939,8 +963,14 @@ function handleWalleApi(req, res, url) {
         const ownerName = body.ownerName || '';
         const providerConfig = body.providerConfig || null;
 
-        if (provider) brain.setKv('walle_provider', provider);
-        if (model) brain.setKv('walle_model', model);
+        if (provider) {
+          brain.setKv('walle_provider', provider);
+          process.env.WALLE_PROVIDER = provider;
+        }
+        if (model) {
+          brain.setKv('walle_model', model);
+          process.env.WALLE_MODEL = model;
+        }
         if (ownerName) brain.setKv('walle_owner_name', ownerName);
 
         if (provider && providerConfig) {
@@ -2616,6 +2646,63 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // GET /api/wall-e/coding/sessions/:id/transcript?offset=&sequence=&limit=
+  // Replay durable Wall-E JSONL records for reconnecting clients without fs.watch.
+  const transcriptRangeMatch = p.match(/^\/api\/wall-e\/coding\/sessions\/([^/]+)\/transcript$/);
+  if (transcriptRangeMatch && m === 'GET') {
+    try {
+      const { WorkspaceReplay } = require('./coding/workspace-replay');
+      const replay = new WorkspaceReplay();
+      const range = replay.replayRange(decodeURIComponent(transcriptRangeMatch[1]), {
+        offset: params.get('offset') || 0,
+        sequence: params.get('sequence') || 0,
+        limitBytes: params.get('limit') || params.get('limitBytes') || undefined,
+      });
+      return jsonResponse(res, { ok: true, ...range }), true;
+    } catch (e) {
+      return jsonResponse(res, { error: e.message }, 500), true;
+    }
+  }
+
+  // POST /api/wall-e/coding/sessions/:id/transcript/append
+  // Direct append signal for CTM/ACP clients that already have structured parts.
+  const transcriptAppendMatch = p.match(/^\/api\/wall-e\/coding\/sessions\/([^/]+)\/transcript\/append$/);
+  if (transcriptAppendMatch && m === 'POST') {
+    readBody(req).then(body => {
+      try {
+        const { WorkspaceReplay } = require('./coding/workspace-replay');
+        const replay = new WorkspaceReplay();
+        const sessionId = decodeURIComponent(transcriptAppendMatch[1]);
+        const result = body.record
+          ? replay.appendRecord(sessionId, body.record)
+          : replay.appendPart(sessionId, body.partType || 'event', body.data || {}, {
+            cwd: body.cwd || '',
+            chatSessionId: body.chatSessionId || '',
+            parentUuid: body.parentUuid || null,
+          });
+        jsonResponse(res, { ok: true, ...result });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 500));
+    return true;
+  }
+
+  // GET /api/wall-e/coding/sessions/:id/replay — rebuild message/part state from JSONL.
+  const replayStateMatch = p.match(/^\/api\/wall-e\/coding\/sessions\/([^/]+)\/replay$/);
+  if (replayStateMatch && m === 'GET') {
+    try {
+      const { WorkspaceReplay } = require('./coding/workspace-replay');
+      const replay = new WorkspaceReplay();
+      const state = replay.rebuildState(decodeURIComponent(replayStateMatch[1]), {
+        cwd: params.get('cwd') || '',
+      });
+      return jsonResponse(res, { ok: true, ...state }), true;
+    } catch (e) {
+      return jsonResponse(res, { error: e.message }, 500), true;
+    }
+  }
+
   // POST /api/wall-e/coding/question/:sessionId/answer — answer an interactive question
   // Inspired by OpenCode Question.reply() (packages/opencode/src/question/index.ts)
   if (m === 'POST' && p.match(/^\/api\/wall-e\/coding\/question\/[^/]+\/answer$/)) {
@@ -3043,21 +3130,42 @@ function handleWalleApi(req, res, url) {
   if (p === '/api/wall-e/eval/dashboard' && m === 'GET') {
     try {
       const leaderboard = brain.getBenchmarkLeaderboardWithDimensions({ days: 30 });
-      const shadowResults = brain.getShadowResults({ limit: 1, offset: 0 });
       const shadowTotal = (typeof brain.getShadowResults === 'function')
         ? brain.getShadowResults({}).length : 0;
+      const providerCount = new Set(leaderboard.map(r => r.provider).filter(Boolean)).size;
+      const benchmarkEvals = leaderboard.reduce((s, r) => s + (Number(r.total_evals) || 0), 0);
+      const trustedBenchmarkEvals = leaderboard.reduce((s, r) => s + (Number(r.trusted_evals) || 0), 0);
+      const trustedBenchmarkModels = leaderboard.filter(r => r.trust_status === 'trusted').length;
+      const provisionalBenchmarkModels = leaderboard.filter(r => r.trust_status === 'provisional').length;
+      const legacyBenchmarkModels = leaderboard.filter(r => r.trust_status === 'legacy').length;
       return jsonResponse(res, {
         data: {
-          providers: leaderboard.length,
-          totalEvals: leaderboard.reduce((s, r) => s + r.total_evals, 0) + shadowTotal,
+          providers: providerCount,
+          modelGroups: leaderboard.length,
+          totalEvals: benchmarkEvals + shadowTotal,
           shadowEvals: shadowTotal,
-          benchmarkEvals: leaderboard.reduce((s, r) => s + r.total_evals, 0),
+          benchmarkEvals,
+          trustedBenchmarkEvals,
+          trustedBenchmarkModels,
+          provisionalBenchmarkModels,
+          legacyBenchmarkModels,
           leaderboard,
         }
       }), true;
     } catch (e) {
       return jsonResponse(res, {
-        data: { providers: 0, totalEvals: 0, shadowEvals: 0, benchmarkEvals: 0, leaderboard: [] },
+        data: {
+          providers: 0,
+          modelGroups: 0,
+          totalEvals: 0,
+          shadowEvals: 0,
+          benchmarkEvals: 0,
+          trustedBenchmarkEvals: 0,
+          trustedBenchmarkModels: 0,
+          provisionalBenchmarkModels: 0,
+          legacyBenchmarkModels: 0,
+          leaderboard: [],
+        },
         error: e.message
       }), true;
     }
@@ -3399,6 +3507,7 @@ function handleWalleApi(req, res, url) {
   if (p === '/api/wall-e/eval/benchmarks' && m === 'GET') {
     try {
       const { listBenchmarkSuites, loadBenchmarkSuite } = require('./eval/benchmarks');
+      const { listAdapterSuites } = require('./eval/eval-orchestrator');
       const suites = [];
       const errors = [];
       for (const name of listBenchmarkSuites()) {
@@ -3415,6 +3524,7 @@ function handleWalleApi(req, res, url) {
           errors.push({ suite: name, error: e.message });
         }
       }
+      suites.push(...listAdapterSuites());
       return jsonResponse(res, errors.length ? { data: suites, errors } : { data: suites }), true;
     } catch (e) {
       return jsonResponse(res, { data: [], error: e.message }), true;
@@ -3426,6 +3536,30 @@ function handleWalleApi(req, res, url) {
     readBody(req).then(async body => {
       try {
         const data = typeof body === 'string' ? JSON.parse(body) : body;
+        const { isAdapterSuite, EvalOrchestrator } = require('./eval/eval-orchestrator');
+        if (isAdapterSuite(data.suite)) {
+          const { getAvailableProviders } = require('./eval/head-to-head');
+          const models = Array.isArray(data.models) && data.models.length
+            ? data.models
+            : Array.isArray(data.providers) && data.providers.length
+              ? data.providers.map(p => p.model).filter(Boolean)
+              : getAvailableProviders(brain).map(p => p.model);
+          const { runAgentLoop } = require('./coding-orchestrator');
+          const orchestrator = new EvalOrchestrator({
+            brain,
+            timeoutMs: data.timeoutMs || 600000,
+            concurrency: data.concurrency || 1,
+            budgetDollars: data.budgetDollars || 10,
+          });
+          const result = await orchestrator.run({
+            suite: data.suite,
+            models,
+            runAgentLoop,
+            maxTasks: data.maxTasks,
+            afterDate: data.afterDate,
+          });
+          return jsonResponse(res, { data: result });
+        }
         const { runBenchmark } = require('./eval/benchmarks');
         const result = await runBenchmark(brain, {
           suite: data.suite,
@@ -4179,6 +4313,38 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // ── Coding Permission Requests ──
+
+  // GET /api/wall-e/permissions?session_id=... — list pending approvals
+  if (p === '/api/wall-e/permissions' && m === 'GET') {
+    try {
+      return jsonResponse(res, {
+        data: _permissionRegistry.list({ sessionId: params.get('session_id') || '' }),
+      }), true;
+    } catch (e) {
+      return jsonResponse(res, { error: e.message }, 500), true;
+    }
+  }
+
+  // POST /api/wall-e/permissions/:id/reply — reply once/always/reject
+  const permissionReplyMatch = p.match(/^\/api\/wall-e\/permissions\/([^/]+)\/reply$/);
+  if (permissionReplyMatch && m === 'POST') {
+    readBody(req).then(body => {
+      const reply = body.reply || body.decision;
+      if (!['once', 'always', 'reject'].includes(reply)) {
+        return jsonResponse(res, { error: 'reply must be once, always, or reject' }, 400);
+      }
+      const ok = _permissionRegistry.reply({
+        requestId: decodeURIComponent(permissionReplyMatch[1]),
+        reply,
+        message: body.message || '',
+      });
+      if (!ok) return jsonResponse(res, { error: 'Permission request not found' }, 404);
+      jsonResponse(res, { ok: true });
+    }).catch(e => jsonResponse(res, { error: e.message }, 500));
+    return true;
+  }
+
   const listeningHandled = handleListeningApi(req, res, url, { brain, ensureBrainInit });
   if (listeningHandled) return true;
 
@@ -4210,4 +4376,5 @@ module.exports = {
   // Test helpers
   _setReadDb,
   _setBrain,
+  _permissionRegistry,
 };