create-walle 0.9.21 → 0.9.23

package/template/wall-e/coding/prompt-bundle.js

@@ -21,10 +21,27 @@ function loadPromptText(name) {
   }
 }
 
+/**
+ * Provider/model families get a short adaptation block appended to the
+ * stable prompt bundle (opencode ships per-model prompt variants for the
+ * same reason: instruction-following failure modes differ per family).
+ * Blocks live in prompts/coding/<family>.txt and stay short — calibration
+ * heuristics, not rule lists.
+ */
+function providerPromptFamily({ provider = '', model = '' } = {}) {
+  const hay = `${provider} ${model}`.toLowerCase();
+  if (/deepseek/.test(hay)) return 'deepseek';
+  if (/openai|gpt-|codex|\bo[134](-|$)/.test(hay)) return 'gpt';
+  if (/google|gemini/.test(hay)) return 'gemini';
+  if (/ollama|mlx|lmstudio|qwen|gemma|llama|mistral|phi-/.test(hay)) return 'local';
+  return '';
+}
+
 function selectPromptFiles({ mode = 'build', provider = '', model = '' } = {}) {
   const files = ['base.txt'];
   if (mode === 'plan') files.push('plan.txt');
-  if (/deepseek/i.test(`${provider} ${model}`)) files.push('deepseek.txt');
+  const family = providerPromptFamily({ provider, model });
+  if (family) files.push(`${family}.txt`);
   return files;
 }
 
@@ -56,6 +73,7 @@ function buildPromptBundle({ body = '', mode = 'build', provider = '', model = '
 module.exports = {
   PROMPT_DIR,
   loadPromptText,
+  providerPromptFamily,
   selectPromptFiles,
   buildPromptBundle,
   buildChildScopeSection,

package/template/wall-e/coding/prompt-section-registry.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { redactPromptContent, estimateTokens } = require('./prompt-runtime');
+
+const DEFAULT_PREVIEW_CHARS = 240;
+
+class PromptSectionRegistry {
+  constructor({ provider = '', model = '', now = () => new Date().toISOString() } = {}) {
+    this.provider = provider;
+    this.model = model;
+    this.now = now;
+    this.sections = [];
+  }
+
+  add(section = {}) {
+    const normalized = normalizePromptManifestSection(section);
+    this.sections.push(normalized);
+    return normalized;
+  }
+
+  addMany(sections = []) {
+    return sections.map((section) => this.add(section));
+  }
+
+  manifest(extra = {}) {
+    return buildPromptManifest({
+      provider: extra.provider || this.provider,
+      model: extra.model || this.model,
+      sections: this.sections,
+      timestamp: extra.timestamp || this.now(),
+      metadata: extra.metadata || {},
+    });
+  }
+}
+
+function buildCodingPromptManifest({
+  systemPrompt = '',
+  userTask = '',
+  provider = '',
+  model = '',
+  runtimeMode = '',
+  tools = [],
+  promptCapabilities = null,
+  metadata = {},
+  now = () => new Date().toISOString(),
+} = {}) {
+  const registry = new PromptSectionRegistry({ provider, model, now });
+  registry.add({
+    id: 'stable.system-prompt',
+    kind: 'stable',
+    source: 'wall-e/coding-prompts.js',
+    content: systemPrompt,
+    cacheable: true,
+    metadata: { runtimeMode },
+  });
+  registry.add({
+    id: 'dynamic.user-task',
+    kind: 'dynamic',
+    source: 'user',
+    content: userTask,
+    cacheable: false,
+    redactionPolicy: 'standard',
+  });
+  registry.add({
+    id: 'dynamic.tool-catalog',
+    kind: 'dynamic',
+    source: 'tool-registry',
+    content: toolCatalogSignature(tools),
+    cacheable: false,
+    metadata: { count: Array.isArray(tools) ? tools.length : 0 },
+  });
+  if (promptCapabilities) {
+    registry.add({
+      id: 'dynamic.prompt-capabilities',
+      kind: 'dynamic',
+      source: 'prompt-capabilities',
+      content: JSON.stringify(promptCapabilities),
+      cacheable: false,
+      redactionPolicy: 'standard',
+      metadata: {
+        skills: Array.isArray(promptCapabilities.skills) ? promptCapabilities.skills.length : 0,
+        mcpTools: Array.isArray(promptCapabilities.mcp?.tools) ? promptCapabilities.mcp.tools.length : 0,
+      },
+    });
+  }
+  return registry.manifest({ metadata: { runtimeMode, ...metadata } });
+}
+
+function buildPromptManifest({ provider = '', model = '', sections = [], timestamp = new Date().toISOString(), metadata = {} } = {}) {
+  const normalized = sections.map(normalizePromptManifestSection);
+  const stableSections = normalized.filter((section) => section.kind === 'stable');
+  const dynamicSections = normalized.filter((section) => section.kind !== 'stable');
+  const manifest = {
+    promptManifestId: `prompt_${hashText(stableStringify({
+      provider,
+      model,
+      sections: normalized.map((section) => ({
+        id: section.id,
+        hash: section.hash,
+        kind: section.kind,
+      })),
+    })).slice(0, 24)}`,
+    version: 1,
+    provider: String(provider || ''),
+    model: String(model || ''),
+    timestamp,
+    stableHash: `sha256:${hashText(stableSections.map((section) => section.hash).join('\n'))}`,
+    dynamicHash: `sha256:${hashText(dynamicSections.map((section) => section.hash).join('\n'))}`,
+    stableSectionCount: stableSections.length,
+    dynamicSectionCount: dynamicSections.length,
+    tokenEstimate: normalized.reduce((sum, section) => sum + section.tokenEstimate, 0),
+    cacheBoundaryAfter: stableSections.length ? stableSections[stableSections.length - 1].id : '',
+    sections: normalized.map(stripContent),
+    metadata: safeJson(metadata),
+  };
+  return manifest;
+}
+
+function appendPromptManifest(transcript, manifest, opts = {}) {
+  if (!transcript?.appendPart || !manifest) return null;
+  return transcript.appendPart({
+    sessionId: opts.sessionId,
+    cwd: opts.cwd,
+    chatSessionId: opts.chatSessionId,
+    partType: 'prompt_manifest',
+    data: manifest,
+  });
+}
+
+function normalizePromptManifestSection(section = {}) {
+  if (!section.id) throw new Error('prompt section id is required');
+  if (section.hash && Object.prototype.hasOwnProperty.call(section, 'preview') && !Object.prototype.hasOwnProperty.call(section, 'content')) {
+    const kind = section.kind === 'stable' ? 'stable' : 'dynamic';
+    return {
+      id: String(section.id),
+      kind,
+      source: String(section.source || 'runtime'),
+      cacheable: kind === 'stable' && section.cacheable !== false,
+      visibility: String(section.visibility || 'llm'),
+      hash: String(section.hash),
+      redactedHash: String(section.redactedHash || section.hash),
+      tokenEstimate: Number.isFinite(Number(section.tokenEstimate)) ? Number(section.tokenEstimate) : 0,
+      preview: String(section.preview || ''),
+      metadata: safeJson(section.metadata || {}),
+    };
+  }
+  const content = String(section.content || '');
+  const redactionPolicy = section.redactionPolicy || section.redaction_policy || 'none';
+  const redacted = redactPromptContent(content, redactionPolicy);
+  const kind = section.kind || (section.cacheable === false ? 'dynamic' : 'stable');
+  return {
+    id: String(section.id),
+    kind: kind === 'stable' ? 'stable' : 'dynamic',
+    source: String(section.source || 'runtime'),
+    cacheable: kind === 'stable' && section.cacheable !== false,
+    visibility: String(section.visibility || 'llm'),
+    hash: `sha256:${hashText(content)}`,
+    redactedHash: `sha256:${hashText(redacted)}`,
+    tokenEstimate: Number.isFinite(Number(section.tokenEstimate))
+      ? Number(section.tokenEstimate)
+      : estimateTokens(content),
+    preview: truncate(redacted, section.previewChars || DEFAULT_PREVIEW_CHARS),
+    metadata: safeJson(section.metadata || {}),
+  };
+}
+
+function stripContent(section) {
+  const {
+    id,
+    kind,
+    source,
+    cacheable,
+    visibility,
+    hash,
+    redactedHash,
+    tokenEstimate,
+    preview,
+    metadata,
+  } = section;
+  return { id, kind, source, cacheable, visibility, hash, redactedHash, tokenEstimate, preview, metadata };
+}
+
+function toolCatalogSignature(tools = []) {
+  return (tools || []).map((tool) => {
+    const schema = tool.input_schema || tool.schema || {};
+    return stableStringify({
+      name: tool.name,
+      descriptionHash: hashText(tool.description || ''),
+      required: schema.required || [],
+      properties: Object.keys(schema.properties || {}).sort(),
+    });
+  }).join('\n');
+}
+
+function hashText(text) {
+  return crypto.createHash('sha256').update(String(text || '')).digest('hex');
+}
+
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}
+
+function safeJson(value) {
+  try {
+    return JSON.parse(JSON.stringify(value || {}));
+  } catch {
+    return {};
+  }
+}
+
+function truncate(text, max) {
+  const value = String(text || '');
+  if (!max || value.length <= max) return value;
+  return `${value.slice(0, Math.max(0, max - 24))}\n[prompt preview truncated]`;
+}
+
+module.exports = {
+  PromptSectionRegistry,
+  appendPromptManifest,
+  buildCodingPromptManifest,
+  buildPromptManifest,
+  normalizePromptManifestSection,
+  toolCatalogSignature,
+};

package/template/wall-e/coding/provider-compat.js

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+  ANTHROPIC_SAMPLING_PARAMS,
+  anthropicModelRejectsSamplingParams,
+} = require('../llm/request-compat');
+
 const DEFAULT_BODY_LIMIT = 50 * 1024 * 1024;
 
 const PROVIDER_BODY_LIMITS = Object.freeze({
@@ -16,6 +21,7 @@ const STRIPPED_REASONING_PARAMS = [
   'temperature',
   'top_p',
   'topP',
+  'top_k',
   'topK',
   'presencePenalty',
   'frequencyPenalty',
@@ -44,6 +50,15 @@ function applyProviderCompatibility(request = {}, { provider = request.provider,
     }
   }
 
+  if (pid === 'anthropic' && anthropicModelRejectsSamplingParams(mid)) {
+    for (const key of ANTHROPIC_SAMPLING_PARAMS) {
+      if (next[key] !== undefined) {
+        delete next[key];
+        warnings.push(`Removed unsupported Anthropic model parameter: ${key}.`);
+      }
+    }
+  }
+
   if (usesMaxCompletionTokens(mid, pid) && next.maxTokens !== undefined && next.max_completion_tokens === undefined) {
     next.max_completion_tokens = next.maxTokens;
     warnings.push(`Mapped maxTokens to max_completion_tokens for ${mid}.`);

package/template/wall-e/coding/runtime-events.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const RUNTIME_EVENT_TYPES = new Set([
+  'session_started',
+  'session_finished',
+  'user_prompt_submitted',
+  'prompt_built',
+  'model_stream_started',
+  'model_stream_finished',
+  'turn_started',
+  'turn_finished',
+  'tool_requested',
+  'tool_started',
+  'tool_finished',
+  'tool_failed',
+  'tool_blocked',
+  'permission_requested',
+  'permission_resolved',
+  'permission_denied',
+  'snapshot_captured',
+  'compaction_started',
+  'compaction_finished',
+  'hook_started',
+  'hook_finished',
+  'hook_failed',
+  'task_started',
+  'task_updated',
+  'task_finished',
+  'task_failed',
+  'diagnostic_recorded',
+]);
+
+const SECRET_KEY_RE = /(?:^|_|\b)(api[_-]?key|authorization|auth|cookie|credential|password|passwd|secret|token)(?:$|_|\b)/i;
+const SECRET_VALUE_RE = /\b(?:sk-[A-Za-z0-9_-]{12,}|ghp_[A-Za-z0-9_]{12,}|xox[baprs]-[A-Za-z0-9-]{12,}|AKIA[0-9A-Z]{12,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)\b/g;
+
+class RuntimeEventValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'RuntimeEventValidationError';
+  }
+}
+
+function createRuntimeEvent(input = {}, defaults = {}) {
+  const type = String(input.type || defaults.type || '').trim();
+  if (!type) throw new RuntimeEventValidationError('runtime event type is required');
+  if (!RUNTIME_EVENT_TYPES.has(type)) throw new RuntimeEventValidationError(`unknown runtime event type: ${type}`);
+
+  const sessionId = String(input.sessionId || input.session_id || defaults.sessionId || defaults.session_id || '').trim();
+  if (!sessionId) throw new RuntimeEventValidationError('runtime event sessionId is required');
+
+  const payload = redactValue(input.payload ?? input.data ?? {});
+  const redactions = collectRedactions(input.payload ?? input.data ?? {});
+  const event = {
+    id: String(input.id || input.eventId || defaults.id || newId('evt')),
+    type,
+    sessionId,
+    session_id: sessionId,
+    agentSessionId: stringOrEmpty(input.agentSessionId || input.agent_session_id || defaults.agentSessionId || defaults.agent_session_id),
+    agent_session_id: stringOrEmpty(input.agent_session_id || input.agentSessionId || defaults.agent_session_id || defaults.agentSessionId),
+    turnId: stringOrEmpty(input.turnId || input.turn_id || defaults.turnId || defaults.turn_id),
+    turn_id: stringOrEmpty(input.turn_id || input.turnId || defaults.turn_id || defaults.turnId),
+    parentEventId: stringOrEmpty(input.parentEventId || input.parent_event_id || defaults.parentEventId || defaults.parent_event_id),
+    parent_event_id: stringOrEmpty(input.parent_event_id || input.parentEventId || defaults.parent_event_id || defaults.parentEventId),
+    timestamp: String(input.timestamp || defaults.timestamp || new Date().toISOString()),
+    cwd: stringOrEmpty(input.cwd || defaults.cwd),
+    provider: stringOrEmpty(input.provider || defaults.provider),
+    model: stringOrEmpty(input.model || defaults.model),
+    actor: stringOrEmpty(input.actor || defaults.actor || 'walle'),
+    status: stringOrEmpty(input.status || defaults.status),
+    payload,
+    data: payload,
+    redactions,
+  };
+  event.hash = eventHash(event);
+  return event;
+}
+
+class RuntimeEventWriter {
+  constructor({ transcript = null, events = null, now = () => new Date().toISOString(), defaults = {} } = {}) {
+    this.transcript = transcript;
+    this.events = events;
+    this.now = now;
+    this.defaults = defaults;
+  }
+
+  emit(input = {}, defaults = {}) {
+    const event = createRuntimeEvent(input, {
+      ...this.defaults,
+      ...defaults,
+      timestamp: input.timestamp || defaults.timestamp || this.now(),
+    });
+    this._appendTranscript(event);
+    this._emitBus(event);
+    return event;
+  }
+
+  child(defaults = {}) {
+    return new RuntimeEventWriter({
+      transcript: this.transcript,
+      events: this.events,
+      now: this.now,
+      defaults: { ...this.defaults, ...defaults },
+    });
+  }
+
+  _appendTranscript(event) {
+    if (!this.transcript) return;
+    const payload = {
+      sessionId: event.sessionId,
+      cwd: event.cwd,
+      partType: 'runtime_event',
+      data: {
+        kind: 'event',
+        eventId: event.id,
+        type: event.type,
+        name: event.type,
+        status: event.status || 'recorded',
+        threadId: event.agentSessionId || event.sessionId,
+        turnId: event.turnId,
+        parentItemId: event.parentEventId,
+        provider: event.provider,
+        model: event.model,
+        provenance: 'live',
+        data: event.payload,
+        redactions: event.redactions,
+        hash: event.hash,
+      },
+    };
+    try {
+      if (this.transcript.appendRuntimeEvent) {
+        this.transcript.appendRuntimeEvent(payload.data, payload);
+      } else if (this.transcript.appendPart) {
+        this.transcript.appendPart(payload);
+      }
+    } catch (err) {
+      this._emitBus(createRuntimeEvent({
+        ...event,
+        type: 'diagnostic_recorded',
+        payload: {
+          source: 'runtime_event_writer',
+          message: `Failed to append runtime event: ${err.message}`,
+          eventType: event.type,
+        },
+      }));
+    }
+  }
+
+  _emitBus(event) {
+    if (!this.events?.emit) return;
+    try {
+      this.events.emit('runtime.event', event);
+      this.events.emit(`runtime.${event.type}`, event);
+    } catch {}
+  }
+}
+
+function redactValue(value, path = [], redactions = []) {
+  if (value == null) return value;
+  if (typeof value === 'string') {
+    const redacted = value.replace(SECRET_VALUE_RE, '[REDACTED]');
+    if (redacted !== value) redactions.push(path.join('.') || '$');
+    return redacted;
+  }
+  if (typeof value !== 'object') return value;
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactValue(item, [...path, String(index)], redactions));
+  }
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const childPath = [...path, key];
+    if (SECRET_KEY_RE.test(key)) {
+      out[key] = '[REDACTED]';
+      redactions.push(childPath.join('.'));
+      continue;
+    }
+    out[key] = redactValue(raw, childPath, redactions);
+  }
+  return out;
+}
+
+function collectRedactions(value) {
+  const redactions = [];
+  redactValue(value, [], redactions);
+  return [...new Set(redactions)];
+}
+
+function eventHash(event) {
+  const stable = {
+    type: event.type,
+    sessionId: event.sessionId,
+    agentSessionId: event.agentSessionId,
+    turnId: event.turnId,
+    parentEventId: event.parentEventId,
+    timestamp: event.timestamp,
+    actor: event.actor,
+    payload: event.payload,
+  };
+  return `sha256:${crypto.createHash('sha256').update(stableStringify(stable)).digest('hex')}`;
+}
+
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}
+
+function newId(prefix) {
+  return `${prefix}_${crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex')}`;
+}
+
+function stringOrEmpty(value) {
+  return value == null ? '' : String(value);
+}
+
+module.exports = {
+  RUNTIME_EVENT_TYPES,
+  RuntimeEventValidationError,
+  RuntimeEventWriter,
+  createRuntimeEvent,
+  redactValue,
+  stableStringify,
+};

package/template/wall-e/coding/runtime-mode.js

@@ -18,6 +18,9 @@ const COORDINATION_TOOL_NAMES = new Set([
   'update_todos',
   'ask_user',
   'run_shell',
+  'check_url',
+  'start_static_server',
+  'stop_static_server',
   'mcp_call',
   'skill',
 ]);