ask-core 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07cf04e5db86d1aa2ed63aad10f47608619f320e00af7d730b0cd5b950f347ff
-  data.tar.gz: 99ef57dd70f631d3bfa024eb03b63279df7d251cab2afa68988cecd66140bc92
+  metadata.gz: 4a806c5e8835fe74ef4bf8941a314ed462fa39bd3d607e6de112b92df9a8bbb8
+  data.tar.gz: a6301f23b50af2d5e508eb73e072951a2e3526a3c0c2776a92b24b281111ef93
 SHA512:
-  metadata.gz: 62ca489c64a4b6ef8e89603e9a4d0442d7b9a4c5c54e61cbb46dc3803046d1b120e2b5e061c6826ee0ad1b2fc8cec9618f6fe3ec5587970efdd99a29d46b89af
-  data.tar.gz: c228dc1e27f86a24eddc30b60e928dbdf2ca59ee45feb441954b07c91787ba55c825d3d537fb6cca7fba312908100d220ab63ab283d5b6736bb0fe60d1248ba3
+  metadata.gz: 685fd487472dcb656e7b928e32d8e972ce27b963e78c8a64b167fe3a76691268878b87cf3079ff39d530cd23082d33ad919e36b01d209a790a9225c89d26b3bf
+  data.tar.gz: ba3bae4f9839de021ac62c3aefb0e9675b159151e5d45c5b113e48c6ec042594c658568944e78075b0c38e9dc945c02be13c40dfd2cf6901ed181b7bf9184fe3

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.8.0] — 2026-07-28
+
+### Changed
+
+- **`Ask::State::Memory` moved to `ask-state-providers`** — `ask-core` now only contains the abstract `State::Adapter` contract. The in-memory implementation is available in the `ask-state-providers` gem under the same class name (`Ask::State::Memory`). This keeps `ask-core` purely foundational.
+
+  ```ruby
+  # Before (ask-core 0.7.x)
+  require "ask"
+  store = Ask::State::Memory.new
+
+  # After — add ask-state-providers gem
+  require "ask-state-providers"
+  store = Ask::State::Memory.new  # same class name, same API
+  ```
+
+### Tested
+
+- 281 tests, 549 assertions, 0 failures
+
 ## [0.7.0] — 2026-07-26
 
 ### Added

data/lib/ask/state.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require "forwardable"
-
 module Ask
   # Pluggable state backend for agent sessions, channel providers, and
   # any other ask-rb component that needs durable key-value storage,
   # distributed locking, message queues, or ordered lists.
   #
   # The {State::Adapter} abstract base defines the contract.
-  # {State::Memory} provides an in-process implementation backed by Hash.
   # Production apps can provide Redis, PostgreSQL, or other backends by
   # subclassing {State::Adapter}.
+  # {State::Memory} (in-process, Hash-backed) is available in the
+  # +ask-state-providers+ gem.
   #
   # @example Using the in-memory adapter
   #   store = Ask::State::Memory.new
@@ -187,203 +185,5 @@ module Ask
       end
     end
 
-    # In-process state backend backed by a Hash.
-    # All operations are thread-safe via a Mutex.
-    # Data is not persisted — lost on process exit.
-    class Memory < Adapter
-      def initialize
-        @data = {}
-        @locks = {}
-        @queues = {}
-        @lists = {}
-        @mutex = Mutex.new
-      end
-
-      # -- key-value --
-
-      def get(key)
-        @mutex.synchronize do
-          expiry = @data[key]&.dig(:expires_at)
-          return nil if expiry && Time.now >= expiry
-
-          @data[key]&.dig(:value)
-        end
-      end
-
-      def set(key, value, ttl: nil)
-        @mutex.synchronize do
-          @data[key] = {
-            value: value,
-            expires_at: ttl ? Time.now + ttl : nil
-          }
-        end
-      end
-
-      def delete(key)
-        @mutex.synchronize { @data.delete(key) }
-      end
-
-      def set_if_not_exists(key, value, ttl: nil)
-        @mutex.synchronize do
-          if @data.key?(key)
-            expiry = @data[key][:expires_at]
-            return false if expiry.nil? || Time.now < expiry
-
-            # Key expired — treat as nonexistent
-            @data.delete(key)
-          end
-
-          @data[key] = {
-            value: value,
-            expires_at: ttl ? Time.now + ttl : nil
-          }
-          true
-        end
-      end
-
-      def clear
-        @mutex.synchronize do
-          @data.clear
-          @locks.clear
-          @queues.clear
-          @lists.clear
-        end
-      end
-
-      def exists?(key)
-        @mutex.synchronize do
-          expiry = @data[key]&.dig(:expires_at)
-          return false if expiry && Time.now >= expiry
-          @data.key?(key)
-        end
-      end
-
-      def keys(pattern: nil)
-        @mutex.synchronize do
-          # Filter out expired keys
-          active = @data.select do |_k, v|
-            expiry = v[:expires_at]
-            expiry.nil? || Time.now < expiry
-          end
-
-          keys = active.keys.map(&:to_s)
-          return keys unless pattern
-
-	          regex = self.class.glob_to_regex(pattern)
-          keys.select { |k| k.match?(regex) }
-        end
-      end
-
-      # -- locking --
-
-      def acquire_lock(key, ttl: 10)
-        @mutex.synchronize do
-          existing = @locks[key]
-          if existing.nil? || existing.expired?
-            lock = Lock.new(
-              id: key,
-              token: SecureRandom.hex(16),
-              expires_at: Time.now + ttl
-            )
-            @locks[key] = lock
-            lock
-          end
-        end
-      end
-
-      def release_lock(key, lock)
-        @mutex.synchronize do
-          current = @locks[key]
-          if current && current.token == lock.token && !current.expired?
-            @locks.delete(key)
-            true
-          else
-            false
-          end
-        end
-      end
-
-      # -- queues --
-
-      def enqueue(queue, value)
-        @mutex.synchronize do
-          @queues[queue] ||= []
-          entry = QueueEntry.new(
-            id: SecureRandom.uuid,
-            value: value,
-            enqueued_at: Time.now
-          )
-          @queues[queue] << entry
-          entry
-        end
-      end
-
-      def dequeue(queue)
-        @mutex.synchronize do
-          q = @queues[queue]
-          return nil unless q&.any?
-
-          q.shift
-        end
-      end
-
-      def queue_depth(queue)
-        @mutex.synchronize do
-          (@queues[queue] || []).length
-        end
-      end
-
-      # -- lists --
-
-      def list_append(key, value, max_length: nil)
-        @mutex.synchronize do
-          @lists[key] ||= []
-          @lists[key] << value
-          @lists[key].shift if max_length && @lists[key].length > max_length
-        end
-      end
-
-      def list_range(key, start = 0, stop = -1)
-        @mutex.synchronize do
-          list = @lists[key] || []
-          return list if start == 0 && stop == -1
-
-          stop = list.length - 1 if stop == -1 || stop >= list.length
-          return [] if start > stop
-
-          list[start..stop] || []
-        end
-      end
-
-      def list_remove(key, value)
-        @mutex.synchronize do
-          list = @lists[key]
-          return 0 unless list
-
-          before = list.length
-          list.delete(value)
-          before - list.length
-        end
-      end
-
-      # -- lifecycle --
-
-      def close
-        @mutex.synchronize do
-          @data.clear
-          @locks.clear
-          @queues.clear
-          @lists.clear
-        end
-      end
-
-      private
-
-      # Convert a glob pattern (*, ?) to a Regexp.
-      # Delegates to the shared class method for consistency.
-      def glob_to_regex(pattern)
-        self.class.glob_to_regex(pattern)
-      end
-    end
   end
 end

data/lib/ask/stream.rb

@@ -35,7 +35,7 @@ module Ask
     def finished? = !@finish_reason.nil?
 
     # @return [Boolean] true if this chunk contains tool calls
-    def tool_call? = @tool_calls&.any? == true
+    def tool_call? = @tool_calls.respond_to?(:any?) && @tool_calls.any?
 
     # @return [Boolean] true if this chunk contains thinking/reasoning content
     def thinking? = @thinking.to_s.length > 0

data/lib/ask/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ask
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-core
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Kaka Ruto