elelem 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72a4cd636b39b6f30cc0520c3445a3b8748625fd5ca52f15b05d27349a0701b4
-  data.tar.gz: 12c55aaf15f42e7607fb60ed78500b44655ba6eaab857601ec58073378587866
+  metadata.gz: d4696869850fc38fba45a65a38aca74f8663fe9b8562deb7a987cbc71058221a
+  data.tar.gz: 8ec379df1537243659cfee997c02fde40912be780ace54b14bb0ff181f5fad64
 SHA512:
-  metadata.gz: '018856c824b90cbbe658c3b117f683737f14c34f493ba3629281cd7318c11d039585b829e201a9a8bf591619747d2d6c7f1f3568f53a79c40222632a706303ac'
-  data.tar.gz: ab3132d4613f560dfb97e7bcfa406e5f49ac66f5e642ec85f77c1a25d030825f1a7d9f6401d54dd6eb3f767ec69506b8f114e3a269324fb5fd72f0ca97827a0d
+  metadata.gz: 52e225e4b206091bcd1838cce432ee2391c648fa4f995a722dfefc2820985bb405e5e3574a972a8e31be260695eb368f3f6f3dcfa32f8cbeeb76b5fab6b1a2f3
+  data.tar.gz: c508bfedce1daf081011046ca77a13872af1bb133d161edfb944d7e4019e92222b15dc9aeb4f98376328e099a62e5ec89f2b67d2f595ed6ea6a58281a0a44589

data/lib/elelem/agent.rb

@@ -2,94 +2,100 @@
 
 module Elelem
   class Agent
-    attr_reader :conversation, :toolbox, :input, :output, :commands
+    attr_reader :conversation, :toolbox, :output
     attr_accessor :provider
 
-    def initialize(provider, toolbox: Toolbox.new, input: NullInput.new, output: NullOutput.new, system_prompt: nil, commands: nil)
+    def initialize(provider, toolbox: Toolbox.new, output: NullOutput.new, system_prompt: nil)
       @provider = provider
       @toolbox = toolbox
-      @commands = commands || Commands.new
       @output = output
-      @input = input
-      @conversation = Conversation.new
-      @system_prompt = SystemPrompt.new(system_prompt)
-    end
-
-    def repl
-      output.say "elelem v#{VERSION}"
-      loop do
-        line = input.ask("> ")
-        break if line.nil?
-        next if line.empty?
-        line.start_with?("/") ? command(line) : turn(line)
-      end
+      @conversation = Transcript.new(system_prompt: system_prompt)
     end
 
     def context
-      @conversation.to_a(system_prompt: @system_prompt.render)
+      @conversation.to_a
     end
 
     def turn(prompt)
       @conversation.add(role: "user", content: prompt)
-      ctx = []
-      content = nil
+      content = run_until_done([])
+      @conversation.add(role: "assistant", content: content)
+      content
+    end
 
+    private
+
+    def run_until_done(ctx)
       loop do
-        output.waiting
-        content, tool_calls = fetch_response(ctx)
-        output.say(content, as: :markdown)
-        break if tool_calls.empty?
-
-        ctx << { role: "assistant", content: content, tool_calls: tool_calls }.compact
-        tool_calls.each do |tool_call|
-          ctx << { role: "tool", tool_call_id: tool_call[:id], content: process(tool_call).to_json }
-        end
+        content, tool_calls = fetch_and_say(ctx)
+        return content if tool_calls.empty?
+
+        ctx.concat(tool_turn(content, tool_calls))
       end
+    end
 
-      @conversation.add(role: "assistant", content: content)
-      content
+    def fetch_and_say(ctx)
+      output.waiting
+      content, tool_calls = fetch_response(ctx)
+      output.say(content, as: :markdown)
+      [content, tool_calls]
     end
 
-    private
+    def tool_turn(content, tool_calls)
+      results = tool_calls.map { |tool_call| tool_result(tool_call) }
+      [{ role: "assistant", content: content, tool_calls: tool_calls }.compact, *results]
+    end
 
-    def command(line)
-      parts = line.delete_prefix("/").split(" ", 2)
-      name, args = parts[0], parts[1]
-      commands.run(name, args) || output.say(commands.names.join(" "))
-    rescue => e
-      Elelem.logger.warn("agent: #{e.message}")
-      output.say(e.message, as: :error)
+    def tool_result(tool_call)
+      { role: "tool", tool_call_id: tool_call[:id], content: process(tool_call).to_json }
     end
 
     def process(tool_call)
-      name, args = tool_call[:name], tool_call[:arguments]
+      name = tool_call[:name]
+      args = tool_call[:arguments]
       output.doing(toolbox.tool_for(name).name, args)
       Elelem.logger.debug("agent: #{name}(#{args.inspect})")
-      result = toolbox.run(name.to_s, args)
+      log_result(name, toolbox.run(name.to_s, args))
+    end
+
+    def log_result(name, result)
       Elelem.logger.debug("agent: #{name} -> #{result.inspect}")
       result
     end
 
     def fetch_response(ctx)
+      collect_response(ctx)
+    rescue StandardError, ScriptError => e
+      fetch_error(e)
+    end
+
+    def collect_response(ctx)
       content = String.new
       tool_calls = []
+      provider.fetch(messages(ctx), toolbox.to_a) { |event| handle_event(event, content, tool_calls) }
+      [content, tool_calls]
+    end
+
+    def messages(ctx)
+      @conversation.to_a(ctx)
+    end
 
-      provider.fetch(@conversation.to_a(system_prompt: @system_prompt.render) + ctx, toolbox.to_a) do |event|
-        case event[:type]
-        when "saying"
-          content << event[:text].to_s
-        when "thinking"
-          output.thinking(event[:text])
-        when "doing"
-          tool_calls << { id: event[:id], name: event[:name], arguments: event[:arguments] }
-        end
+    def fetch_error(error)
+      warn_and_say(error)
+      ["Error: #{error.message}", []]
+    end
+
+    def handle_event(event, content, tool_calls)
+      case event[:type]
+      when "saying" then content << event[:text].to_s
+      when "thinking" then output.thinking(event[:text])
+      when "doing" then tool_calls << { id: event[:id], name: event[:name], arguments: event[:arguments] }
       end
+    end
 
-      [content, tool_calls]
-    rescue => e
-      Elelem.logger.warn("agent: #{e.message}")
-      output.say(e.message, as: :error)
-      ["Error: #{e.message}", []]
+    def warn_and_say(error)
+      Elelem.logger.warn("agent: #{error.message}")
+      output.say(error.message, as: :error)
     end
   end
 end

data/lib/elelem/cli.rb

@@ -8,6 +8,15 @@ require "reline"
 module Elelem
   class CLI
     COMMANDS = %w[chat ask files help].freeze
+    USAGE = <<~TEXT
+      \nCommands:
+        chat              Interactive REPL (default)
+        ask <prompt>      One-shot query (reads stdin if piped)
+        files             Output files as XML (no options)
+        help              Show this help
+      \nOptions:
+    TEXT
+    private_constant :USAGE
 
     def initialize(args, provider: "stub")
       @provider = provider
@@ -23,54 +32,85 @@ module Elelem
     private
 
     def parse(args)
-      @parser = OptionParser.new do |o|
-        o.banner = "Usage: #{File.basename($PROGRAM_NAME)} [command] [options] [args]"
-        o.separator "\nCommands:"
-        o.separator "  chat              Interactive REPL (default)"
-        o.separator "  ask <prompt>      One-shot query (reads stdin if piped)"
-        o.separator "  files             Output files as XML (no options)"
-        o.separator "  help              Show this help"
-        o.separator "\nOptions:"
-        o.on("-p", "--provider NAME", "Provider to use (default: #{@provider})") { |p| @provider = p }
-        o.on("-h", "--help", "Show this help") { puts o; exit }
-      end
+      @parser = OptionParser.new { |o| describe_options(o) }
       @parser.parse!(args)
     end
 
+    def describe_options(parser)
+      describe_usage(parser)
+      parser.on("-p", "--provider NAME", "Provider to use (default: #{@provider})") { |p| @provider = p }
+      parser.on("-h", "--help", "Show this help") { print_help_and_exit(parser) }
+    end
+
+    def print_help_and_exit(parser)
+      puts parser
+      exit
+    end
+
+    def describe_usage(parser)
+      parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [command] [options] [args]"
+      parser.separator USAGE
+    end
+
     def help
       puts @parser
     end
 
     def chat
       Elelem.start(provider: @provider)
-    rescue => e
-      Elelem.logger.warn("cli: #{e.message}\n#{e.backtrace.join("\n")}")
-      abort "elelem: #{e.message}"
+    rescue StandardError, ScriptError => e
+      warn_and_abort(e)
     end
 
     def ask
       abort "Usage: elelem-chat ask <prompt>" if @args.empty?
+
+      reply = Elelem.ask(prompt_for_ask, provider: @provider, output: output_for_ask)
+      print_reply(reply, piped: piped?)
+    rescue StandardError, ScriptError => e
+      warn_and_abort(e)
+    end
+
+    def piped?
+      !$stdout.tty?
+    end
+
+    def output_for_ask
+      Elelem::Output.new(stream: piped? ? $stderr : $stdout)
+    end
+
+    def prompt_for_ask
       prompt = @args.join(" ")
-      prompt = "#{prompt}\n\n```\n#{$stdin.read}\n```" if $stdin.stat.pipe?
-      piped = !$stdout.tty?
-      output = Elelem::Output.new(stream: piped ? $stderr : $stdout)
-      reply = Elelem.ask(prompt, provider: @provider, output: output)
+      $stdin.stat.pipe? ? "#{prompt}\n\n```\n#{$stdin.read}\n```" : prompt
+    end
+
+    def print_reply(reply, piped:)
       abort "elelem: no reply" if reply.to_s.strip.empty?
       Elelem::Output.new.say(reply, as: :markdown) if piped
-    rescue => e
-      Elelem.logger.warn("cli: #{e.message}\n#{e.backtrace.join("\n")}")
-      abort "elelem: #{e.message}"
+    end
+
+    def warn_and_abort(error)
+      Elelem.logger.warn("cli: #{error.message}\n#{error.backtrace.join("\n")}")
+      abort "elelem: #{error.message}"
     end
 
     def files
-      files = $stdin.stat.pipe? ? $stdin.readlines : `git ls-files`.lines
       puts "<documents>"
-      files.each_with_index do |line, i|
-        path = line.strip
-        next if path.empty? || !File.file?(path)
-        puts %Q{<document index="#{i + 1}"><source>#{path}</source><document_content><![CDATA[#{File.read(path)}]]></document_content></document>}
-      end
+      candidate_files.each_with_index { |line, i| print_document(line, i) }
       puts "</documents>"
-     end
+    end
+
+    def candidate_files
+      $stdin.stat.pipe? ? $stdin.readlines : `git ls-files`.lines
+    end
+
+    def print_document(line, index)
+      path = line.strip
+      return if path.empty? || !File.file?(path)
+
+      content = File.read(path)
+      puts %(<document index="#{index + 1}"><source>#{path}</source>) +
+           %(<document_content><![CDATA[#{content}]]></document_content></document>)
+    end
   end
 end

data/lib/elelem/commands.rb

@@ -18,7 +18,7 @@ module Elelem
 
     def completions_for(name, partial = "")
       cmd = command_for(name)
-      return [] unless cmd && cmd.completions
+      return [] unless cmd&.completions
 
       options = cmd.completions.respond_to?(:call) ? cmd.completions.call : cmd.completions
       options.select { |o| o.start_with?(partial) }

data/lib/elelem/config.rb

@@ -4,14 +4,14 @@ module Elelem
   module Config
     extend SingleForwardable
 
-    def_single_delegators :default, :build_provider, :build_agent, :apply, :reload, :names
+    def_single_delegators :default, :build_provider, :build_session, :apply, :reload, :names
 
     def self.default
       @default ||= Registry.new
     end
   end
 
-  def self.configure(&block)
-    Config.default.configure(&block)
+  def self.configure(&)
+    Config.default.configure(&)
   end
 end

data/lib/elelem/conversation.rb

@@ -10,6 +10,7 @@ module Elelem
 
     def add(role:, content:, **extra)
       raise ArgumentError, "invalid role: #{role}" unless ROLES.include?(role)
+
       @messages << { role: role, content: content, **extra }.compact
     end
 

data/lib/elelem/input.rb

@@ -22,19 +22,17 @@ module Elelem
 
     def complete(target, preposing)
       line = "#{preposing}#{target}"
-
-      if line.start_with?("/") && !preposing.include?(" ")
-        return command_names.select { |c| c.start_with?(line) }
-      end
-
-      if preposing.start_with?("/") && preposing.include?(" ")
-        cmd_name = preposing.delete_prefix("/").split(" ", 2).first
-        return complete_command_args(cmd_name, target)
-      end
+      return command_names.select { |c| c.start_with?(line) } if line.start_with?("/") && !preposing.include?(" ")
+      return complete_command_args_for(preposing, target) if preposing.start_with?("/") && preposing.include?(" ")
 
       complete_files(target)
     end
 
+    def complete_command_args_for(preposing, target)
+      cmd_name = preposing.delete_prefix("/").split(" ", 2).first
+      complete_command_args(cmd_name, target)
+    end
+
     def command_names
       @commands.respond_to?(:names) ? @commands.names : @commands
     end

data/lib/elelem/output.rb

@@ -2,6 +2,12 @@
 
 module Elelem
   class Output
+    RENDERERS = {
+      error: ->(text) { "error: #{text}" },
+      markdown: ->(text) { "```\n#{text}\n```\n" }
+    }.freeze
+    private_constant :RENDERERS
+
     def initialize(stream: $stdout, **)
       @stream = stream
     end
@@ -26,8 +32,7 @@ module Elelem
       say "#{state} \e[36m#{name}\e[0m(#{args})"
     end
 
-    def waiting
-    end
+    def waiting; end
 
     def display_file(path, fallback: nil)
       say(fallback || path)
@@ -36,14 +41,7 @@ module Elelem
     private
 
     def render(text, as)
-      case as
-      when :error
-        return "error: #{text}"
-      when :markdown
-        "```\n" + text + "\n```\n"
-      else
-        text
-      end
+      RENDERERS[as]&.call(text) || text
     end
 
     def write(text)

data/lib/elelem/plugins.rb

@@ -15,18 +15,22 @@ module Elelem
     def load!(force: false)
       return if @loaded && !force
 
-      @load_paths.each do |path|
-        dir = File.expand_path(path)
-        next unless File.directory?(dir)
+      @load_paths.each { |path| load_dir(File.expand_path(path)) }
+      @loaded = true
+    end
 
-        Dir["#{dir}/*.rb"].sort.each do |file|
-          load(file)
-        rescue => e
-          warn "elelem: failed to load plugin #{file}: #{e.message}"
-        end
-      end
+    private
 
-      @loaded = true
+    def load_dir(dir)
+      return unless File.directory?(dir)
+
+      Dir["#{dir}/*.rb"].each { |file| load_plugin(file) }
+    end
+
+    def load_plugin(file)
+      load(file)
+    rescue StandardError, ScriptError => e
+      warn "elelem: failed to load plugin #{file}: #{e.message}"
     end
   end
 end

data/lib/elelem/registry.rb

@@ -17,53 +17,52 @@ module Elelem
       @registration.providers.fetch(name.to_s) { require_gem(name) }.call
     end
 
-    def apply(agent)
+    def apply(session)
       @plugins.load!
-      @registration.setups.each_value { |block| block.call(agent) }
+      @registration.setups.each_value { |block| block.call(session) }
     end
 
-    def reload(agent)
+    def reload(session)
       @registration.clear_setups!
-      agent.toolbox.clear!
-      agent.commands.clear!
+      session.toolbox.clear!
+      session.commands.clear!
       @plugins.load!(force: true)
-      apply(agent)
+      apply(session)
     end
 
     def names
       @registration.providers.keys
     end
 
-    def build_agent(provider, toolbox: Toolbox.new, input: nil, output: nil)
+    def build_session(provider, toolbox: Toolbox.new, input: nil, output: nil)
       commands = Commands.new
-      agent = Agent.new(
-        build_provider(provider),
-        toolbox: toolbox,
-        commands: commands,
-        input: input || build_input(commands: commands),
-        output: output || build_output,
-      )
-      apply(agent)
-      agent
+      agent = Agent.new(build_provider(provider), toolbox: toolbox, output: output || build_output)
+      session = Session.new(agent, input: input || build_input(commands: commands), commands: commands)
+      apply(session)
+      session
     end
 
     private
 
-    def build_input(**opts)
+    def build_input(**)
       @plugins.load!
-      (@registration.factories[:input] || ->(**o) { Input.new(**o) }).call(**opts)
+      (@registration.factories[:input] || ->(**o) { Input.new(**o) }).call(**)
     end
 
-    def build_output(**opts)
+    def build_output(**)
       @plugins.load!
-      (@registration.factories[:output] || ->(**o) { Output.new(**o) }).call(**opts)
+      (@registration.factories[:output] || ->(**o) { Output.new(**o) }).call(**)
     end
 
     def require_gem(name)
       require "elelem/#{name}"
-      @registration.providers.fetch(name.to_s) { raise "elelem-#{name} did not register a provider named #{name.inspect}" }
+      @registration.providers.fetch(name.to_s) { unregistered_provider(name) }
     rescue LoadError
       raise "unknown provider: #{name.inspect}. Available: #{names.join(", ")}. Run: gem install elelem-#{name}"
     end
+
+    def unregistered_provider(name)
+      raise "elelem-#{name} did not register a provider named #{name.inspect}"
+    end
   end
 end

data/lib/elelem/repl.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Repl
+    def initialize(session)
+      @session = session
+    end
+
+    def run
+      @session.output.say "elelem v#{VERSION}"
+      while (line = @session.input.ask("> "))
+        dispatch_line(line) unless line.empty?
+      end
+    end
+
+    private
+
+    def dispatch_line(line)
+      line.start_with?("/") ? command(line) : @session.turn(line)
+    end
+
+    def command(line)
+      name, args = line.delete_prefix("/").split(" ", 2)
+      @session.commands.run(name, args) || @session.output.say(@session.commands.names.join(" "))
+    rescue StandardError, ScriptError => e
+      warn_and_say(e)
+    end
+
+    def warn_and_say(error)
+      Elelem.logger.warn("repl: #{error.message}")
+      @session.output.say(error.message, as: :error)
+    end
+  end
+end

data/lib/elelem/result.rb

@@ -5,6 +5,7 @@ require "forwardable"
 module Elelem
   class Result
     extend Forwardable
+
     def_delegators :@payload, :[], :each, :to_json, :to_h, :key?, :merge
 
     def self.success(payload)

data/lib/elelem/schema.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Schema
+    def initialize(params: {}, required: [])
+      @params = params.freeze
+      @required = required.freeze
+      @schema_hash = { type: "object", properties: @params, required: @required }.freeze
+      @json_schemer = JSONSchemer.schema(@schema_hash)
+    end
+
+    def to_h
+      @schema_hash
+    end
+
+    def validate(args)
+      @json_schemer.validate(args || {}).map { |error| error["error"] }
+    end
+  end
+end

data/lib/elelem/session.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Session
+    extend Forwardable
+
+    attr_reader :agent, :input, :commands
+
+    def_delegators :@agent, :provider, :provider=, :toolbox, :output, :conversation, :context, :turn
+
+    def initialize(agent, input: NullInput.new, commands: Commands.new)
+      @agent = agent
+      @input = input
+      @commands = commands
+    end
+  end
+end

data/lib/elelem/system_prompt.rb

@@ -3,6 +3,7 @@
 module Elelem
   class SystemPrompt
     DEFAULT = File.read(File.expand_path("prompts/default.erb", __dir__)).freeze
+    USER_AGENTS_MD = Pathname.new(Dir.home).join(".agents/AGENTS.md").freeze
 
     attr_accessor :template
 
@@ -17,6 +18,14 @@ module Elelem
     private
 
     def agents_md
+      [global_agents_md, project_agents_md].compact.then { |parts| parts.empty? ? nil : parts.join("\n\n") }
+    end
+
+    def global_agents_md
+      USER_AGENTS_MD.read if USER_AGENTS_MD.exist?
+    end
+
+    def project_agents_md
       Pathname.pwd.ascend.each do |dir|
         file = dir / "AGENTS.md"
         return file.read if file.exist?

data/lib/elelem/tool.rb

@@ -2,27 +2,22 @@
 
 module Elelem
   class Tool
-    attr_reader :name, :description, :params, :required, :aliases
+    attr_reader :name, :description, :aliases
 
-    def initialize(name, description:, params: {}, required: [], aliases: [], &fn)
+    def initialize(name, description:, schema: Schema.new, aliases: [], &handler)
       @name = name
       @description = description
-      @params = params.freeze
-      @required = required.freeze
+      @schema = schema
       @aliases = aliases.freeze
-      @fn = fn
-      @schema_hash = { type: "object", properties: @params, required: @required }.freeze
-      @schema = JSONSchemer.schema(@schema_hash)
+      @handler = handler
     end
 
     def call(args)
-      @fn.call(args)
+      @handler.call(args)
     end
 
     def validate(args)
-      @schema.validate(args || {}).map do |error|
-        error["error"]
-      end
+      @schema.validate(args)
     end
 
     def to_h
@@ -31,10 +26,9 @@ module Elelem
         function: {
           name: name,
           description: description,
-          parameters: @schema_hash
+          parameters: @schema.to_h
         }
       }
     end
-
   end
 end

data/lib/elelem/toolbox.rb

@@ -17,8 +17,9 @@ module Elelem
       @hooks[:after].clear
     end
 
-    def add(name, description:, params: {}, required: [], aliases: [], &fn)
-      tool = Tool.new(name, description: description, params: params, required: required, aliases: aliases, &fn)
+    def add(name, description:, params: {}, required: [], aliases: [], &handler)
+      schema = Schema.new(params: params, required: required)
+      tool = Tool.new(name, description: description, schema: schema, aliases: aliases, &handler)
       @tools[name] = tool
       tool.aliases.each { |a| @aliases[a] = name }
     end
@@ -37,14 +38,9 @@ module Elelem
 
     def run(name, args)
       tool = tool_for(name)
-      errors = tool.validate(args)
-      return Result.failure(error: errors.join(", ")) if errors.any?
-
-      result = dispatch(tool, args)
-      result[:error] ? Result.failure(result) : Result.success(result)
-    rescue => e
-      Elelem.logger.warn("toolbox: #{e.message}\n#{e.backtrace.join("\n")}")
-      Result.failure(error: e.message, name: name, args: args)
+      invalid(tool, args) || to_result(dispatch(tool, args))
+    rescue StandardError, ScriptError => e
+      failure(name, args, e)
     end
 
     def to_a
@@ -53,13 +49,35 @@ module Elelem
 
     private
 
+    def invalid(tool, args)
+      errors = tool.validate(args)
+      Result.failure(error: errors.join(", ")) if errors.any?
+    end
+
+    def to_result(result)
+      result[:error] ? Result.failure(result) : Result.success(result)
+    end
+
+    def failure(name, args, error)
+      Elelem.logger.warn("toolbox: #{error.message}\n#{error.backtrace.join("\n")}")
+      Result.failure(error: error.message, name: name, args: args)
+    end
+
     def dispatch(tool, args)
+      run_before_hooks(tool, args)
+      result = tool.call(args)
+      run_after_hooks(tool, args, result)
+      result
+    end
+
+    def run_before_hooks(tool, args)
       @hooks[:before][:*].each { |h| h.call(args, tool_name: tool.name) }
       @hooks[:before][tool.name].each { |h| h.call(args) }
-      result = tool.call(args)
+    end
+
+    def run_after_hooks(tool, args, result)
       @hooks[:after][:*].each { |h| h.call(args, result, tool_name: tool.name) }
       @hooks[:after][tool.name].each { |h| h.call(args, result) }
-      result
     end
   end
 end

data/lib/elelem/transcript.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Elelem
+  class Transcript
+    def initialize(system_prompt: nil)
+      @conversation = Conversation.new
+      @system_prompt = SystemPrompt.new(system_prompt)
+    end
+
+    def add(role:, content:, **extra)
+      @conversation.add(role: role, content: content, **extra)
+    end
+
+    def clear!
+      @conversation.clear!
+    end
+
+    def last
+      @conversation.last
+    end
+
+    def to_a(extra = [])
+      @conversation.to_a(system_prompt: @system_prompt.render) + extra
+    end
+  end
+end

data/lib/elelem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Elelem
-  VERSION = "0.11.0"
+  VERSION = "0.12.0"
 end

data/lib/elelem.rb

@@ -20,26 +20,30 @@ require_relative "elelem/null_output"
 require_relative "elelem/plugins"
 require_relative "elelem/registration"
 require_relative "elelem/registry"
+require_relative "elelem/repl"
 require_relative "elelem/config"
 require_relative "elelem/result"
+require_relative "elelem/schema"
+require_relative "elelem/session"
 require_relative "elelem/stub_provider"
 require_relative "elelem/system_prompt"
 require_relative "elelem/tool"
+require_relative "elelem/transcript"
 require_relative "elelem/null_tool"
 require_relative "elelem/toolbox"
 require_relative "elelem/version"
 
 module Elelem
   def self.start(provider: "stub", toolbox: Toolbox.new)
-    self.build(provider: provider, toolbox: toolbox).repl
+    Repl.new(build(provider: provider, toolbox: toolbox)).run
   end
 
   def self.ask(prompt, provider: "stub", toolbox: Toolbox.new, output: NullOutput.new)
-    self.build(provider: provider, toolbox: toolbox, input: NullInput.new, output: output).turn(prompt)
+    build(provider: provider, toolbox: toolbox, input: NullInput.new, output: output).turn(prompt)
   end
 
   def self.build(provider: "stub", toolbox: Toolbox.new, input: nil, output: nil)
-    Config.build_agent(provider, toolbox: toolbox, input: input, output: output)
+    Config.build_session(provider, toolbox: toolbox, input: input, output: output)
   end
 
   def self.logger

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elelem
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - mo khan
@@ -204,12 +204,16 @@ files:
 - lib/elelem/prompts/default.erb
 - lib/elelem/registration.rb
 - lib/elelem/registry.rb
+- lib/elelem/repl.rb
 - lib/elelem/result.rb
+- lib/elelem/schema.rb
+- lib/elelem/session.rb
 - lib/elelem/slash_command.rb
 - lib/elelem/stub_provider.rb
 - lib/elelem/system_prompt.rb
 - lib/elelem/tool.rb
 - lib/elelem/toolbox.rb
+- lib/elelem/transcript.rb
 - lib/elelem/version.rb
 homepage: https://src.mokhan.ca/elelem/elelem
 licenses:
@@ -218,6 +222,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://src.mokhan.ca/elelem/elelem
   source_code_uri: https://src.mokhan.ca/elelem/elelem
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib