ruby_llm_mesh 0.1.0 → 2.2.0

data/ext/chimera_core/src/lib.rs

@@ -0,0 +1,194 @@
+//! chimera_core — sovereign mesh node for ruby_llm_mesh.
+//!
+//! Exposes a C ABI for Ruby FFI:
+//! - `start_node(port) -> bool`
+//! - `node_alive() -> bool`
+//! - `execute_wasm_payload(intent) -> *mut c_char` (JSON; caller frees via `chimera_free_string`)
+//! - `stop_node() -> bool`
+
+use std::ffi::{CStr, CString};
+use std::io::{Read, Write};
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::os::raw::c_char;
+use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
+use std::thread;
+use std::time::Duration;
+
+static ALIVE: AtomicBool = AtomicBool::new(false);
+static PORT: AtomicU16 = AtomicU16::new(0);
+static STOP: AtomicBool = AtomicBool::new(false);
+
+/// Boot a lightweight mesh listener on `port`. Idempotent if already alive on same port.
+#[no_mangle]
+pub extern "C" fn start_node(port: u16) -> bool {
+    if ALIVE.load(Ordering::SeqCst) && PORT.load(Ordering::SeqCst) == port {
+        return true;
+    }
+
+    STOP.store(false, Ordering::SeqCst);
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    let listener = match TcpListener::bind(addr) {
+        Ok(l) => l,
+        Err(_) => return false,
+    };
+    if let Err(_) = listener.set_nonblocking(true) {
+        return false;
+    }
+
+    PORT.store(port, Ordering::SeqCst);
+    ALIVE.store(true, Ordering::SeqCst);
+
+    thread::spawn(move || {
+        while !STOP.load(Ordering::SeqCst) {
+            match listener.accept() {
+                Ok((stream, _)) => {
+                    let _ = handle_connection(stream);
+                }
+                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                    thread::sleep(Duration::from_millis(25));
+                }
+                Err(_) => {
+                    thread::sleep(Duration::from_millis(50));
+                }
+            }
+        }
+        ALIVE.store(false, Ordering::SeqCst);
+    });
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn stop_node() -> bool {
+    STOP.store(true, Ordering::SeqCst);
+    // Give the accept loop a moment to exit
+    thread::sleep(Duration::from_millis(40));
+    ALIVE.store(false, Ordering::SeqCst);
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn node_alive() -> bool {
+    ALIVE.load(Ordering::SeqCst)
+}
+
+/// Execute an intent payload natively and return a heap-allocated JSON C string.
+/// Caller must free with `chimera_free_string`.
+#[no_mangle]
+pub extern "C" fn execute_wasm_payload(intent: *const c_char) -> *mut c_char {
+    if intent.is_null() {
+        return to_c_string(error_json("null intent pointer"));
+    }
+
+    let c_str = unsafe { CStr::from_ptr(intent) };
+    let intent_str = match c_str.to_str() {
+        Ok(s) => s,
+        Err(_) => return to_c_string(error_json("invalid UTF-8 intent")),
+    };
+
+    let digest = simple_digest(intent_str);
+    let escaped = escape_json(intent_str);
+    let json = format!(
+        "{{\"ok\":true,\"engine\":\"chimera_core\",\"mode\":\"native_wasm\",\"alive\":{},\"port\":{},\"intent\":\"{}\",\"digest\":\"{:016x}\",\"output\":\"Native mesh executed intent ({})\"}}",
+        ALIVE.load(Ordering::SeqCst),
+        PORT.load(Ordering::SeqCst),
+        escaped,
+        digest,
+        truncate(&escaped, 64)
+    );
+    to_c_string(json)
+}
+
+#[no_mangle]
+pub extern "C" fn chimera_free_string(ptr: *mut c_char) {
+    if ptr.is_null() {
+        return;
+    }
+    unsafe {
+        let _ = CString::from_raw(ptr);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn chimera_core_version() -> *mut c_char {
+    to_c_string("2.0.0".to_string())
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let _ = stream.set_read_timeout(Some(Duration::from_millis(200)));
+    let mut buf = [0u8; 1024];
+    let _ = stream.read(&mut buf);
+    let body = "{\"status\":\"ok\",\"engine\":\"chimera_core\",\"alive\":true}";
+    let response = format!(
+        "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        body.len(),
+        body
+    );
+    let _ = stream.write_all(response.as_bytes());
+}
+
+fn to_c_string(s: String) -> *mut c_char {
+    match CString::new(s) {
+        Ok(c) => c.into_raw(),
+        Err(_) => CString::new("{\"ok\":false,\"error\":\"nul in string\"}")
+            .unwrap()
+            .into_raw(),
+    }
+}
+
+fn error_json(msg: &str) -> String {
+    format!(
+        "{{\"ok\":false,\"engine\":\"chimera_core\",\"error\":\"{}\"}}",
+        escape_json(msg)
+    )
+}
+
+fn escape_json(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for ch in s.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if c.is_control() => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+fn simple_digest(s: &str) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for b in s.as_bytes() {
+        h ^= u64::from(*b);
+        h = h.wrapping_mul(0x100000001b3);
+    }
+    h
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.chars().count() <= max {
+        s.to_string()
+    } else {
+        format!("{}…", s.chars().take(max).collect::<String>())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::CString;
+
+    #[test]
+    fn execute_returns_json() {
+        let intent = CString::new("ping mesh").unwrap();
+        let ptr = execute_wasm_payload(intent.as_ptr());
+        assert!(!ptr.is_null());
+        let s = unsafe { CStr::from_ptr(ptr) }.to_str().unwrap();
+        assert!(s.contains("chimera_core"));
+        assert!(s.contains("ping mesh"));
+        chimera_free_string(ptr);
+    }
+}

data/lib/ruby_llm_mesh/budget.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  class Budget
+    DEFAULT_PRICES = {
+      input_per_1k: 0.00015,
+      output_per_1k: 0.0006
+    }.freeze
+
+    attr_reader :tokens_consumed, :usd_consumed
+
+    def initialize(config: RubyLlmMesh.configuration)
+      @config = config
+      @tokens_consumed = 0
+      @usd_consumed = 0.0
+      @mutex = Mutex.new
+    end
+
+    def enabled?
+      @config.budget_enabled
+    end
+
+    def check!(estimated_tokens: 0, estimated_usd: 0.0)
+      return unless enabled?
+
+      @mutex.synchronize do
+        raise_budget_exceeded!("token", @tokens_consumed, @config.budget_max_tokens) if token_limit? && (@tokens_consumed + estimated_tokens) > @config.budget_max_tokens
+        raise_budget_exceeded!("usd", @usd_consumed, @config.budget_max_usd) if usd_limit? && (@usd_consumed + estimated_usd) > @config.budget_max_usd
+      end
+    end
+
+    def consume!(usage:, provider:, model:)
+      return unless enabled?
+
+      tokens = self.class.extract_tokens(usage)
+      usd = self.class.compute_cost(usage, provider: provider, model: model, config: @config)
+
+      @mutex.synchronize do
+        @tokens_consumed += tokens
+        @usd_consumed += usd
+        raise_budget_exceeded!("token", @tokens_consumed, @config.budget_max_tokens) if token_limit? && @tokens_consumed > @config.budget_max_tokens
+        raise_budget_exceeded!("usd", @usd_consumed, @config.budget_max_usd) if usd_limit? && @usd_consumed > @config.budget_max_usd
+      end
+    end
+
+    def status
+      {
+        enabled: enabled?,
+        tokens_consumed: @tokens_consumed,
+        tokens_max: @config.budget_max_tokens,
+        tokens_remaining: tokens_remaining,
+        usd_consumed: @usd_consumed.round(6),
+        usd_max: @config.budget_max_usd,
+        usd_remaining: usd_remaining
+      }
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @tokens_consumed = 0
+        @usd_consumed = 0.0
+      end
+    end
+
+    class << self
+      def instance(config: RubyLlmMesh.configuration)
+        @instances ||= {}
+        @instances[config.object_id] ||= new(config: config)
+      end
+
+      def reset!
+        @instances = {}
+      end
+
+      def estimate_tokens(prompt:, system: nil, max_tokens: nil)
+        text = [system, prompt].compact.join("\n")
+        estimated = (text.length / 4.0).ceil
+        estimated += max_tokens.to_i if max_tokens
+        estimated
+      end
+
+      def estimate_usd(tokens:, model: nil, config: RubyLlmMesh.configuration)
+        prices = resolve_prices(config, model)
+        (tokens / 1000.0) * prices[:input_per_1k]
+      end
+
+      def resolve_prices(config, model)
+        table = config.budget_prices || {}
+        entry = model ? table[model.to_s] || table[model.to_sym] : nil
+        entry ||= table[:default] || table["default"]
+        DEFAULT_PRICES.merge(entry || {})
+      end
+
+      def compute_cost(usage, provider:, model:, config: RubyLlmMesh.configuration)
+        prices = resolve_prices(config, model)
+        prompt_tokens = usage_value(usage, :prompt_tokens, :input_tokens)
+        completion_tokens = usage_value(usage, :completion_tokens, :output_tokens)
+        input_cost = (prompt_tokens / 1000.0) * prices[:input_per_1k]
+        output_cost = (completion_tokens / 1000.0) * prices[:output_per_1k]
+        input_cost + output_cost
+      end
+
+      def extract_tokens(usage)
+        usage_value(usage, :total_tokens, :prompt_tokens, :completion_tokens, :input_tokens, :output_tokens)
+      end
+
+      private
+
+      def usage_value(usage, *keys)
+        hash = usage.is_a?(Hash) ? usage : {}
+        keys.each do |key|
+          value = hash[key] || hash[key.to_s]
+          return value.to_i if value
+        end
+        hash["total_tokens"].to_i
+      end
+    end
+
+    private
+
+    def token_limit?
+      !@config.budget_max_tokens.nil?
+    end
+
+    def usd_limit?
+      !@config.budget_max_usd.nil?
+    end
+
+    def tokens_remaining
+      return nil unless token_limit?
+
+      [@config.budget_max_tokens - @tokens_consumed, 0].max
+    end
+
+    def usd_remaining
+      return nil unless usd_limit?
+
+      [(@config.budget_max_usd - @usd_consumed).round(6), 0.0].max
+    end
+
+    def raise_budget_exceeded!(dimension, consumed, limit)
+      raise BudgetExceededError.new(
+        "Budget exceeded: #{dimension} limit #{limit} (#{consumed} consumed)",
+        dimension: dimension.to_sym,
+        consumed: consumed,
+        limit: limit
+      )
+    end
+  end
+end

data/lib/ruby_llm_mesh/cache/memory_store.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyLlmMesh
+  module Cache
+    # Process-local vector entry store used when Redis is unavailable.
+    class MemoryStore
+      Entry = Struct.new(:id, :prompt, :embedding, :payload, :expires_at, keyword_init: true)
+
+      def initialize
+        @entries = []
+        @mutex = Mutex.new
+      end
+
+      def all
+        @mutex.synchronize do
+          now = Time.now
+          @entries.reject! { |e| e.expires_at && e.expires_at <= now }
+          @entries.map(&:dup)
+        end
+      end
+
+      def write(id:, prompt:, embedding:, payload:, ttl:)
+        expires_at = ttl && ttl.positive? ? Time.now + ttl : nil
+        entry = Entry.new(
+          id: id,
+          prompt: prompt,
+          embedding: embedding,
+          payload: payload,
+          expires_at: expires_at
+        )
+        @mutex.synchronize do
+          @entries.reject! { |e| e.id == id }
+          @entries << entry
+        end
+        true
+      end
+
+      def clear!
+        @mutex.synchronize { @entries.clear }
+      end
+
+      def size
+        all.length
+      end
+    end
+  end
+end

data/lib/ruby_llm_mesh/cache/redis_store.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+module RubyLlmMesh
+  module Cache
+    # Redis-backed store for distributed semantic cache entries.
+    # Requires the optional `redis` gem — soft-loaded only when configured.
+    class RedisStore
+      INDEX_KEY = "ruby_llm_mesh:semantic_cache:index"
+      ENTRY_PREFIX = "ruby_llm_mesh:semantic_cache:entry:"
+
+      def self.redis_available?
+        return @redis_available if defined?(@redis_available) && !@redis_available.nil?
+
+        begin
+          require "redis"
+          @redis_available = true
+        rescue LoadError
+          @redis_available = false
+        end
+      end
+
+      def initialize(url:)
+        unless self.class.redis_available?
+          raise ConfigurationError,
+                "semantic cache backend :redis requires the optional `redis` gem — " \
+                "add `gem \"redis\"` to your Gemfile or omit redis_url to use memory store"
+        end
+
+        @redis = ::Redis.new(url: url)
+      end
+
+      def all
+        ids = @redis.smembers(INDEX_KEY)
+        stale = []
+        entries = ids.filter_map do |id|
+          raw = @redis.get("#{ENTRY_PREFIX}#{id}")
+          unless raw
+            stale << id
+            next
+          end
+
+          data = JSON.parse(raw)
+          MemoryStore::Entry.new(
+            id: id,
+            prompt: data["prompt"],
+            embedding: data["embedding"],
+            payload: data["payload"],
+            expires_at: data["expires_at"] ? Time.at(data["expires_at"]) : nil
+          )
+        rescue JSON::ParserError
+          stale << id
+          nil
+        end
+        cleanup_stale_index!(stale)
+        entries
+      end
+
+      def write(id:, prompt:, embedding:, payload:, ttl:)
+        id ||= SecureRandom.uuid
+        expires_at = ttl && ttl.positive? ? Time.now.to_i + ttl : nil
+        data = JSON.generate(
+          "prompt" => prompt,
+          "embedding" => embedding,
+          "payload" => payload,
+          "expires_at" => expires_at
+        )
+        key = "#{ENTRY_PREFIX}#{id}"
+        if ttl && ttl.positive?
+          @redis.setex(key, ttl, data)
+        else
+          @redis.set(key, data)
+        end
+        begin
+          @redis.sadd(INDEX_KEY, [id])
+        rescue ArgumentError, TypeError, Redis::CommandError
+          @redis.sadd(INDEX_KEY, id)
+        end
+        true
+      end
+
+      def clear!
+        ids = @redis.smembers(INDEX_KEY)
+        keys = ids.map { |id| "#{ENTRY_PREFIX}#{id}" }
+        @redis.del(*keys) if keys.any?
+        @redis.del(INDEX_KEY)
+      end
+
+      def size
+        all.length
+      end
+
+      private
+
+      def cleanup_stale_index!(ids)
+        return if ids.nil? || ids.empty?
+
+        ids.each do |id|
+          begin
+            @redis.srem(INDEX_KEY, [id])
+          rescue ArgumentError, TypeError, Redis::CommandError
+            @redis.srem(INDEX_KEY, id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm_mesh/cache/semantic_cache.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "digest"
+require "securerandom"
+require_relative "memory_store"
+require_relative "redis_store"
+
+module RubyLlmMesh
+  module Cache
+    # Distributed (or process-local) semantic response cache.
+    # Embeds prompts via Rag::Embeddings and matches with cosine similarity.
+    class SemanticCache
+      class << self
+        def instance(config: RubyLlmMesh.configuration)
+          @instance ||= new(config: config)
+        end
+
+        def reset!
+          @instance&.clear!
+          @instance = nil
+        end
+      end
+
+      attr_reader :store, :embedder
+
+      def initialize(config: RubyLlmMesh.configuration, store: nil, embedder: nil)
+        @config = config
+        @embedder = embedder || Rag::Embeddings.new(dimensions: config.semantic_cache_dimensions)
+        @store = store || build_store
+      end
+
+      def enabled?
+        !!@config.semantic_cache_enabled
+      end
+
+      def lookup(prompt, system: nil)
+        return nil unless enabled?
+
+        query = cache_key_text(prompt, system)
+        query_vec = @embedder.embed(query)
+        threshold = @config.semantic_cache_threshold
+        best = nil
+        best_score = -1.0
+
+        @store.all.each do |entry|
+          next if entry.expires_at && entry.expires_at <= Time.now
+          next unless entry.embedding.is_a?(Array) && entry.embedding.length == query_vec.length
+
+          score = @embedder.cosine_similarity(query_vec, entry.embedding)
+          if score >= threshold && score > best_score
+            best = entry
+            best_score = score
+          end
+        end
+
+        return nil unless best
+
+        payload = best.payload || {}
+        Response.new(
+          content: payload["content"] || payload[:content],
+          provider: :semantic_cache,
+          model: payload["model"] || payload[:model],
+          usage: payload["usage"] || payload[:usage] || {},
+          raw: { cache_id: best.id, similarity: best_score, original_provider: payload["provider"] },
+          latency_ms: 0,
+          fallback_used: false,
+          cache_hit: true
+        )
+      end
+
+      def store_response(prompt, response, system: nil)
+        return false unless enabled?
+        return false if response.nil? || response.cache_hit
+
+        query = cache_key_text(prompt, system)
+        embedding = @embedder.embed(query)
+        id = Digest::SHA256.hexdigest(query)[0, 32]
+        payload = {
+          "content" => response.content,
+          "provider" => response.provider.to_s,
+          "model" => response.model,
+          "usage" => response.usage
+        }
+        @store.write(
+          id: id,
+          prompt: query,
+          embedding: embedding,
+          payload: payload,
+          ttl: @config.semantic_cache_ttl
+        )
+      end
+
+      def clear!
+        @store.clear!
+      end
+
+      private
+
+      def cache_key_text(prompt, system)
+        [system.to_s.strip, prompt.to_s.strip].reject(&:empty?).join("\n---\n")
+      end
+
+      def build_store
+        backend = @config.semantic_cache_backend
+        backend = infer_backend if backend.nil?
+
+        case backend.to_sym
+        when :redis
+          RedisStore.new(url: @config.redis_url)
+        when :memory
+          MemoryStore.new
+        else
+          raise ConfigurationError, "Unknown semantic_cache_backend: #{backend.inspect}"
+        end
+      end
+
+      def infer_backend
+        if @config.redis_url && !@config.redis_url.to_s.empty? && RedisStore.redis_available?
+          :redis
+        else
+          :memory
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm_mesh/circuit_breaker.rb

@@ -22,13 +22,23 @@ module RubyLlmMesh
           true
         when OPEN
           if Time.now - entry[:opened_at] >= @reset_timeout
+            # Single probe: transition to half-open and allow only this caller.
             entry[:state] = HALF_OPEN
+            entry[:opened_at] = Time.now
             true
           else
             false
           end
         when HALF_OPEN
-          true
+          # If the probe never reported (hung request), allow another after timeout.
+          # With reset_timeout 0, stay blocked until success/failure is recorded.
+          if @reset_timeout.positive? && entry[:opened_at] &&
+             Time.now - entry[:opened_at] >= @reset_timeout
+            entry[:opened_at] = Time.now
+            true
+          else
+            false
+          end
         end
       end
     end