@yeaft/webchat-agent 0.1.412 → 0.1.414

package/unify/config-api.js

@@ -0,0 +1,117 @@
+/**
+ * config-api.js — Read/write Yeaft config.json for remote management
+ *
+ * Provides functions to get and update the LLM-related portion of
+ * ~/.yeaft/config.json via WebSocket messages from the web UI.
+ *
+ * Only exposes provider/model configuration — not internal fields
+ * like maxContinueTurns or debug that don't belong in the UI.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { DEFAULT_YEAFT_DIR } from './init.js';
+
+/**
+ * Read the LLM-relevant portion of config.json.
+ *
+ * @param {string} [dir] — Yeaft data directory
+ * @returns {{ providers, primaryModel, fastModel, language } | { error: string }}
+ */
+export function getLlmConfig(dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+
+  if (!existsSync(configPath)) {
+    return { providers: [], primaryModel: null, fastModel: null, language: 'en', needsSetup: true };
+  }
+
+  try {
+    const raw = readFileSync(configPath, 'utf8');
+    const json = JSON.parse(raw);
+    const providers = Array.isArray(json.providers) ? json.providers : [];
+
+    // Detect if config still has default/placeholder values (first-time setup needed)
+    const needsSetup = providers.length === 0 || providers.every(p =>
+      p.apiKey === 'proxy' || p.apiKey === '' || !p.apiKey
+    );
+
+    return {
+      providers,
+      primaryModel: json.primaryModel || null,
+      fastModel: json.fastModel || null,
+      language: json.language || 'en',
+      needsSetup,
+    };
+  } catch (e) {
+    return { error: `Failed to read config.json: ${e.message}` };
+  }
+}
+
+/**
+ * Update the LLM-relevant portion of config.json.
+ * Merges into existing config — preserves fields like debug, maxContextTokens, etc.
+ *
+ * @param {object} update — { providers?, primaryModel?, fastModel?, language? }
+ * @param {string} [dir] — Yeaft data directory
+ * @returns {{ providers, primaryModel, fastModel, language } | { error: string }}
+ */
+export function updateLlmConfig(update, dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+
+  // Read existing config (preserve non-LLM fields)
+  let existing = {};
+  if (existsSync(configPath)) {
+    try {
+      existing = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch {
+      // Start fresh if corrupt
+      existing = {};
+    }
+  }
+
+  // Validate providers structure
+  if (update.providers !== undefined) {
+    if (!Array.isArray(update.providers)) {
+      return { error: 'providers must be an array' };
+    }
+    for (const p of update.providers) {
+      if (!p.name || typeof p.name !== 'string') {
+        return { error: 'Each provider must have a name' };
+      }
+      if (!p.baseUrl || typeof p.baseUrl !== 'string') {
+        return { error: `Provider "${p.name}" must have a baseUrl` };
+      }
+      if (!Array.isArray(p.models) || p.models.length === 0) {
+        return { error: `Provider "${p.name}" must have at least one model` };
+      }
+    }
+    existing.providers = update.providers;
+  }
+
+  // Update model selections
+  if (update.primaryModel !== undefined) {
+    existing.primaryModel = update.primaryModel || null;
+  }
+  if (update.fastModel !== undefined) {
+    existing.fastModel = update.fastModel || null;
+  }
+  if (update.language !== undefined) {
+    existing.language = update.language;
+  }
+
+  // Write back
+  try {
+    writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+  } catch (e) {
+    return { error: `Failed to write config.json: ${e.message}` };
+  }
+
+  return {
+    providers: Array.isArray(existing.providers) ? existing.providers : [],
+    primaryModel: existing.primaryModel || null,
+    fastModel: existing.fastModel || null,
+    language: existing.language || 'en',
+  };
+}

package/unify/config.js

@@ -1,38 +1,66 @@
 /**
  * config.js — Yeaft configuration management
  *
- * Priority (high → low): CLI overrides > ENV vars > .env file > config.md frontmatter > defaults
+ * All configuration lives in ~/.yeaft/config.json:
  *
- * Note: "model" in Yeaft always means a model ID (e.g. "gpt-5", "claude-sonnet-4-20250514").
- * Yeaft does not provide its own models — it routes to external LLM providers via adapters.
+ * {
+ *   "providers": [
+ *     { "name": "my-proxy", "baseUrl": "http://localhost:6628/v1", "apiKey": "proxy",
+ *       "models": ["claude-sonnet-4-20250514", "gpt-5", "deepseek-chat"] }
+ *   ],
+ *   "primaryModel": "my-proxy/claude-sonnet-4-20250514",
+ *   "fastModel": "my-proxy/claude-haiku-3-20250414",
+ *   "language": "en",
+ *   "debug": false,
+ *   "maxContextTokens": 200000,
+ *   "messageTokenBudget": 8192
+ * }
+ *
+ * Legacy: if config.json doesn't exist, falls back to old config.md + .env for migration.
  */
 
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { resolveModel } from './models.js';
+import { resolveModel, parseModelRef } from './models.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
-  model: 'claude-sonnet-4-20250514',
-  fallbackModel: null,
-  language: 'en', // 'en' | 'zh'
-  apiKey: null,
-  openaiApiKey: null,
-  proxyUrl: 'http://localhost:6628',
-  baseUrl: null,
-  adapter: null, // auto-detect: 'anthropic' | 'openai' | 'proxy'
+  language: 'en',
   debug: false,
   dir: DEFAULT_YEAFT_DIR,
   maxContextTokens: 200000,
   maxOutputTokens: 16384,
-  messageTokenBudget: 8192, // Phase 2: context * 4%, triggers consolidation
-  maxContinueTurns: 3,      // Phase 2: auto-continue on max_tokens
+  messageTokenBudget: 8192,
+  maxContinueTurns: 3,
 };
 
+// ─── config.json reader ─────────────────────────────────────────
+
+/**
+ * Read and parse ~/.yeaft/config.json.
+ *
+ * @param {string} dir
+ * @returns {object|null} — Parsed JSON or null if not found/invalid
+ */
+function readConfigJson(dir) {
+  const configPath = join(dir, 'config.json');
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const raw = readFileSync(configPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// ─── Legacy support (config.md + .env) ──────────────────────────
+
 /**
  * Parse YAML frontmatter from a markdown file.
  * Simple parser — handles key: value pairs, no nested objects.
+ * @deprecated Use config.json instead. Kept for migration.
  *
  * @param {string} content — File content
  * @returns {Record<string, string>} — Parsed frontmatter
@@ -49,7 +77,6 @@ export function parseFrontmatter(content) {
     if (colonIdx === -1) continue;
     const key = trimmed.slice(0, colonIdx).trim();
     let value = trimmed.slice(colonIdx + 1).trim();
-    // Parse booleans and numbers
     if (value === 'true') value = true;
     else if (value === 'false') value = false;
     else if (value === 'null') value = null;
@@ -60,243 +87,209 @@ export function parseFrontmatter(content) {
 }
 
 /**
- * Load configuration from config.md file.
- *
- * @param {string} dir — Yeaft data directory
- * @returns {Record<string, unknown>} — Config from file
+ * Load legacy config.md.
+ * @deprecated
  */
-function loadConfigFile(dir) {
+function loadLegacyConfigFile(dir) {
   const configPath = join(dir, 'config.md');
   if (!existsSync(configPath)) return {};
-
   try {
-    const content = readFileSync(configPath, 'utf8');
-    return parseFrontmatter(content);
+    return parseFrontmatter(readFileSync(configPath, 'utf8'));
   } catch {
     return {};
   }
 }
 
 /**
- * Load .env file from a directory. Sets process.env for any keys
- * not already defined (env vars take precedence over .env file).
- *
- * ⚠️ Side-effect: mutates process.env globally. Values set by a previous
- * call persist across subsequent loadConfig() calls within the same process.
- * This is by design (matches dotenv behavior), but callers that need isolation
- * (e.g. tests) must manually delete keys from process.env between calls.
- *
- * @param {string} dir — Directory containing .env file
+ * Load legacy .env file.
+ * @deprecated
  */
-function loadEnvFile(dir) {
+function loadLegacyEnvFile(dir) {
   const envPath = join(dir, '.env');
   if (!existsSync(envPath)) return;
-
   try {
     const content = readFileSync(envPath, 'utf8');
     for (const line of content.split('\n')) {
       let trimmed = line.trim();
-      // Skip empty lines and comments
       if (!trimmed || trimmed.startsWith('#')) continue;
-      // Strip optional 'export ' prefix (common in .env files)
       if (trimmed.startsWith('export ')) trimmed = trimmed.slice(7);
       const eqIdx = trimmed.indexOf('=');
       if (eqIdx === -1) continue;
-
       const key = trimmed.slice(0, eqIdx).trim();
       let value = trimmed.slice(eqIdx + 1).trim();
-      // Remove surrounding quotes if present
       if ((value.startsWith('"') && value.endsWith('"')) ||
           (value.startsWith("'") && value.endsWith("'"))) {
         value = value.slice(1, -1);
       }
-
-      // Only set if not already defined (shell env takes precedence)
       if (process.env[key] === undefined) {
         process.env[key] = value;
       }
     }
   } catch {
-    // Silently ignore .env read errors
+    // Silently ignore
   }
 }
 
-/**
- * Helper: check if an env var is truthy.
- * @param {string|undefined} val
- * @returns {boolean}
- */
 function isTruthy(val) {
   return val === '1' || val === 'true' || val === 'yes';
 }
 
 /**
- * Load full configuration.
- *
- * @param {Record<string, unknown>} [overrides] — CLI overrides
- * @returns {object} — Merged configuration
+ * Build config from legacy config.md + .env + env vars.
+ * @deprecated — used only when config.json doesn't exist.
  */
-export function loadConfig(overrides = {}) {
+function loadLegacyConfig(dir, overrides) {
   const env = process.env;
+  loadLegacyEnvFile(dir);
+  const fileConfig = loadLegacyConfigFile(dir);
 
-  // Determine data directory first (needed to load .env and config.md)
-  const dir = overrides.dir || env.YEAFT_DIR || DEFAULTS.dir;
-
-  // Load .env file (sets process.env for undefined keys — shell env takes precedence)
-  loadEnvFile(dir);
-
-  // Load from config.md
-  const fileConfig = loadConfigFile(dir);
-
-  // Build merged config: defaults < file < env < overrides
   const config = {
-    model:
-      overrides.model ||
-      env.YEAFT_MODEL ||
-      fileConfig.model ||
-      DEFAULTS.model,
-
-    fallbackModel:
-      overrides.fallbackModel ||
-      env.YEAFT_FALLBACK_MODEL ||
-      fileConfig.fallbackModel ||
-      DEFAULTS.fallbackModel,
-
-    language:
-      overrides.language ||
-      env.YEAFT_LANGUAGE ||
-      fileConfig.language ||
-      DEFAULTS.language,
-
-    apiKey:
-      overrides.apiKey ||
-      env.YEAFT_API_KEY ||
-      fileConfig.apiKey ||
-      DEFAULTS.apiKey,
-
-    openaiApiKey:
-      overrides.openaiApiKey ||
-      env.YEAFT_OPENAI_API_KEY ||
-      fileConfig.openaiApiKey ||
-      DEFAULTS.openaiApiKey,
-
-    proxyUrl:
-      overrides.proxyUrl ||
-      env.YEAFT_PROXY_URL ||
-      fileConfig.proxyUrl ||
-      DEFAULTS.proxyUrl,
-
-    baseUrl:
-      overrides.baseUrl ||
-      env.YEAFT_BASE_URL ||
-      fileConfig.baseUrl ||
-      DEFAULTS.baseUrl,
-
-    adapter:
-      overrides.adapter ||
-      env.YEAFT_ADAPTER ||
-      fileConfig.adapter ||
-      DEFAULTS.adapter,
-
-    debug:
-      overrides.debug !== undefined
-        ? overrides.debug
-        : env.YEAFT_DEBUG !== undefined
-          ? isTruthy(env.YEAFT_DEBUG)
-          : fileConfig.debug !== undefined
-            ? fileConfig.debug
-            : DEFAULTS.debug,
-
+    model: overrides.model || env.YEAFT_MODEL || fileConfig.model || 'claude-sonnet-4-20250514',
+    fallbackModel: overrides.fallbackModel || env.YEAFT_FALLBACK_MODEL || fileConfig.fallbackModel || null,
+    language: overrides.language || env.YEAFT_LANGUAGE || fileConfig.language || DEFAULTS.language,
+    apiKey: overrides.apiKey || env.YEAFT_API_KEY || fileConfig.apiKey || null,
+    openaiApiKey: overrides.openaiApiKey || env.YEAFT_OPENAI_API_KEY || fileConfig.openaiApiKey || null,
+    proxyUrl: overrides.proxyUrl || env.YEAFT_PROXY_URL || fileConfig.proxyUrl || 'http://localhost:6628',
+    baseUrl: overrides.baseUrl || env.YEAFT_BASE_URL || fileConfig.baseUrl || null,
+    adapter: overrides.adapter || env.YEAFT_ADAPTER || fileConfig.adapter || null,
+    debug: overrides.debug !== undefined ? overrides.debug
+      : env.YEAFT_DEBUG !== undefined ? isTruthy(env.YEAFT_DEBUG)
+        : fileConfig.debug !== undefined ? fileConfig.debug : DEFAULTS.debug,
     dir,
-
-    maxContextTokens:
-      overrides.maxContextTokens ??
-      (env.YEAFT_MAX_CONTEXT ? parseInt(env.YEAFT_MAX_CONTEXT, 10) : null) ??
-      fileConfig.maxContextTokens ??
-      DEFAULTS.maxContextTokens,
-
-    maxOutputTokens:
-      overrides.maxOutputTokens ??
-      fileConfig.maxOutputTokens ??
-      DEFAULTS.maxOutputTokens,
-
-    messageTokenBudget:
-      overrides.messageTokenBudget ??
-      (env.YEAFT_MESSAGE_TOKEN_BUDGET ? parseInt(env.YEAFT_MESSAGE_TOKEN_BUDGET, 10) : null) ??
-      fileConfig.messageTokenBudget ??
-      DEFAULTS.messageTokenBudget,
-
-    maxContinueTurns:
-      overrides.maxContinueTurns ??
-      fileConfig.maxContinueTurns ??
-      DEFAULTS.maxContinueTurns,
+    maxContextTokens: overrides.maxContextTokens ?? (env.YEAFT_MAX_CONTEXT ? parseInt(env.YEAFT_MAX_CONTEXT, 10) : null) ?? fileConfig.maxContextTokens ?? DEFAULTS.maxContextTokens,
+    maxOutputTokens: overrides.maxOutputTokens ?? fileConfig.maxOutputTokens ?? DEFAULTS.maxOutputTokens,
+    messageTokenBudget: overrides.messageTokenBudget ?? (env.YEAFT_MESSAGE_TOKEN_BUDGET ? parseInt(env.YEAFT_MESSAGE_TOKEN_BUDGET, 10) : null) ?? fileConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
+    maxContinueTurns: overrides.maxContinueTurns ?? fileConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
+    providers: null,
+    primaryModel: null,
+    fastModel: null,
   };
 
-  // Auto-detect adapter using model registry + credential fallback
+  // Auto-detect adapter
   if (!config.adapter) {
     const modelInfo = resolveModel(config.model);
     if (modelInfo) {
-      // Known model → set adapter from registry
       config.adapter = modelInfo.adapter === 'anthropic' ? 'anthropic' : 'openai';
-      // Use registry baseUrl if not explicitly overridden
-      if (!config.baseUrl) {
-        config.baseUrl = modelInfo.baseUrl;
-      }
-      // Use registry contextWindow if still at default
-      if (config.maxContextTokens === DEFAULTS.maxContextTokens) {
-        config.maxContextTokens = modelInfo.contextWindow;
-      }
-      // Use registry maxOutputTokens if still at default
-      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) {
-        config.maxOutputTokens = modelInfo.maxOutputTokens;
-      }
+      if (!config.baseUrl) config.baseUrl = modelInfo.baseUrl;
+      if (config.maxContextTokens === DEFAULTS.maxContextTokens) config.maxContextTokens = modelInfo.contextWindow;
+      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) config.maxOutputTokens = modelInfo.maxOutputTokens;
     } else {
-      // Unknown model → fallback to credential-based detection
-      if (config.apiKey) {
-        config.adapter = 'anthropic';
-      } else if (config.openaiApiKey) {
-        config.adapter = 'openai';
-      } else if (config.proxyUrl) {
-        config.adapter = 'proxy';
-      }
+      if (config.apiKey) config.adapter = 'anthropic';
+      else if (config.openaiApiKey) config.adapter = 'openai';
+      else if (config.proxyUrl) config.adapter = 'proxy';
     }
   }
 
-  // Store resolved model info for reference
   config.modelInfo = resolveModel(config.model) || null;
+  return config;
+}
+
+// ─── Main: loadConfig ───────────────────────────────────────────
+
+/**
+ * Load full configuration.
+ *
+ * Reads ~/.yeaft/config.json first. If not found, falls back to legacy
+ * config.md + .env for backward compatibility.
+ *
+ * @param {Record<string, unknown>} [overrides] — CLI overrides
+ * @returns {object} — Merged configuration
+ */
+export function loadConfig(overrides = {}) {
+  // Determine data directory
+  const dir = overrides.dir || process.env.YEAFT_DIR || DEFAULTS.dir;
+
+  // Try config.json first
+  const jsonConfig = readConfigJson(dir);
+
+  if (!jsonConfig) {
+    // No config.json → legacy path
+    return loadLegacyConfig(dir, overrides);
+  }
+
+  // ─── Build config from config.json ────────────────────────
+  const providers = Array.isArray(jsonConfig.providers) ? jsonConfig.providers : null;
+
+  // Resolve primary model
+  let model = 'claude-sonnet-4-20250514';
+  let primaryModel = jsonConfig.primaryModel || null;
+  if (primaryModel) {
+    const parsed = parseModelRef(primaryModel);
+    model = parsed.modelId;
+  }
+
+  // Resolve fast model
+  let fastModel = jsonConfig.fastModel || primaryModel || null;
+  let fastModelId = null;
+  if (fastModel) {
+    const parsed = parseModelRef(fastModel);
+    fastModelId = parsed.modelId;
+  }
+
+  // Resolve model info for context window / output limits
+  const modelInfo = resolveModel(model);
+
+  const config = {
+    // Model
+    model: overrides.model || model,
+    primaryModel: overrides.primaryModel || primaryModel,
+    fastModel: overrides.fastModel || fastModel,
+    fastModelId: fastModelId,
+    fallbackModel: jsonConfig.fallbackModel || null,
+    modelInfo: modelInfo || null,
+
+    // Providers
+    providers: providers,
+
+    // General settings
+    language: overrides.language || jsonConfig.language || DEFAULTS.language,
+    debug: overrides.debug !== undefined ? overrides.debug : (jsonConfig.debug ?? DEFAULTS.debug),
+    dir,
+
+    // Token limits
+    maxContextTokens: overrides.maxContextTokens ?? jsonConfig.maxContextTokens ?? modelInfo?.contextWindow ?? DEFAULTS.maxContextTokens,
+    maxOutputTokens: overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens ?? modelInfo?.maxOutputTokens ?? DEFAULTS.maxOutputTokens,
+    messageTokenBudget: overrides.messageTokenBudget ?? jsonConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
+    maxContinueTurns: overrides.maxContinueTurns ?? jsonConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
+
+    // Legacy fields (null when using config.json)
+    apiKey: overrides.apiKey || null,
+    openaiApiKey: null,
+    proxyUrl: null,
+    baseUrl: null,
+    adapter: null,
+  };
 
   return config;
 }
 
+// ─── MCP config ─────────────────────────────────────────────────
+
 /**
- * Load MCP server configuration from ~/.yeaft/mcp.json.
+ * Load MCP server configuration.
  *
- * JSON format (frontmatter parser can't handle nested objects):
- * {
- *   "servers": [
- *     {
- *       "name": "github",
- *       "command": "npx",
- *       "args": ["@mcp/github"],
- *       "env": { "GITHUB_TOKEN": "ghp_..." }
- *     }
- *   ]
- * }
+ * Reads from config.json "mcpServers" field first, then falls back to
+ * standalone ~/.yeaft/mcp.json for backward compatibility.
  *
- * @param {string} yeaftDir — e.g. ~/.yeaft
+ * @param {string} yeaftDir
+ * @param {object} [jsonConfig] — Already-parsed config.json (optional, avoids re-read)
  * @returns {{ servers: object[] }}
  */
-export function loadMCPConfig(yeaftDir) {
+export function loadMCPConfig(yeaftDir, jsonConfig) {
+  // Check config.json mcpServers field
+  if (jsonConfig && Array.isArray(jsonConfig.mcpServers)) {
+    const valid = jsonConfig.mcpServers.filter(s => s.name && s.command);
+    if (valid.length > 0) return { servers: valid };
+  }
+
+  // Fallback: standalone mcp.json
   const mcpPath = join(yeaftDir, 'mcp.json');
   if (!existsSync(mcpPath)) return { servers: [] };
 
   try {
     const raw = readFileSync(mcpPath, 'utf8');
     const parsed = JSON.parse(raw);
-    if (!parsed.servers || !Array.isArray(parsed.servers)) {
-      return { servers: [] };
-    }
-    // Each server must have at least name + command
+    if (!parsed.servers || !Array.isArray(parsed.servers)) return { servers: [] };
     const valid = parsed.servers.filter(s => s.name && s.command);
     return { servers: valid };
   } catch {

package/unify/engine.js

@@ -80,6 +80,9 @@ export class Engine {
   /** @type {string|null} */
   #yeaftDir;
 
+  /** @type {object|null} — Config override for internal tasks (recall, consolidation, dream) using fastModel */
+  #fastConfig;
+
   /**
    * @param {{
    *   adapter: import('./llm/adapter.js').LLMAdapter,
@@ -105,6 +108,15 @@ export class Engine {
     this.#skillManager = skillManager || null;
     this.#mcpManager = mcpManager || null;
     this.#yeaftDir = yeaftDir || null;
+
+    // Build fast config: uses fastModelId for internal tasks (recall, consolidation, dream)
+    // Falls back to primary model if no fastModel configured
+    const fastModelId = config.fastModelId || config.model;
+    if (fastModelId !== config.model) {
+      this.#fastConfig = { ...config, model: fastModelId };
+    } else {
+      this.#fastConfig = config;
+    }
   }
 
   /**
@@ -215,12 +227,12 @@ export class Engine {
     // Read user profile
     memory.profile = this.#memoryStore.readProfile();
 
-    // Recall relevant entries
+    // Recall relevant entries (uses fastModel for cheaper/faster side-queries)
     try {
       const result = await recall({
         prompt,
         adapter: this.#adapter,
-        config: this.#config,
+        config: this.#fastConfig,
         memoryStore: this.#memoryStore,
       });
       memory.entries = result.entries;
@@ -288,7 +300,7 @@ export class Engine {
         conversationStore: this.#conversationStore,
         memoryStore: this.#memoryStore,
         adapter: this.#adapter,
-        config: this.#config,
+        config: this.#fastConfig,
         budget,
       });
       return { archivedCount: result.archivedCount, extractedCount: result.extractedEntries.length };
@@ -481,13 +493,16 @@ export class Engine {
         // ─── Post-query: StopHooks or Legacy ─────────────
         if (this.#yeaftDir && this.#conversationStore) {
           // Full pipeline: persist + consolidate + dream gate
+          // Note: stopHooks uses fastConfig for consolidation/dream (cheaper internal tasks)
+          // but receives both configs — messages are persisted with primary model name
           const hookResult = await runStopHooks({
             yeaftDir: this.#yeaftDir,
             mode,
             conversationStore: this.#conversationStore,
             memoryStore: this.#memoryStore,
             adapter: this.#adapter,
-            config: this.#config,
+            config: this.#fastConfig,
+            primaryModel: this.#config.model,
             messages: conversationMessages,
             trace: this.#trace,
           });
@@ -616,4 +631,7 @@ export class Engine {
 
   /** @returns {string|null} */
   get yeaftDir() { return this.#yeaftDir; }
+
+  /** @returns {object} — Config with fastModel as model (for internal tasks) */
+  get fastConfig() { return this.#fastConfig; }
 }

package/unify/index.js

@@ -16,7 +16,8 @@ export {
   LLMAbortError,
   createLLMAdapter,
 } from './llm/adapter.js';
-export { MODEL_REGISTRY, resolveModel, listModels, isKnownModel } from './models.js';
+export { AdapterRouter } from './llm/router.js';
+export { MODEL_REGISTRY, resolveModel, listModels, isKnownModel, getProviderForModel, parseModelRef } from './models.js';
 export { buildSystemPrompt, SUPPORTED_LANGUAGES } from './prompts.js';
 export { Engine } from './engine.js';
 export { ConversationStore, parseMessage, estimateTokens } from './conversation/persist.js';