create-walle 0.9.11 → 0.9.13

package/template/wall-e/hooks/session-memory.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+
+const { createSessionIngestService } = require('../memory/session-ingest-service');
+const { collectIngestRecords } = require('../sources/base');
+const { ensureBuiltinSourceAdapters } = require('../sources/builtin');
+const sourceRegistry = require('../sources/registry');
+
+const SAVE_INTERVAL = 15;
+const SUPPORTED_HARNESSES = new Set(['claude-code', 'codex', 'walle']);
+
+function getHookStateDir() {
+  return process.env.WALL_E_HOOK_STATE_DIR || path.join(os.homedir(), '.walle', 'hook_state');
+}
+
+function parseHarnessInput(data = {}, harness = 'walle') {
+  if (!SUPPORTED_HARNESSES.has(harness)) throw new Error(`Unsupported harness: ${harness}`);
+  const transcriptPath = data.transcript_path
+    || data.transcriptPath
+    || data.transcript
+    || data.session_file
+    || data.sessionFile
+    || data.path
+    || data.file
+    || '';
+  const cwd = data.cwd || data.workspace || data.project_dir || data.projectDir || '';
+  return {
+    harness,
+    transcriptPath,
+    cwd,
+    sessionId: data.session_id || data.sessionId || data.id || '',
+    stopHookActive: Boolean(data.stop_hook_active || data.stopHookActive),
+  };
+}
+
+function validateTranscriptPath(transcriptPath) {
+  if (!transcriptPath || typeof transcriptPath !== 'string') {
+    throw new Error('transcript path is required');
+  }
+  if (transcriptPath.split(/[\\/]+/).includes('..')) {
+    throw new Error('transcript path must not contain traversal segments');
+  }
+  if (!transcriptPath.endsWith('.jsonl')) {
+    throw new Error('transcript path must end in .jsonl');
+  }
+  return path.resolve(transcriptPath);
+}
+
+function adapterIdForHarness(harness, transcriptPath = '') {
+  if (harness === 'codex') return 'codex-jsonl';
+  if (harness === 'claude-code') return 'claude-code-jsonl';
+  if (harness === 'walle') return 'walle-jsonl';
+  if (transcriptPath.includes(`${path.sep}.codex${path.sep}`)) return 'codex-jsonl';
+  if (transcriptPath.includes(`${path.sep}.claude${path.sep}`)) return 'claude-code-jsonl';
+  return 'walle-jsonl';
+}
+
+function sourceRefFromHarness(data = {}, harness = 'walle') {
+  const parsed = parseHarnessInput(data, harness);
+  const sourceFile = validateTranscriptPath(parsed.transcriptPath);
+  const adapterId = adapterIdForHarness(parsed.harness, sourceFile);
+  return {
+    adapterId,
+    uri: sourceFile,
+    sourceFile,
+    sourceId: parsed.sessionId ? `${adapterId}:${parsed.sessionId}` : undefined,
+    cwd: parsed.cwd,
+    metadata: { harness: parsed.harness },
+  };
+}
+
+async function countHumanMessages(sourceRef) {
+  ensureBuiltinSourceAdapters();
+  const adapter = sourceRegistry.instantiate(sourceRef.adapterId);
+  if (!adapter) throw new Error(`Unknown source adapter: ${sourceRef.adapterId}`);
+  const { records } = await collectIngestRecords(adapter, sourceRef);
+  return records.filter((record) => record.type === 'memory_record' && record.role === 'user').length;
+}
+
+function readState(sourceRef) {
+  const statePath = stateFilePath(sourceRef);
+  try {
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return { lastHumanCount: 0 };
+  }
+}
+
+function writeState(sourceRef, state) {
+  const statePath = stateFilePath(sourceRef);
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, JSON.stringify({ ...state, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+async function handleSessionStart(data = {}, { harness = 'walle' } = {}) {
+  const sourceRef = sourceRefFromHarness(data, harness);
+  writeState(sourceRef, { lastHumanCount: 0, sourceRef });
+  return { ok: true, action: 'session_start', sourceRef };
+}
+
+async function handleStop(data = {}, {
+  harness = 'walle',
+  saveInterval = SAVE_INTERVAL,
+  service = null,
+  background = false,
+} = {}) {
+  const parsed = parseHarnessInput(data, harness);
+  if (parsed.stopHookActive) return { ok: true, action: 'skip_active_stop_hook' };
+  const sourceRef = sourceRefFromHarness(data, harness);
+  const humanCount = await countHumanMessages(sourceRef);
+  const state = readState(sourceRef);
+  const sinceLast = humanCount - Number(state.lastHumanCount || 0);
+  if (humanCount === 0 || sinceLast < saveInterval) {
+    return { ok: true, action: 'skip_interval', humanCount, sinceLast, sourceRef };
+  }
+
+  writeState(sourceRef, { ...state, lastHumanCount: humanCount, sourceRef });
+  if (background && !service) {
+    const spawned = spawnBackgroundIngest(sourceRef);
+    return { ok: true, action: 'background_ingest', humanCount, sinceLast, pid: spawned.pid, sourceRef };
+  }
+  const ingest = await runLockedIngest(sourceRef, { service });
+  return { ok: true, action: 'ingested', humanCount, sinceLast, ingest, sourceRef };
+}
+
+async function handlePrecompact(data = {}, { harness = 'walle', service = null } = {}) {
+  const sourceRef = sourceRefFromHarness(data, harness);
+  const ingest = await runLockedIngest(sourceRef, { service });
+  return { ok: true, action: 'precompact_ingested', ingest, sourceRef };
+}
+
+async function runLockedIngest(sourceRef, { service = null, dryRun = false } = {}) {
+  const release = acquireLock(sourceRef);
+  if (!release.acquired) return { skipped: true, reason: 'lock_exists', lockPath: release.lockPath };
+  try {
+    const ingestService = service || createSessionIngestService();
+    return await ingestService.ingestSource(sourceRef, { dryRun });
+  } finally {
+    release();
+  }
+}
+
+function spawnBackgroundIngest(sourceRef) {
+  const cli = path.join(__dirname, 'cli.js');
+  const child = spawn(process.execPath, [
+    cli,
+    'ingest-file',
+    '--adapter',
+    sourceRef.adapterId,
+    '--file',
+    sourceRef.sourceFile,
+    '--source-id',
+    sourceRef.sourceId || '',
+    '--cwd',
+    sourceRef.cwd || '',
+  ], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  return child;
+}
+
+function acquireLock(sourceRef) {
+  const lockPath = lockFilePath(sourceRef);
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  let fd = null;
+  try {
+    fd = fs.openSync(lockPath, 'wx');
+    fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString(), sourceRef }));
+  } catch (err) {
+    if (err.code === 'EEXIST') {
+      const skipped = () => false;
+      skipped.acquired = false;
+      skipped.lockPath = lockPath;
+      return skipped;
+    }
+    throw err;
+  } finally {
+    if (fd != null) fs.closeSync(fd);
+  }
+  const release = () => {
+    try { fs.unlinkSync(lockPath); } catch {}
+    return true;
+  };
+  release.acquired = true;
+  release.lockPath = lockPath;
+  return release;
+}
+
+function stateFilePath(sourceRef) {
+  return path.join(getHookStateDir(), `${hashSource(sourceRef)}.json`);
+}
+
+function lockFilePath(sourceRef) {
+  return path.join(getHookStateDir(), `${hashSource(sourceRef)}.lock`);
+}
+
+function hashSource(sourceRef) {
+  return crypto.createHash('sha256')
+    .update(`${sourceRef.adapterId}:${sourceRef.sourceFile || sourceRef.uri || sourceRef.sourceId}`)
+    .digest('hex')
+    .slice(0, 24);
+}
+
+module.exports = {
+  SAVE_INTERVAL,
+  SUPPORTED_HARNESSES,
+  acquireLock,
+  adapterIdForHarness,
+  countHumanMessages,
+  getHookStateDir,
+  handlePrecompact,
+  handleSessionStart,
+  handleStop,
+  parseHarnessInput,
+  runLockedIngest,
+  sourceRefFromHarness,
+  validateTranscriptPath,
+};

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

@@ -1,10 +1,14 @@
 'use strict';
 
-// Public routes are intentionally limited to webhook ingestion. Everything else
-// must come from localhost or present a shared bearer token.
+// Public routes are intentionally limited to external ingress. Telemetry admin
+// routes are public only at this outer gate; api-walle enforces
+// WALLE_TELEMETRY_SECRET before returning any data.
 const PUBLIC_ROUTES = new Set([
   '/api/wall-e/health',
   '/api/wall-e/webhook',
+  '/api/wall-e/telemetry/ingest',
+  '/api/wall-e/telemetry/summary',
+  '/api/wall-e/telemetry/events',
 ]);
 
 function getAllowedOrigin(req) {

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

@@ -47,9 +47,17 @@ function buildSmartRoutingCandidates(brain, opts = {}) {
   }
 
   const currentProvider = String(opts.currentProvider || '').toLowerCase();
+  const currentModel = String(opts.currentModel || '').toLowerCase();
   const providerOrder = [currentProvider, 'openai', 'google', 'deepseek', 'anthropic', 'ollama', 'mlx']
     .filter(Boolean)
     .filter((value, idx, arr) => arr.indexOf(value) === idx);
+  let providerHealth = null;
+  try {
+    const { default: providerAvailability } = require('../llm/provider-availability');
+    providerHealth = new Map(
+      providerAvailability.getConfiguredProviders().map((provider) => [provider.providerId, provider]),
+    );
+  } catch {}
 
   const candidates = [];
   const rows = brain.listAllModels() || [];
@@ -57,9 +65,12 @@ function buildSmartRoutingCandidates(brain, opts = {}) {
     if (!model || model.enabled === 0 || model.enabled === false) continue;
     const provider = brain.getModelProvider(model.provider_id);
     if (!providerHasRuntimeAccess(provider)) continue;
+    const providerId = provider.id || model.provider_id;
+    if (providerHealth?.get(providerId)?.status === 'unhealthy') continue;
     candidates.push({
       registryId: model.id,
       providerType: String(provider.type || model.provider_type || '').toLowerCase(),
+      providerId,
       modelId: model.model_id,
       displayName: model.display_name,
       speedTier: model.speed_tier == null ? 3 : Number(model.speed_tier),
@@ -88,11 +99,24 @@ function buildSmartRoutingCandidates(brain, opts = {}) {
   }
 
   if (opts.includeAutoFirst) {
+    const isCurrentModel = (candidate) => {
+      if (!currentModel) return false;
+      return String(candidate.modelId || '').toLowerCase() === currentModel
+        || String(candidate.registryId || '').toLowerCase() === currentModel;
+    };
+    const sameProviderAlternative = currentProvider && currentModel
+      ? candidates.find((candidate) => candidate.providerType === currentProvider && !isCurrentModel(candidate))
+      : null;
     const alternatives = selected
+      .filter((candidate) => !sameProviderAlternative || candidate.registryId !== sameProviderAlternative.registryId)
       .filter((candidate) => !currentProvider || candidate.providerType !== currentProvider)
       .map((candidate) => candidate.registryId)
       .filter(Boolean);
-    return alternatives.length > 0 ? [null, ...alternatives.slice(0, 5)] : [];
+    const ordered = [
+      sameProviderAlternative?.registryId,
+      ...alternatives,
+    ].filter(Boolean);
+    return ordered.length > 0 ? [null, ...ordered.slice(0, 5)] : [];
   }
 
   return selected.map((candidate) => candidate.registryId).filter(Boolean).slice(0, 6);
@@ -114,9 +138,11 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
       let requestFinished = false;
       try {
         const abortController = new AbortController();
-        res.on('close', () => {
-          if (!requestFinished) abortController.abort();
-        });
+        if (typeof res.on === 'function') {
+          res.on('close', () => {
+            if (!requestFinished) abortController.abort();
+          });
+        }
         const chatModule = require('../chat');
         // Validate + parse attachments before invoking chat. The validator
         // throws AttachmentError with .code + .status so we can surface 4xx
@@ -198,10 +224,19 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
         const shouldSmartFallback = !body.model && parsedAttachments.length === 0;
         if (shouldSmartFallback) {
           try {
-            const { getDefaultProviderType } = require('../llm/client');
-            const currentProvider = body.provider || getDefaultProviderType();
+            const { getDefaultModel, getDefaultProviderType } = require('../llm/client');
+            const currentProvider = body.provider
+              || brain.getKv?.('walle_provider')
+              || process.env.WALLE_PROVIDER
+              || getDefaultProviderType();
+            const currentModel = body.model
+              || brain.getKv?.('walle_model')
+              || brain.getKv?.('walle_model_' + currentProvider)
+              || process.env.WALLE_MODEL
+              || getDefaultModel();
             const candidates = buildSmartRoutingCandidates(brain, {
               currentProvider,
+              currentModel,
               includeAutoFirst: true,
             });
             if (candidates.length > 1) {
@@ -241,11 +276,22 @@ function handleWalleChatApi(req, res, url, { brain, ensureBrainInit }) {
       } catch (err) {
         requestFinished = true;
         try { require('../telemetry').trackError('chat-api', err); } catch {}
+        const isProviderError = err && (err.code === 'AI_PROVIDER_ERROR' || err.providerError);
+        const providerPayload = isProviderError
+          ? require('../llm/provider-error').toApiPayload(err)
+          : null;
         if (wantsStream) {
-          try { res.write('data: ' + JSON.stringify({ type: 'error', error: err.message }) + '\n\n'); } catch {}
+          try {
+            res.write('data: ' + JSON.stringify({
+              type: 'error',
+              error: providerPayload ? providerPayload.message : err.message,
+              ...(providerPayload || {}),
+            }) + '\n\n');
+          } catch {}
           try { res.end(); } catch {}
         } else {
-          jsonResponse(res, { error: err.message }, 500);
+          const status = providerPayload?.providerError?.status || err.status || 500;
+          jsonResponse(res, providerPayload || { error: err.message }, status);
         }
       }
     }).catch(e => {

package/template/wall-e/integrations/claude-plugin/hooks/hooks.json

@@ -0,0 +1,27 @@
+{
+  "description": "Wall-E session memory hooks",
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/walle-stop-hook.sh"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/walle-precompact-hook.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/template/wall-e/integrations/claude-plugin/hooks/walle-precompact-hook.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="${WALL_E_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../.." && pwd)}"
+exec node "$ROOT/wall-e/hooks/cli.js" precompact --harness claude-code

package/template/wall-e/integrations/claude-plugin/hooks/walle-stop-hook.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="${WALL_E_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../.." && pwd)}"
+exec node "$ROOT/wall-e/hooks/cli.js" stop --harness claude-code

package/template/wall-e/integrations/codex-plugin/hooks/walle-hook.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="${WALL_E_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../.." && pwd)}"
+HOOK_NAME="${1:-stop}"
+
+exec node "$ROOT/wall-e/hooks/cli.js" "$HOOK_NAME" --harness codex

package/template/wall-e/integrations/codex-plugin/hooks.json

@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CODEX_PLUGIN_ROOT}/hooks/walle-hook.sh session-start"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CODEX_PLUGIN_ROOT}/hooks/walle-hook.sh stop"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CODEX_PLUGIN_ROOT}/hooks/walle-hook.sh precompact"
+          }
+        ]
+      }
+    ]
+  }
+}

package/template/wall-e/listening/calendar.js

@@ -6,6 +6,7 @@ const { execFileSync } = require('child_process');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
 const brain = require('../brain');
+const { createSafeFetch } = require('../security/ssrf');
 
 const CAL_READER = path.join(__dirname, '..', 'skills', '_bundled', 'google-calendar', 'cal-reader');
 
@@ -200,7 +201,8 @@ function _readEventKit(hoursAhead) {
  * @returns {Promise<Array<{uid, title, start, end, attendees, location}>>}
  */
 async function _readICS(url, hoursAhead) {
-  const resp = await fetch(url, { signal: AbortSignal.timeout(15000) });
+  const safeFetch = createSafeFetch({ fetchImpl: globalThis.fetch });
+  const resp = await safeFetch(url, { signal: AbortSignal.timeout(15000) });
   if (!resp.ok) throw new Error('ICS fetch failed: ' + resp.status);
   const text = await resp.text();
 

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

@@ -23,7 +23,20 @@ function createClient(type, config = {}) {
   if (!provider) {
     throw new Error(`Unknown provider type: ${type}`);
   }
-  return provider;
+  return withStreamFallback(provider);
+}
+
+function withStreamFallback(provider) {
+  if (!provider || typeof provider.chat !== 'function' || typeof provider.chatStream === 'function') {
+    return provider;
+  }
+  return {
+    ...provider,
+    async *chatStream(opts = {}) {
+      const { streamFromChat } = require('../coding/stream-processor');
+      yield* streamFromChat(provider, opts);
+    },
+  };
 }
 
 // ============================================================
@@ -33,28 +46,60 @@ function createClient(type, config = {}) {
 let _defaultClient = null;
 
 function getDefaultProviderType() {
-  // Check brain DB first (set by setup page), fall back to env
+  // Setup persists to .env and mirrors to process.env for the running daemon.
+  if (process.env.WALLE_PROVIDER) return process.env.WALLE_PROVIDER.toLowerCase();
+  // Fall back to Wall-E's kv_store for older/live setup writes.
   try {
     const brain = require('../brain');
-    const val = brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'walle_provider'").get()?.value;
+    const val = typeof brain.getKv === 'function'
+      ? brain.getKv('walle_provider')
+      : brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'walle_provider'").get()?.value;
     if (val) return val.toLowerCase();
   } catch {}
-  return (process.env.WALLE_PROVIDER || 'anthropic').toLowerCase();
+  return 'anthropic';
 }
 
 function getDefaultModel() {
   providerRegistry.ensureBootstrapped();
   const providerType = getDefaultProviderType();
-  // Check brain DB first, fall back to env
+  if (process.env.WALLE_MODEL && _modelMatchesProvider(process.env.WALLE_MODEL, providerType)) return process.env.WALLE_MODEL;
   try {
     const brain = require('../brain');
-    const val = brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'walle_model'").get()?.value;
+    const val = typeof brain.getKv === 'function'
+      ? brain.getKv('walle_model')
+      : brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'walle_model'").get()?.value;
     if (val && _modelMatchesProvider(val, providerType)) return val;
   } catch {}
-  if (process.env.WALLE_MODEL && _modelMatchesProvider(process.env.WALLE_MODEL, providerType)) return process.env.WALLE_MODEL;
+  return getDefaultModelForProvider(providerType);
+}
+
+function getDefaultModelForProvider(providerType) {
+  providerRegistry.ensureBootstrapped();
   return providerRegistry.getDefaultModel(providerType) || providerRegistry.getDefaultModel('anthropic');
 }
 
+function getDefaultAuthMethod(providerType) {
+  const type = (providerType || getDefaultProviderType()).toLowerCase();
+  try {
+    const brain = require('../brain');
+    const dbMethod = typeof brain.getProviderAuthMethod === 'function'
+      ? brain.getProviderAuthMethod(type)
+      : null;
+    if (dbMethod) return dbMethod;
+  } catch {}
+  if (type === 'anthropic' || type === 'openai') {
+    return process.env.WALLE_AUTH_METHOD || '';
+  }
+  return '';
+}
+
+function resolveCompatibleModel(model, providerType) {
+  providerRegistry.ensureBootstrapped();
+  const targetProvider = providerType || getDefaultProviderType();
+  if (model && _modelMatchesProvider(model, targetProvider)) return model;
+  return getDefaultModelForProvider(targetProvider);
+}
+
 /**
  * Guard against model-provider mismatch. Delegates to the registry's
  * manifest-driven prefix matching (replaces the old hardcoded
@@ -74,11 +119,12 @@ function getDefaultClient() {
     providerRegistry.ensureBootstrapped();
     const providerType = getDefaultProviderType();
     const dbKey = _getProviderKeyFromDb(providerType);
+    const authMethod = getDefaultAuthMethod(providerType);
 
     // Anthropic auth_method=claude_cli routes through the user's `claude`
     // CLI (subscription billing) instead of the SDK against api.anthropic.com.
     // Other providers ignore this — claude_cli only makes sense for Claude.
-    if (providerType === 'anthropic' && process.env.WALLE_AUTH_METHOD === 'claude_cli') {
+    if (providerType === 'anthropic' && authMethod === 'claude_cli') {
       _defaultClient = createClient('claude-cli', {});
       return _defaultClient;
     }
@@ -88,7 +134,7 @@ function getDefaultClient() {
     // forwards requests with the user's claude.ai OAuth Bearer token. We
     // pass an empty placeholder apiKey; the proxy ignores it and replaces
     // auth headers with its own.
-    if (providerType === 'anthropic' && process.env.WALLE_AUTH_METHOD === 'oauth_proxy') {
+    if (providerType === 'anthropic' && authMethod === 'oauth_proxy') {
       const port = process.env.OAUTH_PROXY_PORT || '3458';
       _defaultClient = createClient('anthropic', {
         apiKey: 'oauth-proxy-placeholder',
@@ -100,7 +146,7 @@ function getDefaultClient() {
     // OpenAI auth_method=codex_cli routes through the user's `codex` CLI
     // (ChatGPT subscription billing) instead of api.openai.com. Mirrors the
     // Anthropic claude_cli path but with codex-cli as the underlying provider.
-    if (providerType === 'openai' && process.env.WALLE_AUTH_METHOD === 'codex_cli') {
+    if (providerType === 'openai' && authMethod === 'codex_cli') {
       _defaultClient = createClient('codex-cli', {});
       return _defaultClient;
     }
@@ -158,9 +204,13 @@ function resetDefaultClient() {
 
 module.exports = {
   createClient,
+  withStreamFallback,
   getDefaultClient,
   getDefaultProviderType,
+  getDefaultAuthMethod,
   getDefaultModel,
+  getDefaultModelForProvider,
+  resolveCompatibleModel,
   resetDefaultClient,
   DEFAULT_TIER_MODELS,
   // Re-exported for callers that want to introspect the manifest
@@ -169,4 +219,8 @@ module.exports = {
     providerRegistry.ensureBootstrapped();
     return providerRegistry.detectProviderForModel(model);
   },
+  modelMatchesProvider: (model, provider) => {
+    providerRegistry.ensureBootstrapped();
+    return providerRegistry.modelMatchesProvider(model, provider);
+  },
 };