ruby-mana 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d264315170eee3756db9dc603810cb524ce0a933f15b8897d36e7306c20d25b1
-  data.tar.gz: fc2f36ef0eceec87a7ff9911384db6ed9c6f004eee8c279fc379d3d2c36756fb
+  metadata.gz: fa9b6637652accc3c6223e613713b06f3ef24654324c3498deac36067fbca29f
+  data.tar.gz: dc9722c916a0bcc6d599d37e24d68fc40870a6c35b0736d211266a7b4085c725
 SHA512:
-  metadata.gz: be603cd3ddfcc6e457b656df9caff5ba8a9de4252dbb74416879daead34c64d7b4c50ad6ea422eaa21b76b92acc780e93b54425250e369e3f14223c0c82fee03
-  data.tar.gz: ae6ea7cb12475dded7d5f6cf1c1f73acfb2bc16b592741cd935b9406d118516e1530651095310bc791d436f0039991936e8074da053f629240f0ec5b2c396143
+  metadata.gz: 911c263d7ad2e854c0268878ac19ac7e353d5d293e6683ae8453963c7edcb2443526ffdfdd019d24bbe024f729138ea3bad3234c96c16e968b6b997f81d298cb
+  data.tar.gz: b20334705ffd23d95249e5f3411e54e7e74da25442ebe059745de41ea1dbe88496377b410c3964979a86d2f64cab6e0755291bd5e860d5a116af6cfe535e50a9

data/README.md

@@ -136,11 +136,72 @@ Mana.configure do |c|
   c.api_key = ENV["ANTHROPIC_API_KEY"]
   c.max_iterations = 50
 end
+```
+
+### Custom effect handlers
+
+Define your own tools that the LLM can call. Each effect becomes an LLM tool automatically — the block's keyword parameters define the tool's input schema.
+
+```ruby
+# No params
+Mana.define_effect :get_time do
+  Time.now.to_s
+end
 
-# Or shorthand
-Mana.model = "claude-sonnet-4-20250514"
+# With params — keyword args become tool parameters
+Mana.define_effect :query_db do |sql:|
+  ActiveRecord::Base.connection.execute(sql).to_a
+end
+
+# With description (optional, recommended)
+Mana.define_effect :search_web,
+  description: "Search the web for information" do |query:, max_results: 5|
+    WebSearch.search(query, limit: max_results)
+  end
+
+# Use in prompts
+~"get the current time and store in <now>"
+~"find recent orders using query_db, store in <orders>"
 ```
 
+Built-in effects (`read_var`, `write_var`, `read_attr`, `write_attr`, `call_func`, `done`) are reserved and cannot be overridden.
+
+### LLM-compiled methods
+
+`mana def` lets LLM generate a method implementation on first call. The generated code is cached as a real `.rb` file — subsequent calls are pure Ruby with zero API overhead.
+
+```ruby
+mana def fizzbuzz(n)
+  ~"return an array of FizzBuzz results from 1 to n"
+end
+
+fizzbuzz(15)  # first call → LLM generates code → cached → executed
+fizzbuzz(20)  # pure Ruby from .mana_cache/fizzbuzz.rb
+
+# View the generated source
+puts Mana.source(:fizzbuzz)
+# def fizzbuzz(n)
+#   (1..n).map do |i|
+#     if i % 15 == 0 then "FizzBuzz"
+#     elsif i % 3 == 0 then "Fizz"
+#     elsif i % 5 == 0 then "Buzz"
+#     else i.to_s
+#     end
+#   end
+# end
+
+# Works in classes too
+class Converter
+  include Mana::Mixin
+
+  mana def celsius_to_fahrenheit(c)
+    ~"convert Celsius to Fahrenheit"
+  end
+end
+```
+
+Generated files live in `.mana_cache/` (add to `.gitignore`, or commit them to skip LLM on CI).
+
 ## How it works
 
 1. `~"..."` calls `String#~@`, which captures the caller's `Binding`

data/lib/mana/compiler.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Mana
+  # Compiler for `mana def` — LLM generates method implementations on first call,
+  # caches them as real .rb files, and replaces the method with native Ruby.
+  #
+  # Usage:
+  #   mana def fizzbuzz(n)
+  #     ~"return an array of FizzBuzz results from 1 to n"
+  #   end
+  #
+  #   fizzbuzz(15)  # first call → LLM generates code → cached → executed
+  #   fizzbuzz(20)  # subsequent calls → pure Ruby, zero API overhead
+  #
+  #   Mana.source(:fizzbuzz)  # view generated source
+  module Compiler
+    class << self
+      # Registry of compiled method sources: { "ClassName#method" => source_code }
+      def registry
+        @registry ||= {}
+      end
+
+      # Cache directory for generated .rb files
+      def cache_dir
+        @cache_dir || ".mana_cache"
+      end
+
+      attr_writer :cache_dir
+
+      # Get the generated source for a compiled method
+      def source(method_name, owner: nil)
+        key = registry_key(method_name, owner)
+        registry[key]
+      end
+
+      # Compile a method: wrap it so first invocation triggers LLM code generation
+      def compile(owner, method_name)
+        original = owner.instance_method(method_name)
+        compiler = self
+        key = registry_key(method_name, owner)
+
+        # Read the prompt from the original method body
+        prompt = extract_prompt(original)
+
+        # Build parameter signature for the generated method
+        params_desc = describe_params(original)
+
+        owner.define_method(method_name) do |*args, **kwargs, &blk|
+          # Generate implementation via LLM
+          generated = compiler.generate(method_name, params_desc, prompt)
+
+          # Write to cache file
+          cache_path = compiler.write_cache(method_name, generated, owner)
+
+          # Store in registry
+          compiler.registry[key] = generated
+
+          # Define the method on the correct owner (not Object) via class_eval
+          target_owner = owner
+          target_owner.class_eval(generated, cache_path, 1)
+
+          # Call the now-native method
+          send(method_name, *args, **kwargs, &blk)
+        end
+      end
+
+      # Generate Ruby method source via LLM
+      def generate(method_name, params_desc, prompt)
+        code = nil # pre-declare so binding captures it
+        b = binding
+        engine_prompt = "Write a Ruby method definition `def #{method_name}(#{params_desc})` that: #{prompt}. " \
+                        "Return ONLY the complete method definition (def...end), no explanation. " \
+                        "Store the code as a string in <code>"
+
+        Mana::Engine.run(engine_prompt, b)
+        code
+      end
+
+      # Write generated code to a cache file, return the path
+      def write_cache(method_name, source, owner = nil)
+        FileUtils.mkdir_p(cache_dir)
+        prefix = owner && owner != Object ? "#{underscore(owner.name)}_" : ""
+        path = File.join(cache_dir, "#{prefix}#{method_name}.rb")
+        File.write(path, "# Auto-generated by ruby-mana\n# frozen_string_literal: true\n\n#{source}\n")
+        path
+      end
+
+      # Clear all cached files and registry
+      def clear!
+        FileUtils.rm_rf(cache_dir) if Dir.exist?(cache_dir)
+        @registry = {}
+      end
+
+      private
+
+      def registry_key(method_name, owner = nil)
+        if owner && owner != Object
+          "#{owner}##{method_name}"
+        else
+          method_name.to_s
+        end
+      end
+
+      # Extract the prompt string from the original method.
+      # The method body should be a single ~"..." expression.
+      def extract_prompt(unbound_method)
+        source_loc = unbound_method.source_location
+        return nil unless source_loc
+
+        file, line = source_loc
+        return nil unless file && File.exist?(file)
+
+        lines = File.readlines(file)
+        # Scan from the def line to find the prompt string
+        body_lines = []
+        depth = 0
+        (line - 1...lines.length).each do |i|
+          l = lines[i]
+          depth += l.scan(/\bdef\b|\bdo\b|\bclass\b|\bmodule\b|\bif\b|\bunless\b|\bcase\b|\bwhile\b|\buntil\b|\bbegin\b/).length
+          depth -= l.scan(/\bend\b/).length
+          body_lines << l
+          break if depth <= 0
+        end
+
+        # Extract string content from ~"..." pattern
+        body = body_lines.join
+        match = body.match(/~"([^"]*)"/) || body.match(/~'([^']*)'/)
+        match ? match[1] : body_lines[1...-1].join.strip
+      end
+
+      def describe_params(unbound_method)
+        unbound_method.parameters.map do |(type, name)|
+          case type
+          when :req then name.to_s
+          when :opt then "#{name}=nil"
+          when :rest then "*#{name}"
+          when :keyreq then "#{name}:"
+          when :key then "#{name}: nil"
+          when :keyrest then "**#{name}"
+          when :block then "&#{name}"
+          else name.to_s
+          end
+        end.join(", ")
+      end
+
+      def underscore(str)
+        return "anonymous" if str.nil? || str.empty?
+
+        str.gsub("::", "_")
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+  end
+end

data/lib/mana/effect_registry.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Mana
+  # Registry for custom effect handlers.
+  #
+  # Users define effects that become LLM tools automatically:
+  #
+  #   Mana.define_effect :query_db,
+  #     description: "Execute a SQL query" do |sql:|
+  #       DB.execute(sql)
+  #     end
+  #
+  # The block's keyword parameters become the tool's input schema.
+  # The block's return value is serialized and sent back to the LLM.
+  module EffectRegistry
+    class EffectDefinition
+      attr_reader :name, :description, :handler, :params
+
+      def initialize(name, description: nil, &handler)
+        @name = name.to_s
+        @description = description || @name
+        @handler = handler
+        @params = extract_params(handler)
+      end
+
+      # Convert to LLM tool definition
+      def to_tool
+        properties = {}
+        required = []
+
+        @params.each do |param|
+          properties[param[:name]] = {
+            type: infer_type(param[:default]),
+            description: param[:name]
+          }
+          required << param[:name] if param[:required]
+        end
+
+        tool = {
+          name: @name,
+          description: @description,
+          input_schema: {
+            type: "object",
+            properties: properties
+          }
+        }
+        tool[:input_schema][:required] = required unless required.empty?
+        tool
+      end
+
+      # Call the handler with LLM-provided input
+      def call(input)
+        kwargs = {}
+        @params.each do |param|
+          key = param[:name]
+          if input.key?(key)
+            kwargs[key.to_sym] = input[key]
+          elsif param[:default] != :__mana_no_default__
+            # Use block's default
+          elsif param[:required]
+            raise Mana::Error, "missing required parameter: #{key}"
+          end
+        end
+
+        if kwargs.empty? && @params.empty?
+          @handler.call
+        else
+          @handler.call(**kwargs)
+        end
+      end
+
+      private
+
+      def extract_params(block)
+        return [] unless block
+
+        block.parameters.map do |(type, name)|
+          case type
+          when :keyreq
+            { name: name.to_s, required: true, default: :__mana_no_default__ }
+          when :key
+            # Try to get default value — not possible via reflection,
+            # so we mark it as optional with unknown default
+            { name: name.to_s, required: false, default: nil }
+          when :keyrest
+            # **kwargs — skip, can't generate schema
+            nil
+          else
+            # Positional args — treat as required string params
+            { name: name.to_s, required: true, default: :__mana_no_default__ } if name
+          end
+        end.compact
+      end
+
+      def infer_type(default)
+        case default
+        when Integer then "integer"
+        when Float then "number"
+        when TrueClass, FalseClass then "boolean"
+        when Array then "array"
+        when Hash then "object"
+        else "string"
+        end
+      end
+    end
+
+    RESERVED_EFFECTS = %w[read_var write_var read_attr write_attr call_func done].freeze
+
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def define(name, description: nil, &handler)
+        name_s = name.to_s
+        if RESERVED_EFFECTS.include?(name_s)
+          raise Mana::Error, "cannot override built-in effect: #{name_s}"
+        end
+
+        registry[name_s] = EffectDefinition.new(name, description: description, &handler)
+      end
+
+      def undefine(name)
+        registry.delete(name.to_s)
+      end
+
+      def defined?(name)
+        registry.key?(name.to_s)
+      end
+
+      def get(name)
+        registry[name.to_s]
+      end
+
+      # Generate tool definitions for all registered effects
+      def tool_definitions
+        registry.values.map(&:to_tool)
+      end
+
+      def clear!
+        @registry = {}
+      end
+
+      # Handle a tool call if it matches a registered effect
+      # Returns [handled, result] — handled is true if we processed it
+      def handle(name, input)
+        effect = get(name)
+        return [false, nil] unless effect
+
+        result = effect.call(input)
+        [true, result]
+      end
+    end
+  end
+end

data/lib/mana/engine.rb

@@ -92,12 +92,18 @@ module Mana
       ensure
         handler_stack.pop
       end
+
+      # Built-in tools + any registered custom effects
+      def all_tools
+        TOOLS + Mana::EffectRegistry.tool_definitions
+      end
     end
 
     def initialize(prompt, caller_binding)
       @prompt = prompt
       @binding = caller_binding
       @config = Mana.config
+      @caller_path = caller_source_path
     end
 
     def execute
@@ -123,7 +129,7 @@ module Mana
         # Process each tool use
         tool_results = tool_uses.map do |tu|
           result = handle_effect(tu)
-          done_result = tu[:input]["result"] if tu[:name] == "done"
+          done_result = (tu[:input][:result] || tu[:input]["result"]) if tu[:name] == "done"
           { type: "tool_result", tool_use_id: tu[:id], content: result.to_s }
         end
 
@@ -172,6 +178,28 @@ module Mana
         context.each { |k, v| parts << "  #{k} = #{v}" }
       end
 
+      # Discover available functions from caller's source
+      methods = begin
+        Mana::Introspect.methods_from_file(@caller_path)
+      rescue => _e
+        []
+      end
+      unless methods.empty?
+        parts << ""
+        parts << Mana::Introspect.format_for_prompt(methods)
+      end
+
+      # List custom effects
+      custom_effects = Mana::EffectRegistry.tool_definitions
+      unless custom_effects.empty?
+        parts << ""
+        parts << "Custom tools available:"
+        custom_effects.each do |t|
+          params = (t[:input_schema][:properties] || {}).keys.join(", ")
+          parts << "  #{t[:name]}(#{params}) — #{t[:description]}"
+        end
+      end
+
       parts.join("\n")
     end
 
@@ -183,10 +211,14 @@ module Mana
       # Normalize keys to strings for consistent access
       input = input.transform_keys(&:to_s) if input.is_a?(Hash)
 
-      # Check handler stack first
+      # Check handler stack first (legacy)
       handler = self.class.handler_stack.last
       return handler.call(name, input) if handler && handler.respond_to?(:call)
 
+      # Check custom effect registry
+      handled, result = Mana::EffectRegistry.handle(name, input)
+      return serialize_value(result) if handled
+
       case name
       when "read_var"
         serialize_value(resolve(input["name"]))
@@ -249,6 +281,20 @@ module Mana
       @binding.local_variable_set(name.to_sym, value)
     end
 
+    def caller_source_path
+      # Walk up the call stack to find the first non-mana source file
+      loc = @binding.source_location
+      return loc[0] if loc.is_a?(Array)
+
+      # Fallback: search caller_locations
+      caller_locations(4, 20)&.each do |frame|
+        path = frame.absolute_path || frame.path
+        next if path.nil? || path.include?("mana/")
+        return path
+      end
+      nil
+    end
+
     def serialize_value(val)
       case val
       when String, Integer, Float, TrueClass, FalseClass, NilClass
@@ -278,7 +324,7 @@ module Mana
         model: @config.model,
         max_tokens: 4096,
         system: system,
-        tools: TOOLS,
+        tools: self.class.all_tools,
         messages: messages
       }
 

data/lib/mana/introspect.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Mana
+  # Introspects the caller's source file to discover user-defined methods.
+  # Uses Prism AST to extract `def` nodes with their parameter signatures.
+  module Introspect
+    class << self
+      # Extract method definitions from a Ruby source file.
+      # Returns an array of { name:, params: } hashes.
+      #
+      # @param path [String] path to the Ruby source file
+      # @return [Array<Hash>] method definitions found
+      def methods_from_file(path)
+        return [] unless path && File.exist?(path)
+
+        source = File.read(path)
+        result = Prism.parse(source)
+        methods = []
+
+        walk(result.value) do |node|
+          next unless node.is_a?(Prism::DefNode)
+
+          params = extract_params(node)
+          methods << { name: node.name.to_s, params: params }
+        end
+
+        methods
+      end
+
+      # Format discovered methods as a string for the system prompt.
+      #
+      # @param methods [Array<Hash>] from methods_from_file
+      # @return [String] formatted method list
+      def format_for_prompt(methods)
+        return "" if methods.empty?
+
+        lines = methods.map do |m|
+          sig = m[:params].empty? ? m[:name] : "#{m[:name]}(#{m[:params].join(', ')})"
+          "  #{sig}"
+        end
+
+        "Available Ruby functions:\n#{lines.join("\n")}"
+      end
+
+      private
+
+      def walk(node, &block)
+        queue = [node]
+        while (current = queue.shift)
+          next unless current.respond_to?(:compact_child_nodes)
+
+          block.call(current)
+          queue.concat(current.compact_child_nodes)
+        end
+      end
+
+      def extract_params(def_node)
+        params_node = def_node.parameters
+        return [] unless params_node
+
+        result = []
+
+        # Required parameters
+        (params_node.requireds || []).each do |p|
+          result << param_name(p)
+        end
+
+        # Optional parameters
+        (params_node.optionals || []).each do |p|
+          result << "#{param_name(p)}=..."
+        end
+
+        # Rest parameter
+        if params_node.rest && !params_node.rest.is_a?(Prism::ImplicitRestNode)
+          name = params_node.rest.name
+          result << "*#{name || ''}"
+        end
+
+        # Keyword parameters
+        (params_node.keywords || []).each do |p|
+          case p
+          when Prism::RequiredKeywordParameterNode
+            result << "#{p.name}:"
+          when Prism::OptionalKeywordParameterNode
+            result << "#{p.name}: ..."
+          end
+        end
+
+        # Keyword rest
+        if params_node.keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+          name = params_node.keyword_rest.name
+          result << "**#{name || ''}"
+        end
+
+        # Block parameter
+        if params_node.block
+          result << "&#{params_node.block.name || ''}"
+        end
+
+        result
+      end
+
+      def param_name(node)
+        case node
+        when Prism::RequiredParameterNode
+          node.name.to_s
+        when Prism::OptionalParameterNode
+          node.name.to_s
+        else
+          node.respond_to?(:name) ? node.name.to_s : "_"
+        end
+      end
+    end
+  end
+end

data/lib/mana/mixin.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 module Mana
-  # Include in classes to use ~"..." in instance methods.
-  # binding_of_caller handles scope automatically, so this
-  # is mainly a semantic marker + future extension point.
+  # Include in classes to use ~"..." in instance methods
+  # and `mana def` for LLM-compiled methods.
   module Mixin
     def self.included(base)
-      # Reserved for future: auto-expose methods, etc.
+      base.extend(ClassMethods)
     end
+
+    module ClassMethods
+      # Mark a method for LLM compilation.
+      # Usage:
+      #   mana def fizzbuzz(n)
+      #     ~"return FizzBuzz array from 1 to n"
+      #   end
+      def mana(method_name)
+        Mana::Compiler.compile(self, method_name)
+        method_name
+      end
+    end
+  end
+end
+
+# Make `mana def` available at the top level (main object)
+class << self
+  def mana(method_name)
+    Mana::Compiler.compile(Object, method_name)
+    method_name
   end
 end

data/lib/mana/string_ext.rb

@@ -5,6 +5,13 @@ require "binding_of_caller"
 class String
   # ~"natural language prompt" → execute via Mana engine
   def ~@
-    Mana::Engine.run(self, binding.of_caller(1))
+    return self if Thread.current[:mana_running]
+
+    Thread.current[:mana_running] = true
+    begin
+      Mana::Engine.run(self, binding.of_caller(1))
+    ensure
+      Thread.current[:mana_running] = false
+    end
   end
 end

data/lib/mana/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mana
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/mana.rb

@@ -2,8 +2,10 @@
 
 require_relative "mana/version"
 require_relative "mana/config"
-require_relative "mana/effects"
+require_relative "mana/effect_registry"
 require_relative "mana/engine"
+require_relative "mana/introspect"
+require_relative "mana/compiler"
 require_relative "mana/string_ext"
 require_relative "mana/mixin"
 
@@ -32,6 +34,27 @@ module Mana
 
     def reset!
       @config = Config.new
+      EffectRegistry.clear!
+    end
+
+    # Define a custom effect that becomes an LLM tool
+    def define_effect(name, description: nil, &handler)
+      EffectRegistry.define(name, description: description, &handler)
+    end
+
+    # Remove a custom effect
+    def undefine_effect(name)
+      EffectRegistry.undefine(name)
+    end
+
+    # View generated source for a mana-compiled method
+    def source(method_name, owner: nil)
+      Compiler.source(method_name, owner: owner)
+    end
+
+    # Cache directory for compiled methods
+    def cache_dir=(dir)
+      Compiler.cache_dir = dir
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mana
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Carl
@@ -37,11 +37,11 @@ files:
 - LICENSE
 - README.md
 - lib/mana.rb
+- lib/mana/compiler.rb
 - lib/mana/config.rb
-- lib/mana/effects.rb
+- lib/mana/effect_registry.rb
 - lib/mana/engine.rb
-- lib/mana/llm/anthropic.rb
-- lib/mana/llm/base.rb
+- lib/mana/introspect.rb
 - lib/mana/mixin.rb
 - lib/mana/string_ext.rb
 - lib/mana/version.rb
@@ -67,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Embed LLM as native Ruby — write natural language, it just runs

data/lib/mana/effects.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  module Effects
-    ReadVar   = Struct.new(:name)
-    WriteVar  = Struct.new(:name, :value)
-    ReadAttr  = Struct.new(:obj_name, :attr)
-    WriteAttr = Struct.new(:obj_name, :attr, :value)
-    CallFunc  = Struct.new(:name, :args)
-    Done      = Struct.new(:result)
-  end
-end

data/lib/mana/llm/anthropic.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-
-module Mana
-  module LLM
-    class Anthropic < Base
-      API_URL = "https://api.anthropic.com/v1/messages"
-      API_VERSION = "2023-06-01"
-
-      def initialize(config = Mana.config)
-        super(config)
-        @api_key = config.api_key
-        @model = config.model
-      end
-
-      def chat(system:, messages:, tools:)
-        raise Mana::Error, "Anthropic API key not set" unless @api_key
-
-        body = {
-          model: @model,
-          max_tokens: 4096,
-          temperature: @config.temperature,
-          system: system,
-          messages: messages,
-          tools: tools
-        }
-
-        response = post(body)
-
-        unless response.is_a?(Net::HTTPSuccess)
-          parsed = JSON.parse(response.body) rescue nil
-          error_msg = parsed&.dig("error", "message") || response.body
-          raise Mana::Error, "Anthropic API error (#{response.code}): #{error_msg}"
-        end
-
-        parsed = JSON.parse(response.body)
-        parsed["content"].map { |block| symbolize_keys(block) }
-      end
-
-      private
-
-      def post(body)
-        uri = URI(API_URL)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.open_timeout = 30
-        http.read_timeout = 120
-        http.write_timeout = 30
-
-        request = Net::HTTP::Post.new(uri)
-        request["x-api-key"] = @api_key
-        request["anthropic-version"] = API_VERSION
-        request["content-type"] = "application/json"
-        request.body = JSON.generate(body)
-
-        http.request(request)
-      end
-
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), acc|
-          acc[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
-        end
-      end
-    end
-  end
-end

data/lib/mana/llm/base.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  module LLM
-    # Base interface for LLM clients.
-    # Subclass and implement #chat to add new providers.
-    class Base
-      def initialize(config)
-        @config = config
-      end
-
-      # Send a chat request with tools.
-      # Returns an array of content blocks (tool_use / text).
-      def chat(system:, messages:, tools:)
-        raise NotImplementedError, "#{self.class}#chat not implemented"
-      end
-    end
-  end
-end