create-walle 0.9.21 → 0.9.23

package/template/wall-e/lib/boot-profile.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * Lightweight boot/phase profiler. Records labeled wall-clock durations so we can
+ * SEE where Wall-E startup time actually goes (brain open, migrations, WAL pragma,
+ * backfills, bootstrap, channel/scheduler setup, port bind) instead of guessing.
+ *
+ * Usage:
+ *   const boot = require('./lib/boot-profile');
+ *   boot.reset();
+ *   boot.measure('brain.initDb', () => brain.initDb());
+ *   await boot.measureAsync('backfill', () => brain.backfillTemporalValidity());
+ *   boot.mark('startServer', msSpent);
+ *   boot.done(); console.log(boot.summary());
+ *
+ * The captured profile is process-global (last boot) and exposed read-only via
+ * getProfile() — surfaced at GET /api/wall-e/boot-profile.
+ */
+
+const { performance } = require('perf_hooks');
+
+let _profile = null;
+
+function reset() {
+  _profile = { startedAt: performance.now(), startedIso: new Date().toISOString(), marks: [], totalMs: null };
+  return _profile;
+}
+
+function _ensure() {
+  if (!_profile) reset();
+  return _profile;
+}
+
+// Record a phase that took `ms` milliseconds. `meta` is optional structured detail.
+function mark(label, ms, meta) {
+  const p = _ensure();
+  const entry = { label, ms: Math.round(ms), atMs: Math.round(performance.now() - p.startedAt) };
+  if (meta && typeof meta === 'object') entry.meta = meta;
+  p.marks.push(entry);
+  return entry;
+}
+
+// Time a synchronous function, record under `label`, return its result.
+function measure(label, fn, meta) {
+  const t0 = performance.now();
+  try {
+    return fn();
+  } finally {
+    mark(label, performance.now() - t0, meta);
+  }
+}
+
+// Time an async function, record under `label`, return its (awaited) result.
+async function measureAsync(label, fn, meta) {
+  const t0 = performance.now();
+  try {
+    return await fn();
+  } finally {
+    mark(label, performance.now() - t0, meta);
+  }
+}
+
+// Stamp total elapsed since reset(). Call when boot reaches "ready".
+function done() {
+  const p = _ensure();
+  p.totalMs = Math.round(performance.now() - p.startedAt);
+  return getProfile();
+}
+
+function getProfile() {
+  if (!_profile) return null;
+  return {
+    startedIso: _profile.startedIso,
+    totalMs: _profile.totalMs,
+    marks: _profile.marks.map((m) => ({ ...m })),
+  };
+}
+
+// Human-readable summary, slowest phases first, for the boot log.
+function summary() {
+  if (!_profile || _profile.marks.length === 0) return '[boot-profile] (no marks)';
+  const sorted = [..._profile.marks].sort((a, b) => b.ms - a.ms);
+  const lines = sorted.map((m) => `  ${String(m.ms).padStart(7)}ms  ${m.label}`);
+  const total = _profile.totalMs != null ? `${_profile.totalMs}ms` : '(open)';
+  return `[boot-profile] total=${total}, phases (slowest first):\n${lines.join('\n')}`;
+}
+
+module.exports = { reset, mark, measure, measureAsync, done, getProfile, summary };

package/template/wall-e/lib/event-loop-monitor.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Event-loop delay monitor.
+//
+// Wall-E is single-threaded and uses synchronous better-sqlite3, so a heavy query can
+// block the whole event loop (HTTP included) for seconds. When that happens the daemon
+// looks "running" to a supervisor while every request times out — exactly the failure
+// that hid a multi-minute backfill stall. There was no signal for it.
+//
+// This wraps perf_hooks.monitorEventLoopDelay (a libuv-level histogram of how late timers
+// fire vs. schedule — i.e. how long the loop was blocked) and:
+//   - logs a warning whenever a single blocking spell in the window exceeds a threshold,
+//   - tracks the worst spell seen since boot,
+//   - exposes a cheap stats snapshot for a health endpoint.
+//
+// All timers are unref'd so the monitor never keeps the process alive.
+
+const { monitorEventLoopDelay } = require('perf_hooks');
+
+let _histogram = null;
+let _timer = null;
+let _peakMs = 0;
+let _lastWarn = null;
+let _onWarn = null;
+
+const NS_PER_MS = 1e6;
+const _ms = (ns) => Math.round((Number(ns) || 0) / NS_PER_MS);
+
+function isRunning() {
+  return _histogram != null;
+}
+
+/**
+ * Start monitoring. Idempotent.
+ * @param {object} opts
+ * @param {number} [opts.resolutionMs=20]      sampling resolution
+ * @param {number} [opts.sampleMs=10000]       how often to evaluate + reset the window
+ * @param {number} [opts.warnThresholdMs=1000] warn if the worst spell in a window exceeds this
+ * @param {function} [opts.onWarn]             called as ({ maxMs, meanMs, p99Ms }) on a warning
+ * @param {function} [opts.log=console.warn]   where warnings are written
+ */
+function start(opts = {}) {
+  if (_histogram) return; // already running
+  const resolution = Math.max(1, Number(opts.resolutionMs) || 20);
+  const sampleMs = Math.max(1000, Number(opts.sampleMs) || 10000);
+  const warnThresholdMs = Math.max(50, Number(opts.warnThresholdMs) || 1000);
+  const log = typeof opts.log === 'function' ? opts.log : console.warn;
+  _onWarn = typeof opts.onWarn === 'function' ? opts.onWarn : null;
+
+  _histogram = monitorEventLoopDelay({ resolution });
+  _histogram.enable();
+
+  _timer = setInterval(() => {
+    const maxMs = _ms(_histogram.max);
+    const meanMs = _ms(_histogram.mean);
+    let p99Ms = 0;
+    try { p99Ms = _ms(_histogram.percentile(99)); } catch { /* histogram may be empty */ }
+    if (maxMs > _peakMs) _peakMs = maxMs;
+
+    if (maxMs >= warnThresholdMs) {
+      _lastWarn = { at: new Date().toISOString(), maxMs, meanMs, p99Ms };
+      log(`[wall-e] event loop blocked up to ${maxMs}ms in the last ${Math.round(sampleMs / 1000)}s (mean ${meanMs}ms, p99 ${p99Ms}ms) — a synchronous DB query or sync I/O is starving the loop`);
+      if (_onWarn) { try { _onWarn({ maxMs, meanMs, p99Ms }); } catch { /* never let a hook break the monitor */ } }
+    }
+    _histogram.reset();
+  }, sampleMs);
+  _timer.unref?.();
+}
+
+/** Cheap snapshot for a health endpoint. Safe to call when not running. */
+function stats() {
+  if (!_histogram) return { enabled: false };
+  let p99Ms = 0;
+  try { p99Ms = _ms(_histogram.percentile(99)); } catch { /* empty */ }
+  return {
+    enabled: true,
+    // Current window (reset every sampleMs):
+    mean_ms: _ms(_histogram.mean),
+    max_ms: _ms(_histogram.max),
+    p99_ms: p99Ms,
+    // Worst spell since boot, and the last threshold breach:
+    peak_ms: _peakMs,
+    last_warning: _lastWarn,
+  };
+}
+
+function stop() {
+  if (_timer) { clearInterval(_timer); _timer = null; }
+  if (_histogram) { try { _histogram.disable(); } catch {} _histogram = null; }
+  _onWarn = null;
+}
+
+module.exports = { start, stop, stats, isRunning };

package/template/wall-e/lib/service-health.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const TRANSIENT_PROVIDER_ISSUE_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+
+function asTime(value) {
+  const t = value ? Date.parse(value) : NaN;
+  return Number.isFinite(t) ? t : 0;
+}
+
+function normalizedProviderIssue(alert) {
+  if (!alert || typeof alert !== 'object') return null;
+  const issue = alert.providerError || alert.provider_error || {};
+  const type = String(issue.type || alert.type || '').toLowerCase();
+  const service = String(alert.service || '').toLowerCase();
+  const looksProvider = service === 'ai_provider' || type.startsWith('ai_provider') || !!alert.provider || !!issue.provider;
+  if (!looksProvider) return null;
+  return {
+    id: alert.id || '',
+    type: issue.type || alert.type || 'provider_error',
+    severity: issue.severity || alert.severity || 'error',
+    title: issue.title || alert.title || 'AI provider issue',
+    message: issue.userMessage || issue.message || alert.message || 'Wall-E could not get a provider response.',
+    provider: issue.provider || alert.provider || '',
+    model: issue.model || alert.model || '',
+    status: issue.status || alert.status || '',
+    rawMessage: issue.rawMessage || issue.raw_message || alert.rawMessage || '',
+    actionUrl: issue.actionUrl || issue.action_url || alert.action_url || '/setup.html',
+    actionLabel: issue.actionLabel || issue.action_label || alert.action_label || 'Open Setup',
+    created_at: alert.created_at || issue.createdAt || issue.created_at || '',
+  };
+}
+
+function providerMatches(issue, activeProvider, activeModel) {
+  if (!issue) return false;
+  const provider = String(issue.provider || '').toLowerCase();
+  const model = String(issue.model || '').toLowerCase();
+  const ap = String(activeProvider || '').toLowerCase();
+  const am = String(activeModel || '').toLowerCase();
+  if (ap && provider && provider === ap) return true;
+  if (am && model && model === am) return true;
+  return !ap && !am;
+}
+
+function isStickyProviderIssue(issue) {
+  const text = `${issue.type || ''} ${issue.title || ''} ${issue.message || ''}`.toLowerCase();
+  return /auth|quota|billing|credit|insufficient|invalid|forbidden|unauthorized|permission/.test(text);
+}
+
+function isCurrentProviderIssue(issue, opts, nowMs) {
+  if (!providerMatches(issue, opts.activeProvider, opts.activeModel)) return false;
+  if (isStickyProviderIssue(issue)) return true;
+  const created = asTime(issue.created_at);
+  if (!created) return true;
+  return nowMs - created <= (opts.transientProviderMaxAgeMs || TRANSIENT_PROVIDER_ISSUE_MAX_AGE_MS);
+}
+
+function skillNameFromAlert(alert) {
+  if (!alert) return '';
+  if (alert.skill) return String(alert.skill);
+  const service = String(alert.service || '');
+  if (service && service !== 'ai_provider' && service !== 'system') return service;
+  const msg = String(alert.message || '');
+  const quoted = msg.match(/Skill\s+"([^"]+)"/i);
+  if (quoted) return quoted[1];
+  const named = msg.match(/Skill\s+([A-Za-z0-9_.-]+)/i);
+  return named ? named[1] : '';
+}
+
+function isDisabledSkillAlert(alert) {
+  return !!alert && String(alert.type || '').toLowerCase() === 'skill_disabled';
+}
+
+function isIntegrationAlert(alert) {
+  if (!alert || isDisabledSkillAlert(alert)) return false;
+  const type = String(alert.type || '').toLowerCase();
+  const action = String(alert.action || '').toLowerCase();
+  const text = [alert.service, alert.message, alert.integration].filter(Boolean).join(' ').toLowerCase();
+  if (action === 'gws_reauth' || action === 'repair_slack_owner') return true;
+  if (type === 'auth_expired' || type === 'owner_identity_missing') return true;
+  return /(slack|gws|google|gmail|calendar|drive|oauth)/.test(text)
+    && /(auth|reauth|reconnect|expired|token|owner)/.test(text);
+}
+
+function publicAlert(alert) {
+  return {
+    id: alert.id || '',
+    service: alert.service || '',
+    type: alert.type || '',
+    title: alert.title || '',
+    message: alert.message || '',
+    severity: alert.severity || '',
+    action: alert.action || '',
+    action_label: alert.action_label || '',
+    action_url: alert.action_url || '',
+    created_at: alert.created_at || '',
+  };
+}
+
+function summarizeProviderIssue(issue, nowMs) {
+  const created = asTime(issue.created_at);
+  return {
+    id: issue.id,
+    type: issue.type,
+    severity: issue.severity,
+    title: issue.title,
+    message: issue.message,
+    provider: issue.provider,
+    model: issue.model,
+    status: issue.status,
+    action_url: issue.actionUrl,
+    action_label: issue.actionLabel,
+    created_at: issue.created_at,
+    age_ms: created ? Math.max(0, nowMs - created) : null,
+  };
+}
+
+function buildServiceHealth(alerts, options = {}) {
+  const list = Array.isArray(alerts) ? alerts.filter(Boolean) : [];
+  const nowMs = options.nowMs || Date.now();
+  const providerIssues = list
+    .map(normalizedProviderIssue)
+    .filter(Boolean)
+    .sort((a, b) => asTime(b.created_at) - asTime(a.created_at));
+
+  const currentIssue = providerIssues.find((issue) => isCurrentProviderIssue(issue, options, nowMs)) || null;
+  const currentIssueId = currentIssue && currentIssue.id;
+  const providerHistory = providerIssues
+    .filter((issue) => issue.id !== currentIssueId)
+    .map((issue) => summarizeProviderIssue(issue, nowMs));
+
+  const disabledSkills = list.filter(isDisabledSkillAlert).map((alert) => ({
+    ...publicAlert(alert),
+    skill: skillNameFromAlert(alert),
+  }));
+  const integrationAlerts = list
+    .filter((alert) => !normalizedProviderIssue(alert) && !isDisabledSkillAlert(alert) && isIntegrationAlert(alert))
+    .map(publicAlert);
+  const systemAlerts = list
+    .filter((alert) => !normalizedProviderIssue(alert) && !isDisabledSkillAlert(alert) && !isIntegrationAlert(alert))
+    .map(publicAlert);
+
+  let level = 'ok';
+  if (currentIssue) level = currentIssue.severity === 'warning' ? 'warning' : 'error';
+  else if (integrationAlerts.length || disabledSkills.length || systemAlerts.some((a) => a.severity === 'error')) level = 'warning';
+  else if (providerHistory.length || systemAlerts.length) level = 'info';
+
+  const activeLabel = [options.activeProvider, options.activeModel].filter(Boolean).join(' / ');
+  let title = 'Wall-E services healthy';
+  let message = activeLabel ? `${activeLabel} has no current service blocker.` : 'No current service blocker.';
+  if (currentIssue) {
+    title = currentIssue.title || 'Current provider issue';
+    message = currentIssue.message;
+  } else if (integrationAlerts.length || disabledSkills.length) {
+    title = 'Background services need review';
+    const parts = [];
+    if (disabledSkills.length) parts.push(`${disabledSkills.length} disabled skill${disabledSkills.length === 1 ? '' : 's'}`);
+    if (integrationAlerts.length) parts.push(`${integrationAlerts.length} integration alert${integrationAlerts.length === 1 ? '' : 's'}`);
+    message = parts.join(' and ') + '.';
+  } else if (providerHistory.length || systemAlerts.length) {
+    title = 'Older service history';
+    message = 'No current blocker, but older provider or system alerts are available for review.';
+  }
+
+  return {
+    level,
+    title,
+    message,
+    active_provider: {
+      provider: options.activeProvider || '',
+      model: options.activeModel || '',
+    },
+    current_issue: currentIssue ? summarizeProviderIssue(currentIssue, nowMs) : null,
+    disabled_skills: disabledSkills,
+    integration_alerts: integrationAlerts,
+    provider_history: providerHistory,
+    system_alerts: systemAlerts,
+    counts: {
+      total: list.length,
+      current: currentIssue ? 1 : 0,
+      disabled_skills: disabledSkills.length,
+      integration: integrationAlerts.length,
+      provider_history: providerHistory.length,
+      system: systemAlerts.length,
+    },
+    updated_at: new Date(nowMs).toISOString(),
+  };
+}
+
+module.exports = {
+  buildServiceHealth,
+  normalizedProviderIssue,
+  skillNameFromAlert,
+  TRANSIENT_PROVIDER_ISSUE_MAX_AGE_MS,
+};

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

@@ -3,6 +3,11 @@
 const Anthropic = require('@anthropic-ai/sdk');
 const { fetchWithRetry } = require('./retry');
 const { filterToSupportedModels, supportedModelsForProvider } = require('./supported-models');
+const { isPortkeyProviderConfig } = require('./portkey');
+const {
+  isAnthropicSamplingParamError,
+  stripAnthropicUnsupportedParams,
+} = require('./request-compat');
 
 // ============================================================
 // Environment configuration
@@ -74,6 +79,90 @@ function buildClientOptsFromEnv() {
 
 const MODELS = supportedModelsForProvider('anthropic');
 
+function portkeyMessagesUrl(baseUrl) {
+  const root = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!root) return '/v1/messages';
+  return /\/v1$/i.test(root) ? `${root}/messages` : `${root}/v1/messages`;
+}
+
+// ============================================================
+// Prompt caching
+// ============================================================
+
+const EPHEMERAL = Object.freeze({ type: 'ephemeral' });
+
+function _stripCacheControl(block) {
+  if (block && typeof block === 'object' && block.cache_control) {
+    const { cache_control, ...rest } = block;
+    return rest;
+  }
+  return block;
+}
+
+// Thinking blocks can't carry cache_control; empty text blocks are rejected.
+function _blockSupportsCacheControl(block) {
+  if (!block || typeof block !== 'object') return false;
+  if (block.type === 'thinking' || block.type === 'redacted_thinking') return false;
+  if (block.type === 'text' && !String(block.text || '').length) return false;
+  return true;
+}
+
+/**
+ * Place prompt-cache breakpoints on a /v1/messages request:
+ * last tool definition, last system block, and a sliding breakpoint on the
+ * last content block of the last message (re-placed every turn so turn N+1
+ * reads turn N's prefix from cache). Uses 3 of the 4 allowed breakpoints.
+ *
+ * Pure: returns a new request object; never mutates the caller's messages
+ * (the agent loop reuses message objects across turns — mutating them would
+ * accumulate stale breakpoints and blow the 4-breakpoint API limit).
+ */
+function applyAnthropicPromptCaching(reqParams) {
+  const out = { ...reqParams };
+
+  if (typeof out.system === 'string' && out.system.length > 0) {
+    out.system = [{ type: 'text', text: out.system, cache_control: EPHEMERAL }];
+  } else if (Array.isArray(out.system) && out.system.length > 0) {
+    const blocks = out.system.map(_stripCacheControl);
+    const last = blocks.length - 1;
+    if (_blockSupportsCacheControl(blocks[last])) {
+      blocks[last] = { ...blocks[last], cache_control: EPHEMERAL };
+    }
+    out.system = blocks;
+  }
+
+  if (Array.isArray(out.tools) && out.tools.length > 0) {
+    const tools = out.tools.map(_stripCacheControl);
+    tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: EPHEMERAL };
+    out.tools = tools;
+  }
+
+  if (Array.isArray(out.messages) && out.messages.length > 0) {
+    const messages = out.messages.map((msg) => (
+      msg && Array.isArray(msg.content)
+        ? { ...msg, content: msg.content.map(_stripCacheControl) }
+        : msg
+    ));
+    const lastIdx = messages.length - 1;
+    const last = messages[lastIdx];
+    if (last && typeof last === 'object') {
+      if (typeof last.content === 'string' && last.content.length > 0) {
+        messages[lastIdx] = { ...last, content: [{ type: 'text', text: last.content, cache_control: EPHEMERAL }] };
+      } else if (Array.isArray(last.content) && last.content.length > 0) {
+        const blocks = [...last.content];
+        const lastBlock = blocks.length - 1;
+        if (_blockSupportsCacheControl(blocks[lastBlock])) {
+          blocks[lastBlock] = { ...blocks[lastBlock], cache_control: EPHEMERAL };
+          messages[lastIdx] = { ...last, content: blocks };
+        }
+      }
+    }
+    out.messages = messages;
+  }
+
+  return out;
+}
+
 // Build a human-readable display name from a model id, e.g.
 // "claude-opus-4-7" -> "Claude Opus 4.7"
 function _prettyAnthropicName(id, providedDisplayName) {
@@ -139,7 +228,7 @@ function createAnthropicProvider(config = {}) {
         headers['anthropic-beta'] = betaHeader ? betaHeader + ',oauth-2025-04-20' : 'oauth-2025-04-20';
       }
     }
-    const messagesUrl = baseUrl.replace(/\/+$/, '') + '/messages';
+    const messagesUrl = portkeyMessagesUrl(baseUrl);
 
     client = {
       messages: {
@@ -200,13 +289,15 @@ function createAnthropicProvider(config = {}) {
      * @param {string}  [params.system]    - System prompt
      * @param {number}  [params.maxTokens] - Max output tokens (default 4096)
      * @param {number}  [params.temperature]
+     * @param {number}  [params.top_p]
+     * @param {number}  [params.top_k]
      * @param {AbortSignal} [params.signal]
      * @returns {Promise<object>} Normalized response
      */
-    async chat({ model, messages, tools, system, maxTokens = 4096, temperature, signal } = {}) {
+    async chat({ model, messages, tools, system, maxTokens = 4096, temperature, top_p, topP, top_k, topK, signal, promptCache } = {}) {
       const start = Date.now();
 
-      const reqParams = {
+      let reqParams = {
         model,
         messages,
         max_tokens: maxTokens,
@@ -214,9 +305,25 @@ function createAnthropicProvider(config = {}) {
       if (system) reqParams.system = system;
       if (tools && tools.length > 0) reqParams.tools = tools;
       if (temperature !== undefined) reqParams.temperature = temperature;
+      if (top_p !== undefined) reqParams.top_p = top_p;
+      if (topP !== undefined && reqParams.top_p === undefined) reqParams.top_p = topP;
+      if (top_k !== undefined) reqParams.top_k = top_k;
+      if (topK !== undefined && reqParams.top_k === undefined) reqParams.top_k = topK;
+      if (promptCache) reqParams = applyAnthropicPromptCaching(reqParams);
+
+      const compat = stripAnthropicUnsupportedParams(reqParams, { model });
+      const providerReqParams = compat.request;
 
       const fetchOpts = signal ? { signal } : undefined;
-      const raw = await client.messages.create(reqParams, fetchOpts);
+      let raw;
+      try {
+        raw = await client.messages.create(providerReqParams, fetchOpts);
+      } catch (err) {
+        const fallback = stripAnthropicUnsupportedParams(reqParams, { model, force: true });
+        const didStrip = fallback.warnings.some((warning) => warning.keys?.length > 0);
+        if (!didStrip || !isAnthropicSamplingParamError(err)) throw err;
+        raw = await client.messages.create(fallback.request, fetchOpts);
+      }
       const latencyMs = Date.now() - start;
 
       // Normalize response
@@ -231,8 +338,18 @@ function createAnthropicProvider(config = {}) {
           input: tu.input,
         })),
         stopReason: raw.stop_reason === 'end_turn' ? 'end_turn' : raw.stop_reason === 'tool_use' ? 'tool_use' : raw.stop_reason,
+        // `input` is the TOTAL effective input (uncached + cache hits + cache
+        // writes) so context-size consumers (compaction triggers) see the real
+        // prompt size; cacheRead/cacheWrite let cost accounting discount them.
         usage: raw.usage
-          ? { input: raw.usage.input_tokens, output: raw.usage.output_tokens }
+          ? {
+            input: (raw.usage.input_tokens || 0)
+              + (raw.usage.cache_read_input_tokens || 0)
+              + (raw.usage.cache_creation_input_tokens || 0),
+            output: raw.usage.output_tokens,
+            cacheRead: raw.usage.cache_read_input_tokens || 0,
+            cacheWrite: raw.usage.cache_creation_input_tokens || 0,
+          }
           : undefined,
         latencyMs,
         model: raw.model || model,
@@ -249,6 +366,11 @@ function createAnthropicProvider(config = {}) {
      */
     async listModels(options = {}) {
       const exact = Boolean(options.exact || options.liveOnly);
+      const includeUnknown = Boolean(
+        options.includeUnknown
+        || options.allowUnknown
+        || isPortkeyProviderConfig({ baseUrl, customHeaders })
+      );
       const configuredHeaders = customHeaders || {};
       const hasHeaderCredential = Boolean(
         configuredHeaders['x-api-key']
@@ -289,6 +411,7 @@ function createAnthropicProvider(config = {}) {
           if (/opus/i.test(id) || /-4-7/.test(id)) capabilities.reasoning = true;
           out.push({ id, name: _prettyAnthropicName(id, m.display_name), capabilities });
         }
+        if (includeUnknown) return out;
         const supported = filterToSupportedModels('anthropic', out);
         return supported.length > 0 ? supported : supportedModelsForProvider('anthropic');
       } catch (err) {
@@ -320,4 +443,6 @@ module.exports = {
   buildClientOptsFromEnv,
   createAnthropicProvider,
   createAnthropicFromEnv,
+  portkeyMessagesUrl,
+  applyAnthropicPromptCaching,
 };