llmemory 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc40425c3adccdf3b900f4421cb642feb9e816df10934fe5fe360f2bb2a16706
-  data.tar.gz: b1267ceae049b4c69655987b15fda8517616bde9f2048301bdc030f4d92b1259
+  metadata.gz: ecc37d3f00fe0f347b1cf37d17665a84b92fa8a0effdf6f238178651f44f58a9
+  data.tar.gz: 35dc741e76e12814e6abae4ede8cace697802359892cbb9c419a5e224c5b16f9
 SHA512:
-  metadata.gz: f81850bc29cdeeec37d1d590442376bba2e473e895d0dda7f5be2c0c41d86b7e9bac0b0e2e1e731895a6ae978da78ca68be038ae5d9976bfcd4a1ec5702adec6
-  data.tar.gz: 12d5f1736a795336d3ef951b5fde2ef1e89b1d0a193e00d00fc2de88e5337beee309198dd016ed7e4980598a85c342387713652b66e19fadb2455c853a7a5d94
+  metadata.gz: 7161647ed2bd7ac8b48a4695cd915fb26e80aee867238f8b40a70d8d2b014af72f3206c0b738738d2429a17760927b486e101ce3e82dae09efa59469bb8b54c8
+  data.tar.gz: 310bc288d0e6570280dfd78cfe8f002bb2e071275baf47521649ab2ba56d40ce182cdce2b93cc0bc21ba3c2ccebce7122c4e99c4e481a004790fb030634f1a43

data/README.md

@@ -649,6 +649,19 @@ end
 
 The dashboard uses your existing `Llmemory.configuration` (short-term store, long-term store/type, etc.) and does not add any gem dependency; it only runs when Rails is present and you require `llmemory/dashboard`.
 
+**Dashboard authentication**
+
+By default, the dashboard requires HTTP Basic auth in non-development Rails environments (`dashboard_require_auth?` is `true` outside `Rails.env.development?`). Configure credentials in `Llmemory.configure`:
+
+```ruby
+Llmemory.configure do |config|
+  config.dashboard_auth = { username: ENV["LLMEMORY_DASHBOARD_USER"], password: ENV["LLMEMORY_DASHBOARD_PASSWORD"] }
+  config.dashboard_require_auth = true  # set false to disable (e.g. local dev behind a VPN)
+end
+```
+
+Requests without valid credentials receive `401 Unauthorized`.
+
 ## MCP Server (Model Context Protocol)
 
 llmemory includes an MCP server that allows LLM agents (like Claude Code) to interact directly with the memory system. This gives agents "agency" over their own memory—they can search, save, and retrieve memories autonomously.
@@ -685,16 +698,18 @@ llmemory mcp serve --name my-memory
 **HTTP mode** (for remote access or web integrations):
 
 ```bash
-# Start HTTP server on default port 3100
+# Start HTTP server on default port 3100 (binds to 127.0.0.1 by default)
 llmemory mcp serve --http
 
 # Custom port and host
 llmemory mcp serve --http --port 8080 --host 127.0.0.1
 
-# With authentication (recommended for HTTP/HTTPS)
-MCP_TOKEN=your-secret-token llmemory mcp serve --http
+# With authentication (required when binding outside loopback)
+MCP_TOKEN=your-secret-token llmemory mcp serve --http --host 0.0.0.0
 ```
 
+When the HTTP server listens on a non-loopback address (`0.0.0.0`, a public IP, etc.), **`MCP_TOKEN` is required** — the server refuses to start without it. Loopback binds (`127.0.0.1`, `localhost`) allow unauthenticated access for local development; set `MCP_TOKEN` anyway if other processes on the machine should not reach the server.
+
 **HTTPS mode** (secure remote access):
 
 ```bash
@@ -762,7 +777,7 @@ Or with the standalone executable:
 
 | Variable | Description |
 |----------|-------------|
-| `MCP_TOKEN` | Token for HTTP authentication (if set, requests must include valid token) |
+| `MCP_TOKEN` | Token for HTTP authentication (**required** when the HTTP server binds outside loopback; optional on `127.0.0.1`) |
 | `LLMEMORY_DEBUG` | Set to `1` to enable debug output on stderr |
 | `OPENAI_API_KEY` | API key for LLM/embeddings |
 | `REDIS_URL` | Redis URL for short-term store |
@@ -770,7 +785,9 @@ Or with the standalone executable:
 
 ### HTTP Authentication
 
-When `MCP_TOKEN` is set, the HTTP server requires authentication. Requests must include the token via:
+When binding to a non-loopback host, the HTTP server **requires** `MCP_TOKEN` at startup. On loopback, authentication is optional but recommended if untrusted local processes may connect.
+
+When a token is configured (or mandatory), requests must include it via:
 
 - **Authorization header**: `Authorization: Bearer <token>` or `Authorization: <token>`
 - **Query parameter**: `?token=<token>`

data/app/controllers/llmemory/dashboard/application_controller.rb

@@ -3,12 +3,24 @@
 module Llmemory
   module Dashboard
     class ApplicationController < ActionController::Base
+      before_action :ensure_dashboard_authorized!
+
       helper_method :short_term_store, :file_based_storage, :graph_based_storage,
                     :episodic_storage, :procedural_storage, :forget_log,
                     :file_based?, :graph_based?
 
       protected
 
+      def ensure_dashboard_authorized!
+        return unless Llmemory.configuration.dashboard_require_auth?
+        auth = Llmemory.configuration.dashboard_auth
+        return if auth.respond_to?(:call) && auth.call(self)
+
+        head :forbidden
+      end
+
+      protected
+
       def short_term_store
         @short_term_store ||= build_short_term_store
       end

data/app/views/llmemory/dashboard/short_term/show.html.erb

@@ -18,7 +18,7 @@
       <% content = (m[:content] || m["content"]).to_s %>
       <div class="message <%= role %>">
         <strong><%= role %>:</strong>
-        <%= content.gsub(/\n/, "<br>").html_safe %>
+        <%= simple_format(content) %>
       </div>
     <% end %>
   <% end %>

data/lib/llmemory/active_record_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module ActiveRecordHelpers
+    UNIQUE_RETRY_LIMIT = 3
+
+    private
+
+    def with_unique_retry(limit: UNIQUE_RETRY_LIMIT)
+      attempts = 0
+      begin
+        yield
+      rescue ActiveRecord::RecordNotUnique
+        attempts += 1
+        raise if attempts >= limit
+
+        retry
+      end
+    end
+  end
+end

data/lib/llmemory/cli/commands/mcp.rb

@@ -10,7 +10,7 @@ module Llmemory
           @server_name = "llmemory"
           @http_mode = false
           @port = 3100
-          @host = "0.0.0.0"
+          @host = "127.0.0.1"
           @ssl_cert = nil
           @ssl_key = nil
 
@@ -18,7 +18,7 @@ module Llmemory
           parser.on("--name NAME", "Server name (default: llmemory)") { |v| @server_name = v }
           parser.on("--http", "Run as HTTP server instead of stdio") { @http_mode = true }
           parser.on("--port PORT", Integer, "HTTP port (default: 3100)") { |v| @port = v }
-          parser.on("--host HOST", "HTTP host (default: 0.0.0.0)") { |v| @host = v }
+          parser.on("--host HOST", "HTTP host (default: 127.0.0.1)") { |v| @host = v }
           parser.on("--ssl-cert FILE", "SSL certificate file for HTTPS") { |v| @ssl_cert = v }
           parser.on("--ssl-key FILE", "SSL private key file for HTTPS") { |v| @ssl_key = v }
           parser.on("-h", "--help", "Show this help") do
@@ -51,7 +51,7 @@ module Llmemory
           puts "  --name NAME      Server name (default: llmemory)"
           puts "  --http           Run as HTTP server instead of stdio"
           puts "  --port PORT      HTTP port (default: 3100)"
-          puts "  --host HOST      HTTP host (default: 0.0.0.0)"
+          puts "  --host HOST      HTTP host (default: 127.0.0.1)"
           puts "  --ssl-cert FILE  SSL certificate file for HTTPS"
           puts "  --ssl-key FILE   SSL private key file for HTTPS"
           puts ""
@@ -99,6 +99,8 @@ module Llmemory
             exit 1
           end
 
+          Llmemory.configure { |c| c.shared_memory_stores = true }
+
           server = Llmemory::MCP::Server.new(name: @server_name)
 
           if @http_mode

data/lib/llmemory/configuration.rb

@@ -6,6 +6,10 @@ module Llmemory
                   :llm_api_key,
                   :llm_model,
                   :llm_base_url,
+                  :llm_timeout_seconds,
+                  :llm_open_timeout_seconds,
+                  :llm_http_retries,
+                  :redis_session_ttl_override,
                   :short_term_store,
                   :redis_url,
                   :long_term_type,
@@ -50,13 +54,20 @@ module Llmemory
                   :ttl_procedural_days,
                   :skill_mining_enabled,
                   :encryption_enabled,
-                  :encryption_key
+                  :encryption_key,
+                  :shared_memory_stores,
+                  :dashboard_auth,
+                  :dashboard_require_auth
 
     def initialize
       @llm_provider = :openai
       @llm_api_key = ENV["OPENAI_API_KEY"]
       @llm_model = nil # falls back to the active provider's DEFAULT_MODEL
       @llm_base_url = nil
+      @llm_timeout_seconds = 60
+      @llm_open_timeout_seconds = 10
+      @llm_http_retries = 2
+      @redis_session_ttl_override = nil
       @short_term_store = :memory
       @redis_url = ENV["REDIS_URL"] || "redis://localhost:6379/0"
       @long_term_type = :file_based
@@ -102,6 +113,21 @@ module Llmemory
       @message_sanitizer_enabled = false
       @encryption_enabled = false
       @encryption_key = ENV["LLMEMORY_ENCRYPTION_KEY"]
+      @shared_memory_stores = false
+      @dashboard_auth = nil
+      @dashboard_require_auth = nil
+    end
+
+    def dashboard_require_auth?
+      return @dashboard_require_auth unless @dashboard_require_auth.nil?
+
+      defined?(Rails) && Rails.respond_to?(:env) && Rails.env.development? ? false : true
+    end
+
+    def redis_session_ttl_seconds
+      return @redis_session_ttl_override if @redis_session_ttl_override
+
+      session_prune_after_days.to_i * 86_400
     end
   end
 
@@ -116,20 +142,29 @@ module Llmemory
 
     def reset_configuration!
       @configuration = Configuration.new
+      ShortTerm::Stores.reset_shared_singletons! if defined?(ShortTerm::Stores)
+      if defined?(LongTerm::FileBased::Storages)
+        LongTerm::FileBased::Storages.reset_shared_singletons!
+      end
+      if defined?(LongTerm::GraphBased::Storages)
+        LongTerm::GraphBased::Storages.reset_shared_singletons!
+      end
     end
 
     # Builds a Crypto::Cipher when encryption is enabled and a key is present;
     # otherwise returns Crypto::NullCipher. An explicit non-empty instance key
     # enables encryption even when the global flag is off.
     def build_cipher(key = nil)
-      explicit_key = !key.nil? && !key.to_s.empty?
       resolved = key.nil? ? configuration.encryption_key : key
-      enabled = configuration.encryption_enabled || explicit_key
-      if enabled && !resolved.to_s.empty?
-        require_relative "crypto/cipher"
+      enabled = configuration.encryption_enabled || (!key.nil? && !key.to_s.empty?)
+      if enabled && resolved.to_s.empty?
+        raise ConfigurationError, "encryption_key cannot be empty when encryption is enabled"
+      end
+
+      require_relative "crypto/cipher"
+      if enabled
         Crypto::Cipher.new(resolved)
       else
-        require_relative "crypto/cipher"
         Crypto::NullCipher.new
       end
     end

data/lib/llmemory/crypto/field_helpers.rb

@@ -92,6 +92,11 @@ module Llmemory
         end
 
         str = data.to_s
+        if !cipher.enabled? && str.start_with?(Crypto::Cipher::MARKER)
+          raise DecryptionError,
+                "Data is encrypted but encryption is disabled; enable encryption with the correct encryption_key"
+        end
+
         json = cipher.enabled? && cipher.encrypted?(str) ? cipher.decrypt(str) : str
         JSON.parse(json, symbolize_names: true)
       end

data/lib/llmemory/extractors/entity_relation_extractor.rb

@@ -53,8 +53,7 @@ module Llmemory
       end
 
       def extract(conversation_text)
-        text = conversation_text.to_s.strip
-        text = text[0, MAX_CONVERSATION_CHARS] + "\n[...]" if text.length > MAX_CONVERSATION_CHARS
+        text = truncate_conversation(conversation_text.to_s.strip)
         prompt = <<~PROMPT
           Infer entities and relations from this user-assistant conversation. Build a knowledge graph from what the user says, even when they don't state facts in formal language.
           - Entities: people, places, companies, concepts (type and name).
@@ -93,6 +92,14 @@ module Llmemory
 
       private
 
+      def truncate_conversation(text)
+        return text if text.length <= MAX_CONVERSATION_CHARS
+
+        head_len = (MAX_CONVERSATION_CHARS * 0.7).to_i
+        tail_len = MAX_CONVERSATION_CHARS - head_len
+        "#{text[0, head_len]}\n[...]\n#{text[-tail_len, tail_len]}"
+      end
+
       def parse_response(response)
         json = response.is_a?(Hash) ? response : extract_json(response)
         return { entities: [], relations: [] } unless json.is_a?(Hash)

data/lib/llmemory/extractors/fact_extractor.rb

@@ -43,6 +43,62 @@ module Llmemory
       end
 
       def classify_item(content)
+        classify_items([content])[content.to_s] || "general"
+      end
+
+      CLASSIFY_JSON_SCHEMA = {
+        name: "fact_classification",
+        schema: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  content: { type: "string" },
+                  category: { type: "string" }
+                },
+                required: ["content", "category"],
+                additionalProperties: false
+              }
+            }
+          },
+          required: ["items"],
+          additionalProperties: false
+        }
+      }.freeze
+
+      def classify_items(contents)
+        list = Array(contents).map(&:to_s).reject(&:empty?)
+        return {} if list.empty?
+
+        if @llm.respond_to?(:invoke_with_json_schema)
+          begin
+            numbered = list.map.with_index { |c, i| "#{i + 1}. #{c}" }.join("\n")
+            prompt = <<~PROMPT
+              Classify each fact into ONE category. Use lowercase with underscores.
+              Examples: work_life, personal_life, preferences, general.
+
+              Facts:
+              #{numbered}
+
+              Return one category per fact in the same order.
+            PROMPT
+            parsed = @llm.invoke_with_json_schema(prompt.strip, CLASSIFY_JSON_SCHEMA)
+            mapped = map_classifications(parsed, list)
+            return mapped if mapped.size == list.size
+          rescue Llmemory::LLMError
+            # fall back to per-item classification
+          end
+        end
+
+        list.each_with_object({}) { |content, acc| acc[content] = classify_item_fallback(content) }
+      end
+
+      private
+
+      def classify_item_fallback(content)
         return "general" if content.to_s.strip.empty?
         prompt = <<~PROMPT
           Classify this fact into ONE category. Use lowercase with underscores. Examples: work_life, personal_life, preferences, general.
@@ -53,7 +109,17 @@ module Llmemory
         result.empty? ? "general" : result
       end
 
-      private
+      def map_classifications(parsed, contents)
+        items = Array(parsed["items"] || parsed[:items])
+        by_content = items.each_with_object({}) do |row, acc|
+          content = (row["content"] || row[:content]).to_s
+          category = (row["category"] || row[:category]).to_s.strip.downcase.gsub(/\s+/, "_")
+          acc[content] = category.empty? ? "general" : category
+        end
+        contents.each_with_object({}) do |content, acc|
+          acc[content] = by_content[content] || classify_item_fallback(content)
+        end
+      end
 
       def parse_items_response(response)
         json = extract_json_array(response)

data/lib/llmemory/forget_log.rb

@@ -27,9 +27,13 @@ module Llmemory
         reason: reason,
         at: Time.now.iso8601
       }
-      log = entries(user_id)
-      log << entry
-      @store.save(user_id, SESSION_KEY, { "entries" => log })
+      @store.update(user_id, SESSION_KEY) do |state|
+        state = symbolize(state || {})
+        log = state[:entries]
+        log = log.is_a?(Array) ? log.map { |e| symbolize(e) } : []
+        log << entry
+        state.merge(entries: log)
+      end
       entry
     end
 

data/lib/llmemory/llm/anthropic.rb

@@ -3,10 +3,12 @@
 require "faraday"
 require "json"
 require_relative "base"
+require_relative "http_client"
 
 module Llmemory
   module LLM
     class Anthropic < Base
+      include HttpClient
       DEFAULT_BASE_URL = "https://api.anthropic.com"
       DEFAULT_MODEL = "claude-sonnet-4-6"
 
@@ -21,7 +23,7 @@ module Llmemory
         result = nil
         payload = { provider: :anthropic, model: @model, prompt_chars: prompt.to_s.length }
         Llmemory::Instrumentation.instrument(:llm_invoke, payload) do
-          response = connection.post("v1/messages") do |req|
+          response = post_with_resilience(connection, "v1/messages") do |req|
             req.body = {
               model: @model,
               max_tokens: 1024,
@@ -47,11 +49,7 @@ module Llmemory
       private
 
       def connection
-        @connection ||= Faraday.new(url: @base_url) do |f|
-          f.request :json
-          f.response :json
-          f.adapter Faraday.default_adapter
-        end
+        @connection ||= build_faraday_connection(@base_url)
       end
     end
   end

data/lib/llmemory/llm/http_client.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Llmemory
+  module LLM
+    module HttpClient
+      RETRYABLE_STATUSES = [429, 500, 502, 503, 504].freeze
+
+      private
+
+      def http_timeout
+        (Llmemory.configuration.llm_timeout_seconds || 60).to_i
+      end
+
+      def http_open_timeout
+        (Llmemory.configuration.llm_open_timeout_seconds || 10).to_i
+      end
+
+      def build_faraday_connection(url)
+        Faraday.new(url: url) do |f|
+          f.request :json
+          f.response :json
+          f.options.timeout = http_timeout
+          f.options.open_timeout = http_open_timeout
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def post_with_resilience(connection, path, &block)
+        attempts = 0
+        max_attempts = (Llmemory.configuration.llm_http_retries || 2).to_i + 1
+
+        loop do
+          begin
+            response = connection.post(path, &block)
+            if RETRYABLE_STATUSES.include?(response.status) && attempts < max_attempts - 1
+              attempts += 1
+              sleep(0.5 * (2**(attempts - 1)))
+              next
+            end
+            return response
+          rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+            attempts += 1
+            raise Llmemory::LLMError, "HTTP request failed: #{e.message}" if attempts >= max_attempts
+
+            sleep(0.5 * (2**(attempts - 1)))
+          rescue Faraday::Error => e
+            raise Llmemory::LLMError, "HTTP request failed: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/llm/openai.rb

@@ -3,10 +3,12 @@
 require "faraday"
 require "json"
 require_relative "base"
+require_relative "http_client"
 
 module Llmemory
   module LLM
     class OpenAI < Base
+      include HttpClient
       DEFAULT_BASE_URL = "https://api.openai.com/v1"
       DEFAULT_MODEL = "gpt-4"
 
@@ -21,7 +23,7 @@ module Llmemory
         result = nil
         payload = { provider: :openai, model: @model, prompt_chars: prompt.to_s.length }
         Llmemory::Instrumentation.instrument(:llm_invoke, payload) do
-          response = connection.post("chat/completions") do |req|
+          response = post_with_resilience(connection, "chat/completions") do |req|
             req.body = {
               model: @model,
               messages: [{ role: "user", content: prompt }],
@@ -63,7 +65,7 @@ module Llmemory
         parsed = nil
         instrument_payload = { provider: :openai, model: @model, prompt_chars: prompt.to_s.length }
         Llmemory::Instrumentation.instrument(:llm_invoke, instrument_payload) do
-          response = connection.post("chat/completions") do |req|
+          response = post_with_resilience(connection, "chat/completions") do |req|
             req.body = payload.to_json
             req.headers["Content-Type"] = "application/json"
             req.headers["Authorization"] = "Bearer #{@api_key}"
@@ -88,11 +90,7 @@ module Llmemory
       private
 
       def connection
-        @connection ||= Faraday.new(url: @base_url) do |f|
-          f.request :json
-          f.response :json
-          f.adapter Faraday.default_adapter
-        end
+        @connection ||= build_faraday_connection(@base_url)
       end
     end
   end

data/lib/llmemory/llm/tracking_client.rb

@@ -15,22 +15,20 @@ module Llmemory
 
       def invoke(prompt)
         response = inner_client.invoke(prompt)
-        usage = if response.respond_to?(:usage)
-                  response.usage
-                elsif inner_client.respond_to?(:last_usage)
-                  inner_client.last_usage
-                else
-                  Usage.zero
-                end
-        UsageRecorder.record(user_id: @user_id, usage: usage, operation: :invoke, store: @store)
+        record_usage_from_client(:invoke)
         response
       end
 
       def invoke_with_json_schema(prompt, json_schema)
-        result = inner_client.invoke_with_json_schema(prompt, json_schema)
-        usage = inner_client.respond_to?(:last_usage) ? inner_client.last_usage : Usage.zero
-        UsageRecorder.record(user_id: @user_id, usage: usage, operation: :invoke, store: @store)
-        result
+        return nil unless structured_output_supported?
+
+        result = nil
+        begin
+          result = inner_client.invoke_with_json_schema(prompt, json_schema)
+          result
+        ensure
+          record_usage_from_client(:invoke) if structured_output_supported?
+        end
       end
 
       def last_usage
@@ -56,6 +54,18 @@ module Llmemory
       def inner_client
         @inner_client ||= @inner || Llmemory::LLM.client(api_key: @api_key)
       end
+
+      def structured_output_supported?
+        inner_client.class != Llmemory::LLM::Base &&
+          inner_client.method(:invoke_with_json_schema).owner != Llmemory::LLM::Base
+      end
+
+      def record_usage_from_client(operation)
+        usage = inner_client.respond_to?(:last_usage) ? inner_client.last_usage : Usage.zero
+        return if usage.zero?
+
+        UsageRecorder.record(user_id: @user_id, usage: usage, operation: operation, store: @store)
+      end
     end
   end
 end

data/lib/llmemory/llm/usage.rb

@@ -26,6 +26,10 @@ module Llmemory
       def to_h
         { input_tokens: @input_tokens, output_tokens: @output_tokens, total_tokens: @total_tokens }
       end
+
+      def zero?
+        @input_tokens.zero? && @output_tokens.zero? && @total_tokens.zero?
+      end
     end
   end
 end

data/lib/llmemory/llm/usage_ledger.rb

@@ -15,31 +15,32 @@ module Llmemory
       end
 
       def record(user_id, usage, operation:)
-        state = load_raw(user_id)
-        case operation.to_sym
-        when :invoke
-          bucket = symbolize_bucket(state[:invoke] || state["invoke"])
-          state = state.merge(
-            invoke: {
-              input_tokens: bucket[:input_tokens] + usage.input_tokens,
-              output_tokens: bucket[:output_tokens] + usage.output_tokens,
-              total_tokens: bucket[:total_tokens] + usage.total_tokens,
-              calls: bucket[:calls] + 1
-            }
-          )
-        when :embed
-          bucket = symbolize_bucket(state[:embed] || state["embed"], embed: true)
-          state = state.merge(
-            embed: {
-              total_tokens: bucket[:total_tokens] + usage.total_tokens,
-              calls: bucket[:calls] + 1
-            }
-          )
-        else
-          return totals(user_id)
+        @store.update(user_id, SESSION_KEY) do |state|
+          state = normalize(state || default_state)
+          case operation.to_sym
+          when :invoke
+            bucket = state[:invoke]
+            state = state.merge(
+              invoke: {
+                input_tokens: bucket[:input_tokens] + usage.input_tokens,
+                output_tokens: bucket[:output_tokens] + usage.output_tokens,
+                total_tokens: bucket[:total_tokens] + usage.total_tokens,
+                calls: bucket[:calls] + 1
+              }
+            )
+          when :embed
+            bucket = state[:embed]
+            state = state.merge(
+              embed: {
+                total_tokens: bucket[:total_tokens] + usage.total_tokens,
+                calls: bucket[:calls] + 1
+              }
+            )
+          else
+            next state
+          end
+          state.merge(updated_at: Time.now.iso8601)
         end
-        state[:updated_at] = Time.now.iso8601
-        @store.save(user_id, SESSION_KEY, stringify(state))
         totals(user_id)
       end