llm.rb 12.6.0 → 13.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm.rb
 version: !ruby/object:Gem::Version
-  version: 12.6.0
+  version: 13.0.0
 platform: ruby
 authors:
 - robert
@@ -73,14 +73,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 1.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -241,14 +241,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0.22'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -317,6 +317,8 @@ files:
 - lib/llm/agent.rb
 - lib/llm/buffer.rb
 - lib/llm/compactor.rb
+- lib/llm/compactor/null.rb
+- lib/llm/compactor/truncate.rb
 - lib/llm/context.rb
 - lib/llm/context/deserializer.rb
 - lib/llm/context/serializer.rb
@@ -331,22 +333,27 @@ files:
 - lib/llm/file.rb
 - lib/llm/function.rb
 - lib/llm/function/array.rb
-- lib/llm/function/call_group.rb
-- lib/llm/function/call_task.rb
-- lib/llm/function/fiber_group.rb
+- lib/llm/function/async/group.rb
+- lib/llm/function/async/reactor.rb
+- lib/llm/function/async/task.rb
+- lib/llm/function/fiber/group.rb
+- lib/llm/function/fiber/task.rb
 - lib/llm/function/fork.rb
+- lib/llm/function/fork/group.rb
 - lib/llm/function/fork/job.rb
 - lib/llm/function/fork/task.rb
-- lib/llm/function/fork_group.rb
+- lib/llm/function/group.rb
 - lib/llm/function/ractor.rb
+- lib/llm/function/ractor/group.rb
 - lib/llm/function/ractor/job.rb
 - lib/llm/function/ractor/mailbox.rb
 - lib/llm/function/ractor/task.rb
-- lib/llm/function/ractor_group.rb
 - lib/llm/function/registry.rb
+- lib/llm/function/sequential/group.rb
+- lib/llm/function/sequential/task.rb
 - lib/llm/function/task.rb
-- lib/llm/function/task_group.rb
-- lib/llm/function/thread_group.rb
+- lib/llm/function/thread/group.rb
+- lib/llm/function/thread/task.rb
 - lib/llm/function/tracing.rb
 - lib/llm/json_adapter.rb
 - lib/llm/loop_guard.rb
@@ -469,13 +476,16 @@ files:
 - lib/llm/repl.rb
 - lib/llm/repl/bar.rb
 - lib/llm/repl/command.rb
+- lib/llm/repl/commands/compact.rb
 - lib/llm/repl/commands/exit.rb
 - lib/llm/repl/commands/help.rb
 - lib/llm/repl/input.rb
 - lib/llm/repl/markdown.rb
+- lib/llm/repl/markdown/table.rb
 - lib/llm/repl/status.rb
 - lib/llm/repl/stream.rb
 - lib/llm/repl/transcript.rb
+- lib/llm/repl/walker.rb
 - lib/llm/repl/window.rb
 - lib/llm/response.rb
 - lib/llm/schema.rb
@@ -515,6 +525,7 @@ files:
 - lib/llm/tools/rg.rb
 - lib/llm/tools/shell.rb
 - lib/llm/tools/swap_text.rb
+- lib/llm/tools/utils.rb
 - lib/llm/tools/which.rb
 - lib/llm/tools/write_file.rb
 - lib/llm/tracer.rb
@@ -543,7 +554,7 @@ files:
 - resources/deepdive.md
 homepage: https://r.uby.dev/llm/
 licenses:
-- BUSL-1.1
+- MIT
 metadata:
   homepage_uri: https://r.uby.dev/llm/
   source_code_uri: https://github.com/r-uby-dev/llm.rb

data/lib/llm/function/call_task.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Function
-  ##
-  # The {LLM::Function::CallTask} class wraps a single direct function call
-  # behind the same task-like interface used by spawned concurrency modes.
-  class CallTask
-    ##
-    # @return [LLM::Function]
-    attr_reader :function
-
-    ##
-    # @param [LLM::Function] function
-    # @return [LLM::Function::CallTask]
-    def initialize(function)
-      @function = function
-    end
-
-    ##
-    # @return [Boolean]
-    def alive?
-      false
-    end
-
-    ##
-    # @return [nil]
-    def interrupt!
-      function.interrupt!
-      nil
-    end
-    alias_method :cancel!, :interrupt!
-
-    ##
-    # @return [LLM::Function::Return]
-    def wait
-      function.call
-    end
-    alias_method :value, :wait
-
-    ##
-    # @return [Class]
-    def group_class
-      LLM::Function::TaskGroup
-    end
-  end
-end

data/lib/llm/function/fiber_group.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Function
-  ##
-  # The {LLM::Function::FiberGroup} class wraps an array of
-  # `Fiber` objects that are running {LLM::Function} calls
-  # concurrently using scheduler-backed fibers.
-  #
-  # This class provides the same interface as {LLM::Function::ThreadGroup}
-  # but uses scheduler-backed fibers for cooperative concurrency.
-  #
-  # @example
-  #   llm = LLM.openai(key: ENV["KEY"])
-  #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-  #   ctx.talk "Summarize the weather, headlines, and stock price."
-  #   grp = ctx.functions.spawn(:fiber)
-  #   # do other work while tools run...
-  #   ctx.talk(grp.wait)
-  #
-  # @see LLM::Function::Array#spawn
-  # @see LLM::Function::ThreadGroup
-  # @see LLM::Function::TaskGroup
-  class FiberGroup
-    ##
-    # Creates a new {LLM::Function::FiberGroup} from an array
-    # of fiber objects.
-    #
-    # @param [Array<Fiber>] fibers
-    #   An array of fibers, each running an `LLM::Function#spawn_fiber` call.
-    #
-    # @return [LLM::Function::FiberGroup]
-    #   Returns a new fiber group.
-    def initialize(fibers)
-      @fibers = fibers
-    end
-
-    ##
-    # Returns whether any fiber in the group is still alive.
-    #
-    # This method checks if any of the fibers in the group are
-    # still running. It can be useful for monitoring concurrent
-    # tool execution without blocking.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn(:fiber)
-    #   while grp.alive?
-    #     puts "Tools are still running..."
-    #     sleep 1
-    #   end
-    #   ctx.talk(grp.wait)
-    #
-    # @return [Boolean]
-    #   Returns true if any fiber in the group is still alive,
-    #   false otherwise.
-    def alive?
-      @fibers.any?(&:alive?)
-    end
-
-    ##
-    # @return [nil]
-    def interrupt!
-      @fibers.each { _1.task.raise(LLM::Interrupt) if _1.task.alive? }
-      nil
-    end
-    alias_method :cancel!, :interrupt!
-
-    ##
-    # Waits for all fibers in the group to finish and returns
-    # their {LLM::Function::Return} values.
-    #
-    # This method blocks until every fiber in the group has
-    # completed. If a fiber raised an exception, the exception
-    # is caught and wrapped in an {LLM::Function::Return} with
-    # error information.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn(:fiber)
-    #   returns = grp.wait
-    #   # returns is now an array of LLM::Function::Return objects
-    #   ctx.talk(returns)
-    #
-    # @return [Array<LLM::Function::Return>]
-    #   Returns an array of function return values, in the same
-    #   order as the original fibers.
-    def wait
-      @fibers.map do |fiber|
-        fiber.alive? ? scheduler.run : nil
-        fiber.value
-      end
-    end
-    alias_method :value, :wait
-
-    private
-
-    def scheduler
-      Fiber.scheduler
-    end
-  end
-end

data/lib/llm/function/task_group.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Function
-  ##
-  # The {LLM::Function::TaskGroup} class wraps an array of
-  # `Async::Task` objects that are running {LLM::Function} calls
-  # concurrently using the async gem.
-  #
-  # This class provides the same interface as {LLM::Function::ThreadGroup}
-  # but uses async tasks for lightweight concurrency with automatic
-  # scheduling and I/O management.
-  #
-  # @example
-  #   llm = LLM.openai(key: ENV["KEY"])
-  #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-  #   ctx.talk "Summarize the weather, headlines, and stock price."
-  #   grp = ctx.functions.spawn(:task)
-  #   # do other work while tools run...
-  #   ctx.talk(grp.wait)
-  #
-  # @see LLM::Function::Array#spawn
-  # @see LLM::Function::ThreadGroup
-  # @see LLM::Function::FiberGroup
-  class TaskGroup
-    ##
-    # Creates a new {LLM::Function::TaskGroup} from an array
-    # of async task objects.
-    #
-    # @param [Array<Async::Task>] tasks
-    #   An array of async tasks, each running an `LLM::Function#spawn_async` call.
-    #
-    # @return [LLM::Function::TaskGroup]
-    #   Returns a new task group.
-    def initialize(tasks)
-      @tasks = tasks
-    end
-
-    ##
-    # Returns whether any task in the group is still alive.
-    #
-    # This method checks if any of the tasks in the group are
-    # still running. It can be useful for monitoring concurrent
-    # tool execution without blocking.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn(:task)
-    #   while grp.alive?
-    #     puts "Tools are still running..."
-    #     sleep 1
-    #   end
-    #   ctx.talk(grp.wait)
-    #
-    # @return [Boolean]
-    #   Returns true if any task in the group is still alive,
-    #   false otherwise.
-    def alive?
-      @tasks.any?(&:alive?)
-    end
-
-    ##
-    # @return [nil]
-    def interrupt!
-      @tasks.each(&:interrupt!)
-      nil
-    end
-    alias_method :cancel!, :interrupt!
-
-    ##
-    # Waits for all tasks in the group to finish and returns
-    # their {LLM::Function::Return} values.
-    #
-    # This method blocks until every task in the group has
-    # completed. If a task raised an exception, the exception
-    # is caught and wrapped in an {LLM::Function::Return} with
-    # error information.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn(:task)
-    #   returns = grp.wait
-    #   # returns is now an array of LLM::Function::Return objects
-    #   ctx.talk(returns)
-    #
-    # @return [Array<LLM::Function::Return>]
-    #   Returns an array of function return values, in the same
-    #   order as the original tasks.
-    def wait
-      @tasks.map(&:wait)
-    end
-    alias_method :value, :wait
-  end
-end

data/lib/llm/function/thread_group.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Function
-  ##
-  # The {LLM::Function::ThreadGroup} class wraps an array of
-  # `Thread` objects that are running {LLM::Function} calls
-  # concurrently. It provides a single {#wait} method that
-  # collects the {LLM::Function::Return} values from those
-  # threads.
-  #
-  # This class is returned by {LLM::Function::Array#spawn}
-  # when you call `ctx.functions.spawn` on the collection
-  # returned by {LLM::Context#functions}. It is a lightweight
-  # wrapper that does not inherit from Ruby's built-in
-  # {::ThreadGroup}.
-  #
-  # @example
-  #   llm = LLM.openai(key: ENV["KEY"])
-  #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-  #   ctx.talk "Summarize the weather, headlines, and stock price."
-  #   grp = ctx.functions.spawn
-  #   # do other work while tools run...
-  #   ctx.talk(grp.wait)
-  #
-  # @see LLM::Function::Array#spawn
-  # @see LLM::Function::Array#wait
-  class ThreadGroup
-    ##
-    # Creates a new {LLM::Function::ThreadGroup} from an array
-    # of `Thread` objects.
-    #
-    # @param [Array<Thread>] threads
-    #   An array of threads, each running an {LLM::Function#spawn}
-    #   call. The thread's `Thread#value` will be an
-    #   {LLM::Function::Return}.
-    #
-    # @return [LLM::Function::ThreadGroup]
-    #   Returns a new thread group.
-    def initialize(threads)
-      @threads = threads
-    end
-
-    ##
-    # Returns whether any thread in the group is still alive.
-    #
-    # This method checks if any of the threads in the group are
-    # still running. It can be useful for monitoring concurrent
-    # tool execution without blocking.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn
-    #   while grp.alive?
-    #     puts "Tools are still running..."
-    #     sleep 1
-    #   end
-    #   ctx.talk(grp.wait)
-    #
-    # @return [Boolean]
-    #   Returns true if any thread in the group is still alive,
-    #   false otherwise.
-    def alive?
-      @threads.any?(&:alive?)
-    end
-
-    ##
-    # @return [nil]
-    def interrupt!
-      @threads.each { _1.task.raise LLM::Interrupt }
-      nil
-    end
-    alias_method :cancel!, :interrupt!
-
-    ##
-    # Waits for all threads in the group to finish and returns
-    # their {LLM::Function::Return} values.
-    #
-    # This method blocks until every thread in the group has
-    # completed. If a thread raised an exception, the exception
-    # is caught and wrapped in an {LLM::Function::Return} with
-    # error information.
-    #
-    # @example
-    #   llm = LLM.openai(key: ENV["KEY"])
-    #   ctx = LLM::Context.new(llm, tools: [Weather, News, Stocks])
-    #   ctx.talk "Summarize the weather, headlines, and stock price."
-    #   grp = ctx.functions.spawn
-    #   returns = grp.wait
-    #   # returns is now an array of LLM::Function::Return objects
-    #   ctx.talk(returns)
-    #
-    # @return [Array<LLM::Function::Return>]
-    #   Returns an array of function return values, in the same
-    #   order as the original threads.
-    def wait
-      @threads.map(&:value)
-    end
-    alias_method :value, :wait
-  end
-end