@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/providers/cache-planner.ts

@@ -1,258 +0,0 @@
-/**
- * Cache Strategy Planner — uses the helper model (or main model) to optimize
- * cache breakpoint placement for explicit-caching providers.
- * 
- * Two modes:
- *   1. Heuristic (default): Uses getDefaultStrategy() from cache-strategy.ts
- *   2. LLM-assisted: Sends context to the helper model for optimized strategy
- * 
- * The planner runs:
- *   - Once at session start (first turn)
- *   - Every N turns (configurable, default 10)
- *   - When cache hit rate drops below threshold
- */
-
-import type {
-  CacheStrategy,
-  CacheContext,
-  CacheBreakpoint,
-  CacheHitTracker,
-} from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
-import { getDefaultStrategy } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
-import { getCacheCapability } from '@pellux/goodvibes-sdk/platform/providers/cache-capability';
-import type { ProviderCacheCapability } from '@pellux/goodvibes-sdk/platform/providers/cache-capability';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
-import type { HelperModel } from '@pellux/goodvibes-sdk/platform/config/helper-model';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-/** Result of a strategy planning run. */
-export interface PlanResult {
-  strategy: CacheStrategy;
-  source: 'heuristic' | 'helper' | 'cached';
-  planTimeMs: number;
-}
-
-/**
- * CachePlanner — manages cache strategy lifecycle.
- * 
- * Caches the current strategy and refreshes it based on
- * turn count and hit rate thresholds.
- */
-export class CachePlanner {
-  private currentStrategy: CacheStrategy | null = null;
-  private lastPlanTurn = 0;
-  private turnsSinceLastPlan = 0;
-  private readonly cacheHitTracker: Pick<CacheHitTracker, 'getMetrics'>;
-
-  constructor(
-    private readonly configManager: Pick<ConfigManager, 'get'>,
-    private readonly helperModel: Pick<HelperModel, 'chat'>,
-    cacheHitTracker: Pick<CacheHitTracker, 'getMetrics'>,
-  ) {
-    this.cacheHitTracker = cacheHitTracker;
-  }
-
-  /**
-   * Get the current cache strategy, planning a new one if needed.
-   * 
-   * Triggers re-planning when:
-   *   - No strategy exists yet (first call)
-   *   - refreshAfterTurns threshold reached
-   *   - Cache hit rate dropped below warning threshold
-   */
-  async getStrategy(context: CacheContext): Promise<PlanResult> {
-    const startMs = Date.now();
-    this.turnsSinceLastPlan++;
-
-    // Check if we need to refresh
-    const needsRefresh = this.shouldRefresh(context);
-
-    if (this.currentStrategy && !needsRefresh) {
-      return {
-        strategy: this.currentStrategy,
-        source: 'cached',
-        planTimeMs: Date.now() - startMs,
-      };
-    }
-
-    // Try LLM-assisted planning first (if helper enabled)
-    const helperEnabled = this.configManager.get('helper.enabled') as boolean;
-    const cap = getCacheCapability(context.providerName);
-
-    if (helperEnabled && cap.type === 'explicit') {
-      try {
-        const helperStrategy = await this.planWithHelper(context, cap);
-        if (helperStrategy) {
-          this.currentStrategy = helperStrategy;
-          this.lastPlanTurn = this.turnsSinceLastPlan;
-          this.turnsSinceLastPlan = 0;
-          return {
-            strategy: helperStrategy,
-            source: 'helper',
-            planTimeMs: Date.now() - startMs,
-          };
-        }
-      } catch (err) {
-        logger.debug('[CachePlanner] Helper planning failed, falling back to heuristic', {
-          error: summarizeError(err),
-        });
-      }
-    }
-
-    // Fallback: heuristic strategy
-    const heuristicStrategy = getDefaultStrategy(context);
-    this.currentStrategy = heuristicStrategy;
-    this.lastPlanTurn = this.turnsSinceLastPlan;
-    this.turnsSinceLastPlan = 0;
-
-    return {
-      strategy: heuristicStrategy,
-      source: 'heuristic',
-      planTimeMs: Date.now() - startMs,
-    };
-  }
-
-  /** Check if strategy needs refresh. */
-  private shouldRefresh(context: CacheContext): boolean {
-    // No strategy yet
-    if (!this.currentStrategy) return true;
-
-    // Refresh interval reached
-    if (
-      this.currentStrategy.refreshAfterTurns > 0 &&
-      this.turnsSinceLastPlan >= this.currentStrategy.refreshAfterTurns
-    ) {
-      return true;
-    }
-
-    // Hit rate dropped below threshold
-    const hitRateThreshold = this.configManager.get('cache.hitRateWarningThreshold') as number;
-    if (
-      context.recentCacheHitRate !== undefined &&
-      context.recentCacheHitRate < hitRateThreshold &&
-      this.cacheHitTracker.getMetrics().turns >= 3 // Need enough data
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Use the helper model to plan an optimized cache strategy.
-   * Returns null if the helper can't produce a valid strategy.
-   */
-  private async planWithHelper(
-    context: CacheContext,
-    cap: ProviderCacheCapability,
-  ): Promise<CacheStrategy | null> {
-    const prompt = this.buildHelperPrompt(context, cap);
-
-    const response = await this.helperModel.chat('cache_strategy', prompt, {
-      maxTokens: 1024,
-      systemPrompt: 'You are a cache optimization assistant. Respond ONLY with valid JSON matching the requested schema. No markdown, no explanation.',
-    });
-
-    if (!response) return null;
-
-    try {
-      // Extract JSON from response (handle potential markdown wrapping)
-      let jsonStr = response.trim();
-      if (jsonStr.startsWith('```')) {
-        jsonStr = jsonStr.replace(/^```(?:json)?\s*/, '').replace(/\s*```$/, '');
-      }
-
-      const parsed = JSON.parse(jsonStr) as {
-        breakpoints?: Array<{
-          position?: string;
-          ttl?: string;
-          ttlSeconds?: number;
-          reason?: string;
-        }>;
-        refreshAfterTurns?: number;
-      };
-
-      if (!parsed.breakpoints || !Array.isArray(parsed.breakpoints)) {
-        logger.debug('[CachePlanner] Helper returned invalid structure');
-        return null;
-      }
-
-      // Validate and sanitize breakpoints
-      const validPositions = new Set(['system_and_tools', 'conversation_prefix', 'last_tool_result', 'dynamic']);
-      const validTtls = new Set(['5m', '1h']);
-
-      const breakpoints: CacheBreakpoint[] = parsed.breakpoints
-        .filter(bp => bp.position && validPositions.has(bp.position) && bp.ttl && validTtls.has(bp.ttl))
-        .map(bp => ({
-          position: bp.position as CacheBreakpoint['position'],
-          ttl: bp.ttl!,
-          ttlSeconds: bp.ttl === '1h' ? 3600 : 300,
-          reason: bp.reason ?? 'Helper-planned breakpoint',
-        }));
-
-      // Enforce TTL ordering constraint: longer TTLs must come first
-      breakpoints.sort((a, b) => b.ttlSeconds - a.ttlSeconds);
-
-      // Enforce max breakpoints
-      if (cap.type === 'explicit') {
-        breakpoints.splice(cap.maxBreakpoints);
-      }
-
-      if (breakpoints.length === 0) {
-        logger.debug('[CachePlanner] Helper produced no valid breakpoints');
-        return null;
-      }
-
-      return {
-        breakpoints,
-        prefixStable: true,
-        refreshAfterTurns: parsed.refreshAfterTurns ?? 10,
-      };
-    } catch (err) {
-      logger.debug('[CachePlanner] Failed to parse helper response', {
-        error: summarizeError(err),
-        response: response.slice(0, 200),
-      });
-      return null;
-    }
-  }
-
-  /** Build the prompt for the helper model. */
-  private buildHelperPrompt(context: CacheContext, cap: ProviderCacheCapability): string {
-    return `Optimize cache breakpoint placement for an LLM API request.
-
-Provider: ${context.providerName}
-Cache type: ${cap.type}
-Max breakpoints: ${cap.type === 'explicit' ? cap.maxBreakpoints : 'N/A'}
-Available TTLs: ${cap.type === 'explicit' ? cap.ttlOptions.map(t => `${t.label} (${t.writeCostMultiplier}x write)`).join(', ') : 'N/A'}
-Read discount: ${cap.type === 'explicit' || cap.type === 'automatic' ? `${((1 - cap.readDiscount) * 100).toFixed(0)}% off` : 'N/A'}
-Min cacheable tokens: ${cap.type === 'explicit' ? cap.minCacheableTokens : 'N/A'}
-
-Current request context:
-- System prompt: ~${context.systemPromptTokens} tokens
-- Tools: ${context.toolCount} tools, ~${context.toolTokens} tokens
-- Conversation: ${context.conversationTurns} turns, ~${context.conversationTokens} tokens
-- Recent cache hit rate: ${context.recentCacheHitRate !== undefined ? `${(context.recentCacheHitRate * 100).toFixed(0)}%` : 'unknown'}
-
-Rules:
-- system_and_tools content NEVER changes during a session \u2192 prefer longest TTL
-- conversation_prefix grows each turn but old turns are stable \u2192 5m TTL (refreshes on read)
-- Longer TTL breakpoints MUST come before shorter TTL in content order
-- Only place breakpoints if content exceeds ${cap.type === 'explicit' ? cap.minCacheableTokens : 1024} token minimum
-
-Respond with JSON only:
-{
-  "breakpoints": [
-    { "position": "system_and_tools|conversation_prefix|last_tool_result|dynamic", "ttl": "5m|1h", "reason": "brief explanation" }
-  ],
-  "refreshAfterTurns": 10
-}`;
-  }
-
-  /** Force a strategy refresh on the next getStrategy() call. */
-  invalidate(): void {
-    this.currentStrategy = null;
-  }
-
-}

package/src/providers/capabilities.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/providers/capabilities';

package/src/providers/custom-loader.ts

@@ -1,425 +0,0 @@
-import * as fs from 'fs';
-import * as fsPromises from 'fs/promises';
-import * as path from 'path';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import { emitProviderWarning } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import { OpenAICompatProvider } from '@pellux/goodvibes-sdk/platform/providers/openai-compat';
-import { AnthropicCompatProvider } from '@pellux/goodvibes-sdk/platform/providers/anthropic-compat';
-import type { LLMProvider } from '@pellux/goodvibes-sdk/platform/providers/interface';
-import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers/registry';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-import {
-  LocalContextIngestionService,
-  resolveContextWindow,
-} from '@pellux/goodvibes-sdk/platform/providers/local-context-ingestion';
-
-/** Debounce delay for file watcher (ms). */
-const WATCH_DEBOUNCE_MS = 300;
-
-/**
- * JSON schema for a custom provider configuration file.
- * Place a *.json file in ~/.goodvibes/tui/providers/ to define a custom provider.
- */
-export interface CustomProviderConfig {
-  /** Unique provider identifier, e.g. 'ollama' */
-  name: string;
-  /** Human-friendly display name, e.g. 'Ollama' */
-  displayName: string;
-  /**
-   * API compatibility type.
-   * - 'openai-compat': provider speaks the OpenAI Chat Completions API
-   * - 'anthropic-compat': provider speaks the Anthropic Messages API (SSE streaming)
-   */
-  type: 'openai-compat' | 'anthropic-compat';
-  /** Base URL for the API, e.g. 'http://localhost:11434/v1' */
-  baseURL: string;
-  /** Optional env var name whose value is used as the API key */
-  apiKeyEnv?: string;
-  /** Optional explicit API key (takes precedence over apiKeyEnv) */
-  apiKey?: string;
-  /** Optional extra HTTP headers sent with every request */
-  defaultHeaders?: Record<string, string>;
-  /** How to send reasoning params. Default: 'none' (don't send). */
-  reasoningFormat?: 'mercury' | 'openrouter' | 'llamacpp' | 'none';
-  /** List of models exposed by this provider */
-  models: Array<{
-    id: string;
-    displayName: string;
-    description?: string;
-    contextWindow: number;
-    selectable?: boolean;
-    capabilities: {
-      toolCalling: boolean;
-      codeEditing: boolean;
-      reasoning: boolean;
-      multimodal: boolean;
-    };
-    reasoningEffort?: string[];
-    /** Model capability tier — controls system prompt verbosity. */
-    tier?: 'free' | 'standard' | 'premium';
-  }>;
-}
-
-/** Result of loading all custom providers from disk. */
-export interface LoadCustomProvidersResult {
-  providers: Array<{ config: CustomProviderConfig; provider: LLMProvider }>;
-  models: ModelDefinition[];
-  warnings: string[];
-}
-
-/** Options for loadCustomProviders. */
-export interface LoadCustomProvidersOptions {
-  /** Directory that owns custom provider JSON files. */
-  providersDir: string;
-  /**
-   * When true, attempts to fetch max_context_length from each provider's
-   * /v1/models endpoint and uses the reported value with 'provider_api'
-   * provenance. Falls back to the configured contextWindow or DEFAULT_CONTEXT_WINDOW.
-   * Defaults to false.
-   */
-  ingestContextWindows?: boolean;
-  contextIngestion?: Pick<LocalContextIngestionService, 'ingestProviderContextWindows'>;
-}
-
-/**
- * Resolve API key from config.
- * Priority: explicit apiKey > env var (apiKeyEnv) > empty string.
- */
-function resolveApiKey(config: CustomProviderConfig): string {
-  if (config.apiKey) return config.apiKey;
-  if (config.apiKeyEnv) {
-    const val = process.env[config.apiKeyEnv];
-    if (val) return val;
-  }
-  return '';
-}
-
-/**
- * Validate a single parsed JSON object against the CustomProviderConfig schema.
- * Returns { valid, errors } — errors is empty when valid.
- */
-function validateCustomProvider(data: unknown): { valid: boolean; errors: string[] } {
-  const errors: string[] = [];
-
-  if (typeof data !== 'object' || data === null || Array.isArray(data)) {
-    return { valid: false, errors: ['Root value must be a JSON object'] };
-  }
-
-  const obj = data as Record<string, unknown>;
-
-  if (typeof obj['name'] !== 'string' || obj['name'].trim() === '') {
-    errors.push('"name" must be a non-empty string');
-  }
-
-  if (typeof obj['displayName'] !== 'string' || obj['displayName'].trim() === '') {
-    errors.push('"displayName" must be a non-empty string');
-  }
-
-  if (obj['type'] !== 'openai-compat' && obj['type'] !== 'anthropic-compat') {
-    errors.push('"type" must be "openai-compat" or "anthropic-compat"');
-  }
-
-  if (typeof obj['baseURL'] !== 'string' || obj['baseURL'].trim() === '') {
-    errors.push('"baseURL" must be a non-empty string');
-  }
-
-  if (obj['reasoningFormat'] !== undefined) {
-    if (!['mercury', 'openrouter', 'llamacpp', 'none'].includes(obj['reasoningFormat'] as string)) {
-      errors.push('"reasoningFormat" must be "mercury", "openrouter", "llamacpp", or "none"');
-    }
-  }
-
-  if (!Array.isArray(obj['models']) || (obj['models'] as unknown[]).length === 0) {
-    errors.push('"models" must be a non-empty array');
-  } else {
-    const models = obj['models'] as unknown[];
-    models.forEach((m, i) => {
-      if (typeof m !== 'object' || m === null || Array.isArray(m)) {
-        errors.push(`models[${i}]: must be an object`);
-        return;
-      }
-      const model = m as Record<string, unknown>;
-      if (typeof model['id'] !== 'string' || model['id'].trim() === '') {
-        errors.push(`models[${i}]: "id" must be a non-empty string`);
-      }
-      if (typeof model['displayName'] !== 'string' || model['displayName'].trim() === '') {
-        errors.push(`models[${i}]: "displayName" must be a non-empty string`);
-      }
-      if (typeof model['contextWindow'] !== 'number' || model['contextWindow'] <= 0) {
-        errors.push(`models[${i}]: "contextWindow" must be a positive number`);
-      }
-      if (typeof model['capabilities'] !== 'object' || model['capabilities'] === null) {
-        errors.push(`models[${i}]: "capabilities" must be an object`);
-      } else {
-        const caps = model['capabilities'] as Record<string, unknown>;
-        for (const cap of ['toolCalling', 'codeEditing', 'reasoning', 'multimodal']) {
-          if (typeof caps[cap] !== 'boolean') {
-            errors.push(`models[${i}]: capabilities.${cap} must be a boolean`);
-          }
-        }
-      }
-    });
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Ensure the providers directory exists, creating it if necessary.
- */
-async function ensureProvidersDir(providersDir: string): Promise<void> {
-  try {
-    await fsPromises.mkdir(providersDir, { recursive: true });
-  } catch (err) {
-    throw new Error(
-      `[custom-loader] Failed to create providers directory '${providersDir}': ${
-        summarizeError(err)
-      }`,
-    );
-  }
-}
-
-/**
- * Load all custom providers from an owned providers directory.
- * Auto-creates the directory if it does not exist.
- * Invalid files are skipped with a warning rather than failing the whole load.
- *
- * When `options.ingestContextWindows` is true, each provider's /v1/models
- * endpoint is queried concurrently (via Promise.allSettled) to resolve
- * `max_context_length` with `provider_api` provenance.
- */
-export async function loadCustomProviders(
-  options: LoadCustomProvidersOptions,
-): Promise<LoadCustomProvidersResult> {
-  const warnings: string[] = [];
-  const providers: Array<{ config: CustomProviderConfig; provider: LLMProvider }> = [];
-  const models: ModelDefinition[] = [];
-  const { providersDir } = options;
-
-  await ensureProvidersDir(providersDir);
-
-  let entries: string[];
-  try {
-    const dirents = await fsPromises.readdir(providersDir, { withFileTypes: true });
-    entries = dirents
-      .filter((d) => d.isFile() && d.name.endsWith('.json'))
-      .map((d) => d.name);
-  } catch (err) {
-    warnings.push(
-      `[custom-loader] Could not read providers directory: ${
-        summarizeError(err)
-      }`,
-    );
-    return { providers, models, warnings };
-  }
-
-  // Phase 1: Parse and validate all provider files, instantiate provider objects.
-  // Collect valid entries; skip invalid ones with warnings.
-  const validConfigs: Array<{ cfg: CustomProviderConfig; provider: LLMProvider; apiKey: string }> = [];
-
-  for (const filename of entries) {
-    const filepath = path.join(providersDir, filename);
-    let raw: string;
-    try {
-      raw = await fsPromises.readFile(filepath, 'utf-8');
-    } catch (err) {
-      warnings.push(
-        `[custom-loader] Could not read '${filename}': ${
-          summarizeError(err)
-        }`,
-      );
-      continue;
-    }
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch (err) {
-      warnings.push(
-        `[custom-loader] Invalid JSON in '${filename}': ${
-          summarizeError(err)
-        }`,
-      );
-      continue;
-    }
-
-    const { valid, errors } = validateCustomProvider(parsed);
-    if (!valid) {
-      warnings.push(
-        `[custom-loader] Skipping '${filename}' — validation errors:\n  ${errors.join('\n  ')}`,
-      );
-      continue;
-    }
-
-    const cfg = parsed as CustomProviderConfig;
-
-    const apiKey = resolveApiKey(cfg);
-    const modelIds = cfg.models.map((m) => m.id);
-
-    let provider: LLMProvider;
-    try {
-      if (cfg.type === 'anthropic-compat') {
-        provider = new AnthropicCompatProvider({
-          name: cfg.name,
-          baseURL: cfg.baseURL,
-          apiKey,
-          defaultModel: modelIds[0]!,
-          models: modelIds,
-          ...(cfg.defaultHeaders ? { defaultHeaders: cfg.defaultHeaders } : {}),
-        });
-      } else {
-        provider = new OpenAICompatProvider({
-          name: cfg.name,
-          baseURL: cfg.baseURL,
-          apiKey,
-          defaultModel: modelIds[0]!,
-          models: modelIds,
-          ...(cfg.defaultHeaders ? { defaultHeaders: cfg.defaultHeaders } : {}),
-          reasoningFormat: cfg.reasoningFormat ?? 'none',
-        });
-      }
-    } catch (err) {
-      warnings.push(
-        `[custom-loader] Failed to instantiate provider from '${filename}': ${
-          summarizeError(err)
-        }`,
-      );
-      continue;
-    }
-
-    validConfigs.push({ cfg, provider, apiKey });
-  }
-
-  // Phase 2: Ingest context windows concurrently for all valid providers.
-  // Runs only when options.ingestContextWindows is true.
-  const ingestionResults: Array<Map<string, number> | null> = validConfigs.map(() => null);
-  if (options.ingestContextWindows && options.contextIngestion && validConfigs.length > 0) {
-    const ingestionPromises = validConfigs.map(({ cfg, apiKey }) =>
-      options.contextIngestion?.ingestProviderContextWindows(
-        cfg.name,
-        cfg.baseURL,
-        apiKey || undefined,
-      ),
-    );
-    const settled = await Promise.allSettled(ingestionPromises);
-    for (let i = 0; i < settled.length; i++) {
-      const result = settled[i];
-      if (result) {
-        ingestionResults[i] = result.status === 'fulfilled' ? (result.value ?? null) : null;
-      }
-    }
-  }
-
-  // Phase 3: Build model definitions and populate output arrays.
-  for (let i = 0; i < validConfigs.length; i++) {
-    const { cfg, provider } = validConfigs[i]!;
-    const apiContextMap = ingestionResults[i] ?? null;
-
-    const modelDefs: ModelDefinition[] = cfg.models.map((m) => {
-      const apiContextLength = apiContextMap?.get(m.id) ?? null;
-      const resolved = resolveContextWindow(m.id, apiContextLength, m.contextWindow);
-      return {
-        id: m.id,
-        provider: cfg.name,
-        registryKey: `${cfg.name}:${m.id}`,
-        displayName: m.displayName,
-        description: m.description ?? '',
-        contextWindow: resolved.tokens,
-        contextWindowProvenance: resolved.provenance,
-        selectable: m.selectable ?? true,
-        capabilities: {
-          toolCalling: m.capabilities.toolCalling,
-          codeEditing: m.capabilities.codeEditing,
-          reasoning: m.capabilities.reasoning,
-          multimodal: m.capabilities.multimodal,
-        },
-        ...(m.reasoningEffort ? { reasoningEffort: m.reasoningEffort } : {}),
-        ...(m.tier ? { tier: m.tier } : {}),
-      };
-    });
-
-    providers.push({ config: cfg, provider });
-    models.push(...modelDefs);
-  }
-
-  return { providers, models, warnings };
-}
-
-/**
- * Start watching an owned providers directory for file changes.
- * Debounces rapid events by 300ms before invoking the onChange callback.
- * Emits typed provider warnings if the watcher cannot be started.
- * Returns a handle with a `close()` method to stop watching.
- */
-export function watchCustomProviders(
-  runtimeBus: RuntimeEventBus | null,
-  onChange: () => void,
-  providersDir: string,
-): { close: () => void } {
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  let watcher: fs.FSWatcher | null = null;
-  let closed = false;
-
-  const emitWarning = (message: string): void => {
-    if (runtimeBus) {
-      emitProviderWarning(runtimeBus, {
-        sessionId: 'system',
-        traceId: `providers:warning:${Date.now()}`,
-        source: 'custom-provider-loader',
-      }, { message });
-    }
-  };
-
-  const startWatch = () => {
-    if (closed) return;
-    try {
-      // Note: fs.watch() may miss atomic renames (e.g. editor save-via-rename) on
-      // some Linux filesystems. If that becomes a problem, consider replacing this
-      // with the 'chokidar' library which uses inotify directly.
-      watcher = fs.watch(
-        providersDir,
-        { persistent: false }, // Don't keep the Node process alive just for this watcher
-        (_eventType, _filename) => {
-        if (debounceTimer) clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-          debounceTimer = null;
-          onChange();
-        }, WATCH_DEBOUNCE_MS);
-      });
-
-      watcher.on('error', (err) => {
-        if (closed) return;
-        emitWarning(`[custom-loader] Watcher error: ${err.message}`);
-      });
-    } catch (err) {
-      if (closed) return;
-      emitWarning(`[custom-loader] Could not watch providers directory: ${summarizeError(err)}`);
-    }
-  };
-
-  // Ensure the directory exists before starting the watcher
-  fsPromises
-    .mkdir(providersDir, { recursive: true })
-    .then(() => {
-      if (closed) return;
-      startWatch();
-    })
-    .catch((err) => {
-      if (closed) return;
-      emitWarning(`[custom-loader] Could not create/watch providers directory: ${summarizeError(err)}`);
-    });
-
-  return {
-    close() {
-      closed = true;
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-        debounceTimer = null;
-      }
-      if (watcher) {
-        watcher.close();
-        watcher = null;
-      }
-    },
-  };
-}

package/src/providers/discovered-compat.ts

@@ -1,7 +0,0 @@
-export type { DiscoveredCompatOptions } from '@pellux/goodvibes-sdk/platform/providers/discovered-compat';
-export {
-  LocalAIProvider,
-  LlamaCppProvider,
-  TGIProvider,
-  VLLMProvider,
-} from '@pellux/goodvibes-sdk/platform/providers/discovered-compat';