byterover-cli 1.8.0 → 2.1.0

package/dist/server/infra/executor/pre-compaction/prompts.js

@@ -0,0 +1,47 @@
+/**
+ * Compaction prompts for pre-curation context compaction.
+ *
+ * Self-contained prompts that steer the LLM away from query-mode policy
+ * (which would try to search the KB). The real guardrail against
+ * non-compaction responses is isCompactionOutputValid().
+ */
+/**
+ * Build the system prompt for compaction.
+ *
+ * Opens with a clear, self-contained instruction that overrides
+ * query-mode's "answers from KB only" rules. Note: prompt-level override
+ * is best-effort; isCompactionOutputValid() is the actual guardrail.
+ */
+export function buildCompactionSystemPrompt() {
+    return `You are a knowledge extraction pre-processor. Your ONLY task is to compact the provided text.
+
+## Rules
+- PRESERVE: facts, decisions, code examples, API signatures, diagrams (verbatim), tables (all rows), procedures, file paths, configurations, error patterns
+- REMOVE: conversational filler, repeated explanations, verbose tool call descriptions, meta-commentary, acknowledgments
+- Output clean structured markdown
+- Do NOT wrap output in code blocks or XML tags
+- Do NOT search any knowledge base
+- Do NOT answer questions about the content
+- Do NOT use any tools
+- Output ONLY the compacted text`;
+}
+/**
+ * Build the user message for a compaction pass.
+ *
+ * Wraps the context in <source_content> tags for clear delimitation.
+ *
+ * @param context - The source text to compact
+ * @param aggressive - Whether this is the aggressive (pass 2) attempt
+ */
+export function buildCompactionUserMessage(context, aggressive) {
+    const instruction = aggressive
+        ? 'Compact the following text MORE AGGRESSIVELY. A previous compaction attempt was not short enough. Remove all non-essential detail while keeping core facts, decisions, and code.'
+        : 'Compact the following text while preserving all knowledge-worthy information — facts, decisions, code, configurations, procedures.';
+    return `${instruction}
+
+<source_content>
+${context}
+</source_content>
+
+Output ONLY the compacted text. Do NOT use any tools.`;
+}

package/dist/server/infra/executor/query-executor.d.ts

@@ -7,6 +7,8 @@ import type { IQueryExecutor, QueryExecuteOptions } from '../../core/interfaces/
  * All fields are optional — without them, the executor falls back to the original behavior.
  */
 export interface QueryExecutorDeps {
+    /** Base directory for manifest service (e.g., project path) */
+    baseDirectory?: string;
     /** Enable query result caching (default: false) */
     enableCache?: boolean;
     /** File system for reading full document content and computing fingerprints */
@@ -21,8 +23,8 @@ export interface QueryExecutorDeps {
  * It's an Executor that wraps agent.execute() with query-specific options.
  *
  * Architecture:
- * - TaskProcessor injects the long-lived CipherAgent
- * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - AgentProcess injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-process (subscribes to agentEventBus)
  * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on query execution
  *
@@ -35,6 +37,7 @@ export interface QueryExecutorDeps {
  */
 export declare class QueryExecutor implements IQueryExecutor {
     private static readonly FINGERPRINT_CACHE_TTL_MS;
+    private readonly baseDirectory?;
     private readonly cache?;
     private cachedFingerprint?;
     private readonly fileSystem?;
@@ -48,11 +51,13 @@ export declare class QueryExecutor implements IQueryExecutor {
      */
     private buildPrefetchedContext;
     /**
-     * Build a streamlined query prompt optimized for fast, accurate responses.
+     * Build a query prompt using RLM pattern (variable references, not embedded data).
      *
-     * When pre-fetched context is available, the prompt instructs the LLM to answer
-     * directly from the provided context (reducing LLM calls from 2+ to 1).
-     * When no context is available, falls back to tool-based search.
+     * Search results are pre-loaded into sandbox variables. The prompt references
+     * variable names so the LLM accesses results via code_exec, not via the prompt.
+     *
+     * @param query - User query
+     * @param options - Prompt options with variable names and metadata
      */
     private buildQueryPrompt;
     /**
@@ -61,6 +66,21 @@ export declare class QueryExecutor implements IQueryExecutor {
      * the fingerprint changes and cached results are invalidated.
      */
     private computeContextTreeFingerprint;
+    /**
+     * Extract key entities from a query for supplementary searches.
+     * Simple heuristic: split query, filter stopwords, keep significant terms.
+     */
+    private extractQueryEntities;
+    /**
+     * Run supplementary entity-based searches to improve recall.
+     * Extracts key entities from the query and searches for each independently,
+     * then merges unique results (by path) into the original search result.
+     *
+     * @param query - Original user query
+     * @param searchResult - Initial search result to supplement
+     * @returns Merged search result with additional entity-based matches
+     */
+    private supplementEntitySearches;
     /**
      * Attempt to produce a direct response from search results without LLM.
      * Returns formatted response if high-confidence dominant match found, undefined otherwise.

package/dist/server/infra/executor/query-executor.js

@@ -1,9 +1,13 @@
 import { join } from 'node:path';
 import { BRV_DIR, CONTEXT_FILE_EXTENSION, CONTEXT_TREE_DIR } from '../../constants.js';
+import { isDerivedArtifact } from '../context-tree/derived-artifact.js';
+import { FileContextTreeManifestService } from '../context-tree/file-context-tree-manifest-service.js';
 import { canRespondDirectly, formatDirectResponse, formatNotFoundResponse, } from './direct-search-responder.js';
 import { QueryResultCache } from './query-result-cache.js';
-/** Minimum MiniSearch score to consider a result high-confidence for pre-fetching */
-const SMART_ROUTING_SCORE_THRESHOLD = 5;
+/** Attribution footer appended to all query responses */
+const ATTRIBUTION_FOOTER = '\n\n---\nSource: ByteRover Knowledge Base';
+/** Minimum normalized score to consider a result high-confidence for pre-fetching */
+const SMART_ROUTING_SCORE_THRESHOLD = 0.7;
 /** Maximum number of documents to pre-fetch and inject into the prompt */
 const SMART_ROUTING_MAX_DOCS = 5;
 /**
@@ -13,8 +17,8 @@ const SMART_ROUTING_MAX_DOCS = 5;
  * It's an Executor that wraps agent.execute() with query-specific options.
  *
  * Architecture:
- * - TaskProcessor injects the long-lived CipherAgent
- * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - AgentProcess injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-process (subscribes to agentEventBus)
  * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on query execution
  *
@@ -27,11 +31,13 @@ const SMART_ROUTING_MAX_DOCS = 5;
  */
 export class QueryExecutor {
     static FINGERPRINT_CACHE_TTL_MS = 30_000;
+    baseDirectory;
     cache;
     cachedFingerprint;
     fileSystem;
     searchService;
     constructor(deps) {
+        this.baseDirectory = deps?.baseDirectory;
         this.fileSystem = deps?.fileSystem;
         this.searchService = deps?.searchService;
         if (deps?.enableCache) {
@@ -50,14 +56,14 @@ export class QueryExecutor {
             fingerprint = await this.computeContextTreeFingerprint();
             const cached = this.cache.get(query, fingerprint);
             if (cached) {
-                return cached;
+                return cached + ATTRIBUTION_FOOTER;
             }
         }
         // === Tier 1: Fuzzy cache match (~50ms) ===
         if (this.cache && fingerprint) {
             const fuzzyHit = this.cache.findSimilar(query, fingerprint);
             if (fuzzyHit) {
-                return fuzzyHit;
+                return fuzzyHit + ATTRIBUTION_FOOTER;
             }
         }
         // Await search result (already started in parallel with fingerprint computation)
@@ -68,13 +74,17 @@ export class QueryExecutor {
         catch {
             // Search failed, proceed without pre-fetched context
         }
+        // Supplementary entity-based searches for better multi-session recall
+        if (this.searchService && searchResult && searchResult.totalFound < 3) {
+            searchResult = await this.supplementEntitySearches(query, searchResult);
+        }
         // === OOD short-circuit: no results means topic not covered ===
         if (searchResult && searchResult.results.length === 0) {
             const response = formatNotFoundResponse(query);
             if (this.cache && fingerprint) {
                 this.cache.set(query, response, fingerprint);
             }
-            return response;
+            return response + ATTRIBUTION_FOOTER;
         }
         // === Tier 2: Direct search response (~100-200ms) ===
         if (searchResult && this.fileSystem) {
@@ -83,28 +93,80 @@ export class QueryExecutor {
                 if (this.cache && fingerprint) {
                     this.cache.set(query, directResult, fingerprint);
                 }
-                return directResult;
+                return directResult + ATTRIBUTION_FOOTER;
             }
         }
-        // === Tier 3: Optimized LLM call with pre-fetched context (<5s) ===
+        // === Tier 3/4: LLM call with RLM pattern (variable-based search results) ===
         let prefetchedContext;
         if (searchResult && this.fileSystem) {
             prefetchedContext = this.buildPrefetchedContext(searchResult);
         }
-        const prompt = this.buildQueryPrompt(query, prefetchedContext);
-        // Query-optimized LLM overrides: fewer tokens, iterations, and lower temperature
-        const queryOverrides = prefetchedContext
-            ? { maxIterations: 2, maxTokens: 1024, temperature: 0.3 }
-            : { maxIterations: 3, maxTokens: 2048, temperature: 0.5 };
-        const response = await agent.execute(prompt, {
-            executionContext: { commandType: 'query', ...queryOverrides },
-            taskId,
+        // Lazy manifest rebuild: provides broad structural awareness for LLM
+        let manifestContext;
+        if (this.baseDirectory) {
+            try {
+                const manifestService = new FileContextTreeManifestService({ baseDirectory: this.baseDirectory });
+                let manifest = await manifestService.readManifestIfFresh(this.baseDirectory);
+                if (!manifest) {
+                    manifest = await manifestService.buildManifest(this.baseDirectory);
+                }
+                if (manifest) {
+                    const resolved = await manifestService.resolveForInjection(manifest, query, this.baseDirectory);
+                    if (resolved.length > 0) {
+                        manifestContext = resolved
+                            .map((e) => `[${e.type} ${e.path}]\n${e.content}`)
+                            .join('\n\n---\n\n');
+                    }
+                }
+            }
+            catch {
+                // Fail-open: proceed without manifest context
+            }
+        }
+        // Create per-task session for parallel isolation (own sandbox + history + LLM service)
+        const taskSessionId = await agent.createTaskSession(taskId, 'query');
+        // Task-scoped variable names for sandbox injection (RLM pattern).
+        // Replace hyphens with underscores: UUIDs have hyphens which are invalid in JS identifiers,
+        // so the LLM uses underscores when writing code-exec calls — matching curate-executor pattern.
+        const taskIdSafe = taskId.replaceAll('-', '_');
+        const resultsVar = `__query_results_${taskIdSafe}`;
+        const metaVar = `__query_meta_${taskIdSafe}`;
+        // Compute metadata for LLM guidance
+        const metadata = {
+            hasPreFetched: Boolean(prefetchedContext),
+            resultCount: searchResult?.results.length ?? 0,
+            topScore: searchResult?.results[0]?.score ?? 0,
+            totalFound: searchResult?.totalFound ?? 0,
+        };
+        // Inject search results + metadata into the TASK session's sandbox
+        agent.setSandboxVariableOnSession(taskSessionId, resultsVar, searchResult?.results ?? []);
+        agent.setSandboxVariableOnSession(taskSessionId, metaVar, metadata);
+        const prompt = this.buildQueryPrompt(query, {
+            manifestContext,
+            metadata,
+            metaVar,
+            prefetchedContext,
+            resultsVar,
         });
-        // Store in cache for future Tier 0/1 hits
-        if (this.cache && fingerprint) {
-            this.cache.set(query, response, fingerprint);
+        // Query-optimized LLM overrides: tokens and lower temperature
+        const queryOverrides = prefetchedContext
+            ? { maxIterations: 50, maxTokens: 1024, temperature: 0.3 }
+            : { maxIterations: 50, maxTokens: 2048, temperature: 0.5 };
+        try {
+            const response = await agent.executeOnSession(taskSessionId, prompt, {
+                executionContext: { commandType: 'query', ...queryOverrides },
+                taskId,
+            });
+            // Store in cache for future Tier 0/1 hits
+            if (this.cache && fingerprint) {
+                this.cache.set(query, response, fingerprint);
+            }
+            return response + ATTRIBUTION_FOOTER;
+        }
+        finally {
+            // Clean up entire task session (sandbox + history) in one call
+            await agent.deleteTaskSession(taskSessionId);
         }
-        return response;
     }
     /**
      * Build pre-fetched context string from search results for LLM prompt injection.
@@ -121,13 +183,30 @@ export class QueryExecutor {
         return sections.join('\n\n---\n\n');
     }
     /**
-     * Build a streamlined query prompt optimized for fast, accurate responses.
+     * Build a query prompt using RLM pattern (variable references, not embedded data).
+     *
+     * Search results are pre-loaded into sandbox variables. The prompt references
+     * variable names so the LLM accesses results via code_exec, not via the prompt.
      *
-     * When pre-fetched context is available, the prompt instructs the LLM to answer
-     * directly from the provided context (reducing LLM calls from 2+ to 1).
-     * When no context is available, falls back to tool-based search.
+     * @param query - User query
+     * @param options - Prompt options with variable names and metadata
      */
-    buildQueryPrompt(query, prefetchedContext) {
+    buildQueryPrompt(query, options) {
+        const { manifestContext, metadata, metaVar, prefetchedContext, resultsVar } = options;
+        const groundingRules = `### Grounding Rules (CRITICAL)
+- ONLY use information from the curated knowledge base (.brv/context-tree/)
+- If no relevant knowledge is found, respond: "This topic is not covered in the knowledge base."
+- Do NOT extrapolate, infer, or generate information beyond what is explicitly stated in sources
+- Every claim MUST be traceable to a specific source file
+- When uncertain, say "Based on available knowledge..." and note the limitation`;
+        const responseFormat = `### Response Format
+- **Summary**: Direct answer (2-3 sentences)
+- **Details**: Key findings with explanations
+- **Sources**: File paths from .brv/context-tree/
+- **Gaps**: Note any aspects not covered`;
+        const manifestSection = manifestContext
+            ? `\n## Structural Context (from manifest)\nThe following provides broad structural awareness of the knowledge base:\n\n${manifestContext}\n`
+            : '';
         if (prefetchedContext) {
             return `## User Query
 ${query}
@@ -136,32 +215,36 @@ ${query}
 The following relevant knowledge was found in the context tree:
 
 ${prefetchedContext}
+${manifestSection}
+## Search Results Variable
+Additional search results: \`${resultsVar}\` (${metadata.resultCount} results, top score: ${metadata.topScore.toFixed(2)})
+Metadata: \`${metaVar}\`
 
 ## Instructions
 
 Answer the user's question using the pre-fetched context above.
 If the pre-fetched context does not directly address the user's query topic, respond that the topic is not covered in the knowledge base. Do not attempt to answer from tangentially related content.
-If the context is insufficient but relevant, you may use \`code_exec\` with the \`tools.*\` SDK for additional searches.
+If the context is insufficient but relevant, use \`code_exec\` with \`silent: true\` to read additional documents from the search results variable. Use \`setFinalResult(answer)\` when done.
 
-### Response Format
-- **Summary**: Direct answer (2-3 sentences)
-- **Details**: Key findings with explanations
-- **Sources**: File paths from .brv/context-tree/
-- **Gaps**: Note any aspects not covered`;
+${groundingRules}
+
+${responseFormat}`;
         }
         return `## User Query
 ${query}
+${manifestSection}
+## Search Results Variable
+Search results: \`${resultsVar}\` (${metadata.resultCount} results, top score: ${metadata.topScore.toFixed(2)})
+Metadata: \`${metaVar}\`
 
 ## Instructions
 
-Search the context tree (.brv/context-tree/) to answer this question.
-Use \`code_exec\` to run a programmatic search with the \`tools.*\` SDK.
+Use \`code_exec\` to examine the search results in \`${resultsVar}\`, read relevant documents with \`tools.readFile()\`, and synthesize an answer.
+Use \`silent: true\` for data-loading code_exec calls. Use \`setFinalResult(answer)\` to return the final answer immediately.
 
-### Response Format
-- **Summary**: Direct answer (2-3 sentences)
-- **Details**: Key findings with explanations
-- **Sources**: File paths from .brv/context-tree/
-- **Gaps**: Note any aspects not covered`;
+${groundingRules}
+
+${responseFormat}`;
     }
     /**
      * Compute a context tree fingerprint cheaply using file mtimes.
@@ -181,7 +264,12 @@ Use \`code_exec\` to run a programmatic search with the \`tools.*\` SDK.
                 maxResults: 10_000,
                 respectGitignore: false,
             });
-            const files = globResult.files.map((f) => ({
+            // Filter out non-searchable derived artifacts (_index.md, _manifest.json, .full.md).
+            // Stubs (.stub.md) are intentionally kept — archive/restore should invalidate cache.
+            // Summary-only churn does NOT invalidate cache (summaries are derivative content).
+            const files = globResult.files
+                .filter((f) => !isDerivedArtifact(f.path))
+                .map((f) => ({
                 mtime: f.modified?.getTime() ?? 0,
                 path: f.path,
             }));
@@ -196,6 +284,59 @@ Use \`code_exec\` to run a programmatic search with the \`tools.*\` SDK.
             return 'unknown';
         }
     }
+    /**
+     * Extract key entities from a query for supplementary searches.
+     * Simple heuristic: split query, filter stopwords, keep significant terms.
+     */
+    extractQueryEntities(query) {
+        const stopwords = new Set([
+            'a', 'about', 'an', 'and', 'by', 'did', 'do', 'does', 'for', 'from',
+            'how', 'in', 'is', 'my', 'of', 'or', 'our', 'that', 'the', 'their',
+            'this', 'to', 'was', 'were', 'what', 'when', 'where', 'which', 'who', 'with',
+        ]);
+        const words = query.toLowerCase().split(/\s+/);
+        return words.filter((w) => w.length >= 3 && !stopwords.has(w));
+    }
+    /**
+     * Run supplementary entity-based searches to improve recall.
+     * Extracts key entities from the query and searches for each independently,
+     * then merges unique results (by path) into the original search result.
+     *
+     * @param query - Original user query
+     * @param searchResult - Initial search result to supplement
+     * @returns Merged search result with additional entity-based matches
+     */
+    async supplementEntitySearches(query, searchResult) {
+        const entities = this.extractQueryEntities(query);
+        if (entities.length <= 1)
+            return searchResult;
+        try {
+            const entitySearches = await Promise.allSettled(entities.slice(0, 3).map((entity) => this.searchService.search(entity, { limit: 3 })));
+            // Collect existing paths to deduplicate
+            const existingPaths = new Set(searchResult.results.map((r) => r.path));
+            const supplementary = [];
+            for (const settled of entitySearches) {
+                if (settled.status === 'fulfilled' && settled.value.results) {
+                    for (const result of settled.value.results) {
+                        if (!existingPaths.has(result.path)) {
+                            existingPaths.add(result.path);
+                            supplementary.push(result);
+                        }
+                    }
+                }
+            }
+            if (supplementary.length === 0)
+                return searchResult;
+            return {
+                ...searchResult,
+                results: [...searchResult.results, ...supplementary],
+                totalFound: searchResult.totalFound + supplementary.length,
+            };
+        }
+        catch {
+            return searchResult;
+        }
+    }
     /**
      * Attempt to produce a direct response from search results without LLM.
      * Returns formatted response if high-confidence dominant match found, undefined otherwise.

package/dist/server/infra/http/authenticated-http-client.js

@@ -153,6 +153,10 @@ export class AuthenticatedHttpClient {
         if ('message' in responseData && typeof responseData.message === 'string') {
             return responseData.message;
         }
+        // Some endpoints return 'error' instead of 'message'
+        if ('error' in responseData && typeof responseData.error === 'string') {
+            return responseData.error;
+        }
         // Fallback to HTTP status error
         return `HTTP ${error.response.status}: ${error.response.statusText}`;
     }

package/dist/server/infra/http/provider-model-fetcher-registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Provider Model Fetcher Registry
+ *
+ * Maps provider IDs to their model fetcher implementations.
+ * Lazily instantiated singletons for each provider.
+ */
+import type { IProviderModelFetcher } from '../../core/interfaces/i-provider-model-fetcher.js';
+/**
+ * Get or create a model fetcher for a provider.
+ *
+ * @param providerId - Provider identifier (e.g., 'anthropic', 'openai', 'google')
+ * @returns IProviderModelFetcher instance, or undefined if provider doesn't support model fetching
+ */
+export declare function getModelFetcher(providerId: string): Promise<IProviderModelFetcher | undefined>;
+/**
+ * Clear all cached fetcher instances.
+ * Useful for testing or when provider configs change.
+ */
+export declare function clearModelFetcherCache(): void;
+/**
+ * Validate an API key for a specific provider.
+ * Convenience function that gets the right fetcher and validates.
+ *
+ * @param apiKey - API key to validate
+ * @param providerId - Provider identifier
+ * @returns Validation result, or {isValid: false} if no fetcher exists
+ */
+export declare function validateApiKey(apiKey: string, providerId: string): Promise<{
+    error?: string;
+    isValid: boolean;
+}>;

package/dist/server/infra/http/provider-model-fetcher-registry.js

@@ -0,0 +1,117 @@
+/**
+ * Provider Model Fetcher Registry
+ *
+ * Maps provider IDs to their model fetcher implementations.
+ * Lazily instantiated singletons for each provider.
+ */
+import { PROVIDER_REGISTRY } from '../../core/domain/entities/provider-registry.js';
+import { FileProviderConfigStore } from '../storage/file-provider-config-store.js';
+import { AnthropicModelFetcher, ChatBasedModelFetcher, GoogleModelFetcher, OpenAICompatibleModelFetcher, OpenAIModelFetcher, OpenRouterModelFetcher, } from './provider-model-fetchers.js';
+/**
+ * Singleton instances of model fetchers, lazily created.
+ */
+const fetchers = new Map();
+/**
+ * Get or create a model fetcher for a provider.
+ *
+ * @param providerId - Provider identifier (e.g., 'anthropic', 'openai', 'google')
+ * @returns IProviderModelFetcher instance, or undefined if provider doesn't support model fetching
+ */
+export async function getModelFetcher(providerId) {
+    // ByteRover internal doesn't support model fetching
+    if (providerId === 'byterover')
+        return undefined;
+    // OpenAI Compatible: always read fresh config (baseUrl is user-configured and may change)
+    if (providerId === 'openai-compatible') {
+        const configStore = new FileProviderConfigStore();
+        const config = await configStore.read();
+        const baseUrl = config.getBaseUrl('openai-compatible');
+        if (baseUrl) {
+            return new OpenAICompatibleModelFetcher(baseUrl, 'OpenAI Compatible');
+        }
+        return undefined;
+    }
+    // Return cached instance
+    if (fetchers.has(providerId)) {
+        return fetchers.get(providerId);
+    }
+    // Create fetcher based on provider ID
+    let fetcher;
+    switch (providerId) {
+        case 'anthropic': {
+            fetcher = new AnthropicModelFetcher();
+            break;
+        }
+        case 'cerebras': // falls through
+        case 'cohere': // falls through
+        case 'deepinfra': // falls through
+        case 'groq': // falls through
+        case 'mistral': // falls through
+        case 'togetherai': // falls through
+        case 'xai': {
+            const provider = PROVIDER_REGISTRY[providerId];
+            if (provider?.baseUrl) {
+                fetcher = new OpenAICompatibleModelFetcher(provider.baseUrl, provider.name);
+            }
+            break;
+        }
+        case 'glm': {
+            fetcher = new ChatBasedModelFetcher('https://api.z.ai/api/paas/v4', 'GLM (Z.AI)', ['glm-4.7', 'glm-4.6', 'glm-4.5', 'glm-4.5-flash']);
+            break;
+        }
+        case 'google': {
+            fetcher = new GoogleModelFetcher();
+            break;
+        }
+        case 'minimax': {
+            fetcher = new ChatBasedModelFetcher('https://api.minimax.io/v1', 'MiniMax', ['MiniMax-M2', 'MiniMax-M2-Stable']);
+            break;
+        }
+        case 'moonshot': {
+            fetcher = new ChatBasedModelFetcher('https://api.moonshot.ai/v1', 'Moonshot AI (Kimi)', ['kimi-k2.5', 'kimi-k2-thinking', 'kimi-k2-turbo-preview', 'kimi-k2-thinking-turbo']);
+            break;
+        }
+        case 'openai': {
+            fetcher = new OpenAIModelFetcher();
+            break;
+        }
+        case 'openrouter': {
+            fetcher = new OpenRouterModelFetcher();
+            break;
+        }
+        case 'perplexity': {
+            fetcher = new ChatBasedModelFetcher('https://api.perplexity.ai', 'Perplexity', ['sonar-pro', 'sonar', 'sonar-reasoning-pro', 'sonar-reasoning', 'sonar-deep-research', 'r1-1776']);
+            break;
+        }
+        case 'vercel': {
+            fetcher = new ChatBasedModelFetcher('https://api.v0.dev/v1', 'Vercel', ['v0-1.5-md', 'v0-1.5-lg', 'v0-1.0-md']);
+            break;
+        }
+    }
+    if (fetcher) {
+        fetchers.set(providerId, fetcher);
+    }
+    return fetcher;
+}
+/**
+ * Clear all cached fetcher instances.
+ * Useful for testing or when provider configs change.
+ */
+export function clearModelFetcherCache() {
+    fetchers.clear();
+}
+/**
+ * Validate an API key for a specific provider.
+ * Convenience function that gets the right fetcher and validates.
+ *
+ * @param apiKey - API key to validate
+ * @param providerId - Provider identifier
+ * @returns Validation result, or {isValid: false} if no fetcher exists
+ */
+export async function validateApiKey(apiKey, providerId) {
+    const fetcher = await getModelFetcher(providerId);
+    if (!fetcher) {
+        return { error: `No model fetcher available for provider: ${providerId}`, isValid: false };
+    }
+    return fetcher.validateApiKey(apiKey);
+}