@arthovlabs/liber 0.0.0-stage → 0.5.0

package/src/daemon/llm/manager.js

@@ -0,0 +1,134 @@
+// src/daemon/llm/manager.js
+const OllamaAdapter = require('./adapters/ollama-adapter');
+const OpenAIAdapter = require('./adapters/openai-adapter');
+const AnthropicAdapter = require('./adapters/anthropic-adapter');
+const GeminiAdapter = require('./adapters/gemini-adapter');
+
+class LLMManager {
+  constructor() {
+    this.adapters = {
+      ollama: OllamaAdapter,
+      openai: OpenAIAdapter,
+      anthropic: AnthropicAdapter,
+      gemini: GeminiAdapter
+      // Provider baru tinggal ditambahkan di sini
+    };
+    this.activeAdapter = null;
+    this.retry = { attempts: 3, baseMs: 700 };
+  }
+
+  /**
+   * Inisialisasi adapter berdasarkan konfigurasi di liber.yaml
+   * @param {Object} config - Bagian 'engine' dari liber.yaml
+   */
+  initialize(config) {
+    this.engineConfig = { ...config };
+    const ProviderClass = this.adapters[config.provider];
+    if (!ProviderClass) {
+      throw new Error(`Unsupported LLM provider: ${config.provider}`);
+    }
+    
+    console.log(`[Liber-Daemon] Initializing LLM engine: ${config.provider} (${config.model})`);
+    this.retry = {
+      attempts: Math.max(1, Math.min(parseInt(config.retry_attempts, 10) || 3, 6)),
+      baseMs: Math.max(100, parseInt(config.retry_base_ms, 10) || 700)
+    };
+    this.activeAdapter = new ProviderClass(config);
+    return this.activeAdapter;
+  }
+
+  isRetryable(err) {
+    const msg = String(err?.message || '');
+    if (/HTTP (400|401|403|404|422)\b/.test(msg)) return false; // client errors: retrying cannot help
+    return /HTTP (429|5\d\d)|timeout|timed out|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|fetch failed|network|socket hang up|aborted/i.test(msg);
+  }
+
+  /**
+   * Retry the same request on the next model of the SAME provider/endpoint.
+   * That is all a single-key setup can do: same base URL and key, different
+   * model id, so a dead or over-quota model does not kill the turn.
+   */
+  async _withModelFallback(fn, canRetry = () => true) {
+    const base = this.engineConfig || {};
+    const chain = [base.model, ...(Array.isArray(base.fallback_models) ? base.fallback_models : [])]
+      .map(m => String(m || '').trim())
+      .filter((m, i, all) => m && all.indexOf(m) === i);
+    let index = 0;
+    let lastErr;
+    for (;;) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        const next = chain[index + 1];
+        if (!next || !canRetry()) break;
+        try {
+          this.initialize({ ...base, model: next });
+        } catch (initErr) {
+          lastErr = initErr;
+          break;
+        }
+        this.lastFallback = { from: chain[index], to: next, error: String(err && err.message || err).slice(0, 200), at: Date.now() };
+        if (typeof this.onFallback === 'function') { try { this.onFallback(this.lastFallback); } catch { /* never break a turn */ } }
+        index++;
+      }
+    }
+    throw lastErr;
+  }
+
+  async generate(messages, options = {}) {
+    if (!this.activeAdapter) throw new Error("LLM Engine not initialized. Call initialize() first.");
+    return this._withModelFallback(() => this._withRetry(() => this.activeAdapter.generate(messages, options)));
+  }
+
+  /**
+   * Native tool calling: returns { content, tool_calls, finish_reason }.
+   */
+  async generateChat(messages, options = {}) {
+    if (!this.activeAdapter) throw new Error("LLM Engine not initialized. Call initialize() first.");
+    if (typeof this.activeAdapter.chat !== 'function') {
+      throw new Error('Active adapter does not support native tool calling.');
+    }
+    return this._withModelFallback(() => this._withRetry(() => this.activeAdapter.chat(messages, options)));
+  }
+
+  async _withRetry(fn) {
+    let lastErr;
+    for (let attempt = 1; attempt <= this.retry.attempts; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        const canRetry = attempt < this.retry.attempts && this.isRetryable(err);
+        if (!canRetry) throw err;
+        const wait = Math.min(this.retry.baseMs * 2 ** (attempt - 1), 8000);
+        console.warn(`[Liber-Daemon] LLM error (${err.message}) — retry ${attempt}/${this.retry.attempts} in ${wait}ms`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+    throw lastErr;
+  }
+
+  getLastUsage() {
+    return this.activeAdapter?.lastUsage || null;
+  }
+
+  /** Chain of thought the provider returned on the most recent call, if any. */
+  getLastReasoning() {
+    return this.activeAdapter?.lastReasoning || null;
+  }
+
+  async stream(messages, onChunk, options = {}) {
+    if (!this.activeAdapter) throw new Error("LLM Engine not initialized. Call initialize() first.");
+    if (typeof this.activeAdapter.stream !== 'function') {
+      throw new Error('Active adapter does not support streaming.');
+    }
+    // A stream that already emitted text cannot be replayed: falling back would
+    // duplicate the partial answer, so retry only while nothing was sent.
+    let emitted = false;
+    const guard = (t) => { emitted = true; onChunk(t); };
+    return this._withModelFallback(() => this.activeAdapter.stream(messages, guard, options), () => !emitted);
+  }
+}
+
+module.exports = new LLMManager();

package/src/utils/config-loader.js

@@ -0,0 +1,109 @@
+// src/utils/config-loader.js
+const fs = require('fs');
+const yaml = require('js-yaml');
+const path = require('path');
+
+const KEY_ENV = {
+  openai: ['OPENAI_API_KEY', 'OLLAMA_CLOUD_API_KEY'],
+  anthropic: ['ANTHROPIC_API_KEY'],
+  gemini: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+  ollama: ['OLLAMA_CLOUD_API_KEY', 'OPENAI_API_KEY']
+};
+
+// OpenAI-compatible vendors use their own key names — resolve by endpoint host.
+const ENDPOINT_KEY_ENV = [
+  [/groq\.com/i, ['GROQ_API_KEY']],
+  [/deepseek\.com/i, ['DEEPSEEK_API_KEY']],
+  [/mistral\.ai/i, ['MISTRAL_API_KEY']],
+  [/openrouter\.ai/i, ['OPENROUTER_API_KEY']],
+  [/api\.x\.ai/i, ['XAI_API_KEY']],
+  [/together\.xyz/i, ['TOGETHER_API_KEY']],
+  [/ollama\.com/i, ['OLLAMA_CLOUD_API_KEY']],
+  [/api\.openai\.com/i, ['OPENAI_API_KEY']],
+  [/anthropic\.com/i, ['ANTHROPIC_API_KEY']],
+  [/generativelanguage\.googleapis\.com/i, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']],
+  [/localhost|127\.0\.0\.1/i, []] // local Ollama needs no key
+];
+
+function envVarsFromFile() {
+  try {
+    const envPath = path.resolve(process.cwd(), '.env');
+    if (!fs.existsSync(envPath)) return {};
+    return Object.fromEntries(
+      fs.readFileSync(envPath, 'utf8').split(/\r?\n/).filter(line => line.includes('=') && !line.trim().startsWith('#')).map(line => {
+        const idx = line.indexOf('=');
+        return [line.slice(0, idx).trim(), line.slice(idx + 1).trim()];
+      })
+    );
+  } catch {
+    return {};
+  }
+}
+
+function lookup(names) {
+  const fromEnv = names.map(n => process.env[n]).find(Boolean);
+  if (fromEnv) return fromEnv;
+  const file = envVarsFromFile();
+  return names.map(n => file[n]).find(Boolean) || null;
+}
+
+/**
+ * Provider + endpoint aware key resolution: the endpoint host decides the key
+ * name first (Groq/DeepSeek/Mistral/... each have their own), then the provider.
+ * Process environment always wins over .env.
+ */
+function resolveApiKey(provider, endpoint) {
+  // A key stored through the UI (or imported from a CLI) wins over the
+  // environment, so the Providers page is the source of truth on this machine.
+  try {
+    const providers = require('../daemon/core/providers');
+    const stored = providers.resolveStored(provider, endpoint);
+    if (stored) return stored;
+  } catch { /* provider store unavailable: fall through to env */ }
+
+  const ep = String(endpoint || '');
+  for (const [re, names] of ENDPOINT_KEY_ENV) {
+    if (re.test(ep)) return names.length ? lookup(names) : null;
+  }
+  const envNames = KEY_ENV[String(provider || 'openai').toLowerCase()] || KEY_ENV.openai;
+  return lookup(envNames);
+}
+
+class ConfigLoader {
+  static load(configPath = 'liber.yaml') {
+    try {
+      // 1. Load YAML config
+      const absolutePath = path.resolve(process.cwd(), configPath);
+      const fileContents = fs.readFileSync(absolutePath, 'utf8');
+      const config = yaml.load(fileContents);
+
+      // 2. Secret Management: provider-aware key from environment or .env
+      const engine = config.agent?.engine;
+      if (engine && !engine.provider) {
+        // A null provider used to kill the whole daemon at boot
+        // ("Unsupported LLM provider: null"). Fall back to the OpenAI-compatible
+        // adapter the config comment already promises, and say so out loud.
+        engine.provider = 'openai';
+        console.warn('[config] engine.provider was empty — defaulting to the openai-compatible adapter.');
+      }
+      if (engine && !engine.endpoint) {
+        console.warn('[config] engine.endpoint is empty — every request will fail until a provider endpoint is set.');
+      }
+
+      const provider = (config.agent?.engine?.provider || 'openai').toLowerCase();
+      const envKey = resolveApiKey(provider);
+
+      if (envKey && config.agent?.engine) {
+        config.agent.engine.apiKey = envKey;
+      }
+
+      return config;
+    } catch (e) {
+      console.error(`[Error] Failed to load config: ${e.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = ConfigLoader;
+module.exports.resolveApiKey = resolveApiKey;

package/src/utils/logger.js

@@ -0,0 +1,56 @@
+// src/utils/logger.js
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+  constructor() {
+    this.logFile = path.join(process.cwd(), 'liber.log');
+  }
+
+  // Structured logging for production telemetry
+  info(agentId, event, details) {
+    this._write('INFO', agentId, event, details);
+  }
+
+  warn(agentId, event, details) {
+    this._write('WARN', agentId, event, details);
+  }
+
+  error(agentId, event, details) {
+    this._write('ERROR', agentId, event, details);
+  }
+
+  _write(level, agentId, event, details) {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      agentId,
+      event,
+      details
+    };
+    const logString = JSON.stringify(logEntry);
+    
+    // Console for TUI, File for Telemetry
+    console.log(`[${level}] ${agentId} | ${event}`);
+    try {
+      this._rotateIfNeeded();
+      fs.appendFileSync(this.logFile, logString + '\n');
+    } catch {
+      // never let logging break the harness
+    }
+  }
+
+  _rotateIfNeeded() {
+    const MAX = 5 * 1024 * 1024; // 5 MB
+    try {
+      const stat = fs.statSync(this.logFile);
+      if (stat.size > MAX) {
+        fs.renameSync(this.logFile, `${this.logFile}.1`);
+      }
+    } catch {
+      // file missing or unreadable — nothing to rotate
+    }
+  }
+}
+
+module.exports = new Logger();