anthropic 1.54.1 → 1.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b20f5272e4bfc8e9d59cc7f4dfcbb782e15de065e1df4fb7efae19b8d70f9b22
-  data.tar.gz: 7ff464adb217ac4acd2d800649cc08a33d544c847304a7f940c16aa0c3c1cacc
+  metadata.gz: 58294c110c5b712622ddf3921622929576a73ec5c08cb4316f5c34f6dfcf6d2a
+  data.tar.gz: 665f92b3d88328dff5a61a02481f3d11a05b207d2928a2e8d29e18041ee95db3
 SHA512:
-  metadata.gz: 46357a712cb1de2f2c37a7fb0c8ed445abf59eeff5d5d50b310094bbb72b5471eb7148b32b437edc6dd742f7f256ffc4f03bd557d290765de078ec5ded1765c7
-  data.tar.gz: 7acbb4df6dd1aa2a3668b466086d5a103475995dc4233a66a4abb7b27b5ad15d0f8a8a7ef476321f9687556df20085e6bbaeeac6cd6e6c438b763c7247f15db7
+  metadata.gz: 68c7f02ba359316458ef143f503a1986f144390541b4723c2e7e24694d7183eb76b17581a36c06de13fca3421e50fa82b9a32d05879785b2676bee4f3c6d58e6
+  data.tar.gz: d0fcf027e0eec3331b01c392f857f55a9098a8b7e16b9fa9a6188dff9a9d3474c72bdbcd250dd5e853c151c42e300b828c691bd5e39e4c0863b5e7e39c5fb753

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.56.0 (2026-07-16)
+
+Full Changelog: [v1.55.0...v1.56.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.55.0...v1.56.0)
+
+### Features
+
+* **api:** add support for dreaming ([6277ed9](https://github.com/anthropics/anthropic-sdk-ruby/commit/6277ed90a84e5b0b6574de7301b5f95470627fcc))
+* **api:** add support for MCP Tunnels ([4ecd4ba](https://github.com/anthropics/anthropic-sdk-ruby/commit/4ecd4ba4ebda2a08eeac2635668753ef7ee968b5))
+* **helpers:** add session delta accumulator for agent.message previews ([#83](https://github.com/anthropics/anthropic-sdk-ruby/issues/83)) ([01616a4](https://github.com/anthropics/anthropic-sdk-ruby/commit/01616a41bdfe88e9397fad901e0198b6a7c02c7b))
+
+
+### Bug Fixes
+
+* **streaming:** decode tool_use input when the content block stops ([#109](https://github.com/anthropics/anthropic-sdk-ruby/issues/109)) ([800277b](https://github.com/anthropics/anthropic-sdk-ruby/commit/800277b6e9f46a50533e696d192a6d23eddc920d))
+
+
+### Chores
+
+* **docs:** small updates to field descriptions ([0d7bf61](https://github.com/anthropics/anthropic-sdk-ruby/commit/0d7bf611ef0a96aba1c3604476f48d6da7b5bc1d))
+* **docs:** updates to descriptions and examples ([ea6bfd7](https://github.com/anthropics/anthropic-sdk-ruby/commit/ea6bfd74e293c62f6ca919387dc60154af959bbd))
+
+## 1.55.0 (2026-07-02)
+
+Full Changelog: [v1.54.1...v1.55.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.54.1...v1.55.0)
+
+### Features
+
+* **api:** add agent-memory-2026-07-22 beta header ([c3e9511](https://github.com/anthropics/anthropic-sdk-ruby/commit/c3e9511391e1976a580484e31d6dd2818afecc07))
+
 ## 1.54.1 (2026-07-01)
 
 Full Changelog: [v1.54.0...v1.54.1](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.54.0...v1.54.1)

data/README.md

@@ -15,7 +15,7 @@ Add to your application's Gemfile:
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.54.1"
+gem "anthropic", "~> 1.56.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/anthropic/google_cloud.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Anthropic
+  GoogleCloud = Anthropic::Helpers::GoogleCloud
+  GoogleCloudClient = Anthropic::Helpers::GoogleCloud::Client
+end

data/lib/anthropic/helpers/google_cloud/client.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module GoogleCloud
+      # Client for Claude Platform on Google Cloud — the first-party Anthropic
+      # API served through the Google Cloud gateway.
+      #
+      # This is distinct from {Anthropic::VertexClient}, which targets the
+      # `:rawPredict` publisher-model API (publisher model IDs, messages
+      # only). This client speaks the full first-party Anthropic API: requests
+      # pass through the gateway unchanged — standard `/v1/*` paths, standard
+      # model names, the complete API surface. The deprecated text Completions
+      # endpoint is intentionally not exposed.
+      class Client < Anthropic::Client
+        # OAuth2 scope required to call the gateway.
+        SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+
+        # Gateway base URL template; override via `base_url` or
+        # `ANTHROPIC_GOOGLE_CLOUD_BASE_URL`.
+        URL_TEMPLATE =
+          "https://claude.googleapis.com/v1alpha" \
+          "/projects/%<project>s/locations/%<location>s/workspaces/%<workspace_id>s/invoke"
+
+        # @return [String, nil]
+        attr_reader :project
+
+        # @return [String, nil]
+        attr_reader :location
+
+        # @return [String, nil]
+        attr_reader :workspace_id
+
+        # @return [Anthropic::Resources::Messages]
+        attr_reader :messages
+
+        # @return [Anthropic::Resources::Models]
+        attr_reader :models
+
+        # @return [Anthropic::Resources::Beta]
+        attr_reader :beta
+
+        # Creates a new client for the Anthropic API on the Google Cloud gateway.
+        #
+        # Authentication uses Google credentials by precedence (unless
+        # `skip_auth` is true):
+        #   1. `token_provider` — a callable returning a GCP access token, called
+        #      per attempt
+        #   2. `google_credentials` — a `googleauth` credentials object (anything
+        #      responding to `#apply`), refreshed by the library as needed
+        #   3. Application Default Credentials (`Google::Auth.get_application_default`)
+        #      with the `cloud-platform` scope
+        #
+        # @param project [String, nil] GCP consumer project id. Defaults to
+        #   `ENV["ANTHROPIC_GOOGLE_CLOUD_PROJECT"]`, then
+        #   `ENV["GOOGLE_CLOUD_PROJECT"]`, then the project reported by the
+        #   resolved Google credentials. Only required when the base URL must be
+        #   derived.
+        #
+        # @param location [String, nil] GCP location. Defaults to
+        #   `ENV["ANTHROPIC_GOOGLE_CLOUD_LOCATION"]`, then `"global"`; an
+        #   explicit `nil` falls back to the same defaults.
+        #
+        # @param workspace_id [String, nil] Defaults to
+        #   `ENV["ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID"]`. Required unless
+        #   `skip_auth` is true and an explicit `base_url` is given.
+        #
+        # @param base_url [String, nil] Override the gateway base URL. Defaults to
+        #   `ENV["ANTHROPIC_GOOGLE_CLOUD_BASE_URL"]`, otherwise derived from
+        #   `project`, `location`, and `workspace_id` via {URL_TEMPLATE}.
+        #
+        # @param google_credentials [#apply, nil] A `googleauth`-compatible
+        #   credentials object. Mutually exclusive with `skip_auth`.
+        #
+        # @param token_provider [#call, nil] A callable returning a GCP access
+        #   token string. Takes precedence over `google_credentials`. Mutually
+        #   exclusive with `skip_auth`.
+        #
+        # @param skip_auth [Boolean] When true, no token is attached and
+        #   `workspace_id` is only required when the base URL must be derived.
+        #   For callers fronting with their own authenticated proxy. Mutually
+        #   exclusive with `token_provider` and `google_credentials`.
+        #
+        # @param max_retries [Integer] Max number of retries to attempt after a
+        #   failed retryable request.
+        #
+        # @param timeout [Float]
+        #
+        # @param initial_retry_delay [Float]
+        #
+        # @param max_retry_delay [Float]
+        #
+        # @param middleware [Array<#call>, #call, nil] Per-attempt HTTP
+        #   around-middleware. See {Anthropic::Middleware}. The Google bearer
+        #   is applied per attempt, after user middleware.
+        #
+        # @raise [ArgumentError]
+        def initialize( # rubocop:disable Lint/MissingSuper
+          project: ENV["ANTHROPIC_GOOGLE_CLOUD_PROJECT"] || ENV["GOOGLE_CLOUD_PROJECT"],
+          location: ENV["ANTHROPIC_GOOGLE_CLOUD_LOCATION"] || "global",
+          workspace_id: ENV["ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID"],
+          base_url: ENV["ANTHROPIC_GOOGLE_CLOUD_BASE_URL"],
+          google_credentials: nil,
+          token_provider: nil,
+          skip_auth: false,
+          max_retries: self.class::DEFAULT_MAX_RETRIES,
+          timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+          initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+          max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
+          middleware: nil
+        )
+          if skip_auth && (token_provider || google_credentials)
+            raise ArgumentError.new(
+              "`skip_auth` is mutually exclusive with `token_provider` and `google_credentials`; " \
+              "`skip_auth` disables authentication entirely."
+            )
+          end
+
+          @skip_auth = skip_auth
+          @token_provider = token_provider
+          @authorization = google_credentials
+
+          # Resolve credentials eagerly so the client is thread-safe (no lazy
+          # ADC race) and so the credentials' project can backfill `project`
+          # before the base URL is derived.
+          if !skip_auth && token_provider.nil? && google_credentials.nil?
+            require_googleauth
+            @authorization = Google::Auth.get_application_default([SCOPE])
+          end
+
+          if project.nil? && @authorization.respond_to?(:project_id)
+            project = @authorization.project_id
+          end
+          @project = project
+          # The kwarg default doesn't fire on an explicitly-passed nil — coerce
+          # so nil can't reach the derived URL (matches the other SDKs).
+          @location = location || ENV["ANTHROPIC_GOOGLE_CLOUD_LOCATION"] || "global"
+
+          if workspace_id.nil? && !skip_auth
+            raise ArgumentError.new(
+              "No workspace ID was given. Set the `workspace_id` argument or the " \
+              "`ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` environment variable."
+            )
+          end
+          @workspace_id = workspace_id
+
+          base_url = derive_base_url if base_url.nil?
+
+          # Never inherit first-party Anthropic credentials from the
+          # environment: clear the ivars `Anthropic::Client#auth_headers` reads,
+          # and bind `BaseClient#initialize` directly so the parent's
+          # credential-provider / `ANTHROPIC_BASE_URL` resolution is skipped
+          # entirely.
+          @api_key = nil
+          @auth_token = nil
+          @credentials = nil
+          @token_cache = nil
+
+          Anthropic::Internal::Transport::BaseClient.instance_method(:initialize).bind(self).call(
+            base_url: base_url,
+            timeout: timeout,
+            max_retries: max_retries,
+            initial_retry_delay: initial_retry_delay,
+            max_retry_delay: max_retry_delay,
+            headers: {"anthropic-version" => "2023-06-01"},
+            middleware: middleware
+          )
+
+          @messages = Anthropic::Resources::Messages.new(client: self)
+          @models = Anthropic::Resources::Models.new(client: self)
+          @beta = Anthropic::Resources::Beta.new(client: self)
+        end
+
+        # The deprecated text Completions endpoint is not supported on the
+        # Google Cloud gateway.
+        #
+        # @raise [NotImplementedError]
+        def completions
+          raise NotImplementedError.new(
+            "The deprecated text Completions API is not supported on the Google Cloud gateway."
+          )
+        end
+
+        # @api private
+        #
+        # Hard guarantee that no first-party `X-Api-Key` / `Authorization`
+        # header from static credentials reaches the wire; auth is the GCP
+        # bearer token attached in {#provider_middleware}.
+        #
+        # @return [Hash{String=>String}]
+        private def auth_headers = {}
+
+        # @api private
+        #
+        # The Google Cloud provider middleware: applies the Google OAuth
+        # `authorization` bearer token. Appended innermost on every dispatch
+        # (below user middleware) and runs per attempt. Pure — requests are reused across
+        # retry attempts, so the incoming `req` is never mutated.
+        #
+        # @return [#call]
+        private def provider_middleware
+          lambda do |req, nxt|
+            nxt.call(apply_auth(req))
+          end
+        end
+
+        # @api private
+        #
+        # @param req [Anthropic::APIRequest]
+        # @return [Anthropic::APIRequest]
+        private def apply_auth(req)
+          # `req.headers` is the deep-frozen hash a middleware saw; splat into a
+          # fresh mutable copy so googleauth's `#apply` (which `clone`s then
+          # `[]=`s) doesn't raise.
+          headers = {**req.headers}
+
+          # `follow_redirect` stripped `authorization` for a cross-origin hop —
+          # don't re-add it and leak the bearer token to the new origin.
+          if !@skip_auth && !req.metadata[:cross_origin_redirect] && !headers.key?("authorization")
+            headers =
+              if @token_provider
+                headers.merge("authorization" => "Bearer #{@token_provider.call}")
+              else
+                @authorization.apply(headers)
+              end
+          end
+
+          req.with(headers: headers)
+        end
+
+        # @api private
+        #
+        # @return [String]
+        # @raise [ArgumentError]
+        private def derive_base_url
+          if @project.nil?
+            raise ArgumentError.new(
+              "No project found. Set the `project` argument, set the " \
+              "`ANTHROPIC_GOOGLE_CLOUD_PROJECT` environment variable, or configure " \
+              "application default credentials with a project."
+            )
+          end
+          if @workspace_id.nil?
+            raise ArgumentError.new(
+              "No workspace ID was given. Set the `workspace_id` argument or the " \
+              "`ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` environment variable."
+            )
+          end
+          format(URL_TEMPLATE, project: @project, location: @location, workspace_id: @workspace_id)
+        end
+
+        # @api private
+        private def require_googleauth
+          require("googleauth")
+        rescue LoadError
+          message = <<~MSG
+
+            In order to use the Anthropic Google Cloud client you must require the `googleauth` gem.
+            You can install it by adding the following to your Gemfile:
+
+                gem "googleauth"
+
+            and then running `bundle install`.
+
+            Alternatively, if you are not using Bundler, simply run:
+
+                gem install googleauth
+          MSG
+
+          raise RuntimeError.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/sessions/event_accumulator.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Sessions
+      # Accumulates session stream events into `agent.message` snapshots.
+      #
+      # `event_delta` previews are lossy and best-effort; the buffered final
+      # `agent.message` event is canonical and replaces whatever the preview
+      # accumulated. A `span.model_request_end` event closes all open previews
+      # (the producing model request ended without emitting the buffered
+      # event), discarding their partial snapshots.
+      #
+      # @example
+      #   accumulator = Anthropic::Helpers::Sessions::EventAccumulator.new
+      #   accumulator.wrap(stream).each do |event|
+      #     print accumulator.agent_message_text(event.event_id) if event.type == :event_delta
+      #   end
+      class EventAccumulator
+        # Raised when the delta stream is malformed: an `event_delta` whose
+        # `event_start` was never seen, or whose index is out of range for the
+        # accumulated content.
+        class AccumulationError < Anthropic::Errors::Error
+        end
+
+        # Snapshots keyed by event id, including those still accumulating.
+        # While a preview is open the snapshot is partial and its
+        # `processed_at` is unset; once the buffered final `agent.message`
+        # arrives it is the canonical event.
+        #
+        # @return [Hash{String => Anthropic::Models::Beta::Sessions::BetaManagedAgentsAgentMessageEvent}]
+        attr_reader :agent_messages
+
+        def initialize
+          @agent_messages = {}
+        end
+
+        # Folds one stream event into the accumulated state and returns the
+        # event unchanged.
+        #
+        # @param event [Anthropic::Models::Beta::Sessions::BetaManagedAgentsStreamSessionEvents]
+        #
+        # @raise [Anthropic::Helpers::Sessions::EventAccumulator::AccumulationError]
+        #   on an `event_delta` whose `event_start` was never seen, or whose
+        #   index is out of range for the accumulated content.
+        #
+        # @return [Anthropic::Models::Beta::Sessions::BetaManagedAgentsStreamSessionEvents]
+        def accumulate(event)
+          case event.type
+          in :event_start
+            on_event_start(event)
+          in :event_delta
+            on_event_delta(event)
+          in :"agent.message"
+            @agent_messages[event.id] = event
+          in :"span.model_request_end"
+            # The model request ended without buffering the previewed events
+            # (an error or interrupt mid-stream); discard the open previews.
+            # Canonical events (`processed_at` set) survive.
+            @agent_messages.delete_if { |_, message| message.processed_at.nil? }
+          else
+            # Other event types carry no `agent.message` content.
+          end
+          event
+        end
+
+        # Returns an Enumerator that lazily folds each event from `enum`
+        # through {#accumulate} and yields it unchanged. The enumerator is
+        # fused: it can be consumed once, and re-iterating yields nothing
+        # rather than folding deltas a second time.
+        #
+        # @param enum [Enumerable<Anthropic::Models::Beta::Sessions::BetaManagedAgentsStreamSessionEvents>]
+        #
+        # @return [Enumerator<Anthropic::Models::Beta::Sessions::BetaManagedAgentsStreamSessionEvents>]
+        def wrap(enum)
+          Anthropic::Internal::Util.chain_fused(enum) do |yielder|
+            enum.each { yielder << accumulate(_1) }
+          end
+        end
+
+        # The concatenated text of the accumulated `agent.message` with the
+        # given event id, or `nil` when the id is unknown.
+        #
+        # @param event_id [String]
+        #
+        # @return [String, nil]
+        def agent_message_text(event_id)
+          @agent_messages[event_id]&.content&.filter_map { _1.text if _1.type == :text }&.join
+        end
+
+        private
+
+        def on_event_start(event)
+          # `agent.thinking` previews are start-only today; deltas may come later.
+          return unless event.event.type == :"agent.message"
+
+          id = event.event.id
+          # `processed_at` is left unset: that is what marks the snapshot as an
+          # open preview until the buffered final event reconciles it.
+          @agent_messages[id] = Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent.new(
+            id: id,
+            type: :"agent.message",
+            content: []
+          )
+        end
+
+        def on_event_delta(event)
+          snapshot = @agent_messages[event.event_id]
+          if snapshot.nil?
+            raise AccumulationError.new(
+              "event_delta for #{event.event_id} received before its event_start"
+            )
+          end
+
+          # The final event is canonical; drop deltas that straggle in after it.
+          return unless snapshot.processed_at.nil?
+
+          index = event.delta.index || 0
+          fragment = event.delta.content
+          content = snapshot.content
+
+          # Indices arrive in order — the first delta at a new index opens the
+          # slot. A gap means deltas arrived out of order or were mis-routed.
+          unless (0..content.length).cover?(index)
+            raise AccumulationError.new(
+              "event_delta index #{index} is beyond the end of content (length #{content.length})"
+            )
+          end
+
+          existing = content[index]
+          if existing.nil?
+            # Copy the fragment so later appends never mutate the wire event.
+            block = Anthropic::Beta::Sessions::BetaManagedAgentsTextBlock.new(
+              type: fragment.type,
+              text: fragment.text
+            )
+            snapshot.content = content + [block]
+          elsif fragment.type == :text && existing.type == :text
+            existing.text += fragment.text
+          else
+            # Unrecognised fragment type: no-op; the canonical event fills the gap.
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/streaming/events.rb

@@ -107,11 +107,13 @@ module Anthropic
         required :partial_json, String
 
         # @!attribute snapshot
-        #   The currently accumulated parsed object up to this point in the stream.
+        #   The raw accumulated partial-JSON string for the tool input up to this
+        #   point in the stream. Decoded into the finished block's `input` when the
+        #   content block stops.
         #
         #   Example:
         #   ```
-        #   {'location': 'San Francisco, CA'}
+        #   '{"location":"San Francisco'
         #   ```
         #
         #   @return [Object]

data/lib/anthropic/helpers/streaming/message_stream.rb

@@ -141,6 +141,20 @@ module Anthropic
               content.encrypted_content = delta.encrypted_content
             else
             end
+          in Anthropic::Models::RawContentBlockStopEvent | Anthropic::Models::BetaRawContentBlockStopEvent
+            # The input_json_delta arm above buffers into `input` as a raw String so the
+            # streaming `input_json` events can expose the partial snapshot verbatim; the
+            # finished block must carry the decoded object, as in the non-streaming
+            # message and the other SDKs' accumulators.
+            case current_snapshot.content[event.index]
+            in {type: :tool_use, input: String => raw} => content
+              begin
+                content.input = decode_tool_use_input(raw)
+              rescue JSON::ParserError
+                # malformed complete input JSON from the server: leave the raw buffer
+              end
+            else
+            end
           in Anthropic::Models::RawMessageDeltaEvent | Anthropic::Models::BetaRawMessageDeltaEvent
             current_snapshot.stop_reason = event.delta.stop_reason
             current_snapshot.stop_sequence = event.delta.stop_sequence
@@ -248,6 +262,18 @@ module Anthropic
           events_to_yield
         end
 
+        # @api private
+        #
+        # Decodes a tool_use block's buffered partial-JSON input. An empty buffer
+        # means a no-argument tool call, which the wire encodes as an empty object.
+        #
+        # @param raw [String]
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def decode_tool_use_input(raw)
+          raw.empty? ? {} : JSON.parse(raw, symbolize_names: true)
+        end
+
         # @api private
         #
         # Parse tool use blocks and text blocks with structured output in the message.
@@ -267,7 +293,7 @@ module Anthropic
               parsed =
                 begin
                   parsed_input = if content.input.is_a?(String)
-                    JSON.parse(content.input, symbolize_names: true)
+                    decode_tool_use_input(content.input)
                   else
                     content.input
                   end

data/lib/anthropic/models/anthropic_beta.rb

@@ -57,12 +57,16 @@ module Anthropic
 
       variant const: -> { Anthropic::Models::AnthropicBeta::CACHE_DIAGNOSIS_2026_04_07 }
 
+      variant const: -> { Anthropic::Models::AnthropicBeta::DREAMING_2026_04_21 }
+
       variant const: -> { Anthropic::Models::AnthropicBeta::THINKING_TOKEN_COUNT_2026_05_13 }
 
       variant const: -> { Anthropic::Models::AnthropicBeta::SERVER_SIDE_FALLBACK_2026_06_01 }
 
       variant const: -> { Anthropic::Models::AnthropicBeta::FALLBACK_CREDIT_2026_06_01 }
 
+      variant const: -> { Anthropic::Models::AnthropicBeta::AGENT_MEMORY_2026_07_22 }
+
       # @!method self.variants
       #   @return [Array(String, Symbol)]
 
@@ -97,9 +101,11 @@ module Anthropic
       ADVISOR_TOOL_2026_03_01 = :"advisor-tool-2026-03-01"
       MANAGED_AGENTS_2026_04_01 = :"managed-agents-2026-04-01"
       CACHE_DIAGNOSIS_2026_04_07 = :"cache-diagnosis-2026-04-07"
+      DREAMING_2026_04_21 = :"dreaming-2026-04-21"
       THINKING_TOKEN_COUNT_2026_05_13 = :"thinking-token-count-2026-05-13"
       SERVER_SIDE_FALLBACK_2026_06_01 = :"server-side-fallback-2026-06-01"
       FALLBACK_CREDIT_2026_06_01 = :"fallback-credit-2026-06-01"
+      AGENT_MEMORY_2026_07_22 = :"agent-memory-2026-07-22"
 
       # @!endgroup
     end