anthropic 1.80.0 → 2.3.0

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_path_conflict_error.rbi

@@ -13,11 +13,7 @@ module Anthropic
               )
             end
 
-          sig do
-            returns(
-              Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type::OrSymbol
-            )
-          end
+          sig { returns(Symbol) }
           attr_accessor :type
 
           # The ID of the memory that blocked the write (`mem_...`), or an empty string if
@@ -46,8 +42,9 @@ module Anthropic
           sig { params(message: String).void }
           attr_writer :message
 
-          # The error returned with HTTP status 409 when a create or rename targets a path
-          # that another memory uses, or a path that overlaps another memory's path.
+          # The error returned with HTTP status 409 when you create or rename a memory and
+          # the path you give is already used by another memory or overlaps another memory's
+          # path.
           #
           # Two paths overlap when one is an ancestor of the other, such as `/notes` and
           # `/notes/todo.md`. To free the path, rename or delete the memory that
@@ -55,15 +52,13 @@ module Anthropic
           # creating a new one, update it.
           sig do
             params(
-              type:
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type::OrSymbol,
               conflicting_memory_id: String,
               conflicting_path: String,
-              message: String
+              message: String,
+              type: Symbol
             ).returns(T.attached_class)
           end
           def self.new(
-            type:,
             # The ID of the memory that blocked the write (`mem_...`), or an empty string if
             # that memory can't be identified.
             #
@@ -74,15 +69,15 @@ module Anthropic
             conflicting_path: nil,
             # A human-readable explanation of the conflict. To handle the error in code, use
             # `conflicting_path` and `conflicting_memory_id` instead.
-            message: nil
+            message: nil,
+            type: :memory_path_conflict_error
           )
           end
 
           sig do
             override.returns(
               {
-                type:
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type::OrSymbol,
+                type: Symbol,
                 conflicting_memory_id: String,
                 conflicting_path: String,
                 message: String
@@ -91,35 +86,6 @@ module Anthropic
           end
           def to_hash
           end
-
-          module Type
-            extend Anthropic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            MEMORY_PATH_CONFLICT_ERROR =
-              T.let(
-                :memory_path_conflict_error,
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPathConflictError::Type::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
         end
       end
     end

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_precondition_failed_error.rbi

@@ -13,11 +13,7 @@ module Anthropic
               )
             end
 
-          sig do
-            returns(
-              Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type::OrSymbol
-            )
-          end
+          sig { returns(Symbol) }
           attr_accessor :type
 
           # A human-readable explanation of why the precondition failed.
@@ -38,59 +34,18 @@ module Anthropic
           # [memory guide](https://platform.claude.com/docs/en/managed-agents/memory#safe-content-edits-optimistic-concurrency)
           # to learn more about safe content edits with content hash preconditions.
           sig do
-            params(
-              type:
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type::OrSymbol,
-              message: String
-            ).returns(T.attached_class)
+            params(message: String, type: Symbol).returns(T.attached_class)
           end
           def self.new(
-            type:,
             # A human-readable explanation of why the precondition failed.
-            message: nil
+            message: nil,
+            type: :memory_precondition_failed_error
           )
           end
 
-          sig do
-            override.returns(
-              {
-                type:
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type::OrSymbol,
-                message: String
-              }
-            )
-          end
+          sig { override.returns({ type: Symbol, message: String }) }
           def to_hash
           end
-
-          module Type
-            extend Anthropic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            MEMORY_PRECONDITION_FAILED_ERROR =
-              T.let(
-                :memory_precondition_failed_error,
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPreconditionFailedError::Type::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
         end
       end
     end

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_prefix.rbi

@@ -19,75 +19,29 @@ module Anthropic
           sig { returns(String) }
           attr_accessor :path
 
-          sig do
-            returns(
-              Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type::TaggedSymbol
-            )
-          end
+          sig { returns(Symbol) }
           attr_accessor :type
 
-          # A rolled-up directory marker returned by
-          # [List memories](/en/api/beta/memory_stores/memories/list) when `depth` is set.
-          # Indicates that one or more memories exist deeper than the requested depth under
-          # this prefix. This is a list-time rollup, not a stored resource; it has no ID and
-          # no lifecycle. Each prefix counts toward the page `limit` and interleaves with
-          # `memory` items in path order.
-          sig do
-            params(
-              path: String,
-              type:
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type::OrSymbol
-            ).returns(T.attached_class)
-          end
+          # A directory marker that
+          # [List Memories](https://platform.claude.com/docs/en/api/beta/memory_stores/memories/list)
+          # returns instead of the memories below the requested `depth`.
+          #
+          # It stands for one or more memories whose paths start with `path`. It isn't a
+          # stored object and doesn't have an ID. Each marker counts toward the page
+          # `limit`.
+          sig { params(path: String, type: Symbol).returns(T.attached_class) }
           def self.new(
             # The rolled-up path prefix, including a trailing `/` (e.g. `/projects/foo/`).
             # Pass this value as `path_prefix` on a subsequent list call to drill into the
             # directory.
             path:,
-            type:
+            type: :memory_prefix
           )
           end
 
-          sig do
-            override.returns(
-              {
-                path: String,
-                type:
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type::TaggedSymbol
-              }
-            )
-          end
+          sig { override.returns({ path: String, type: Symbol }) }
           def to_hash
           end
-
-          module Type
-            extend Anthropic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            MEMORY_PREFIX =
-              T.let(
-                :memory_prefix,
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryPrefix::Type::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
         end
       end
     end

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_version.rbi

@@ -21,10 +21,11 @@ module Anthropic
           sig { returns(Time) }
           attr_accessor :created_at
 
-          # ID of the memory this version snapshots (a `mem_...` value). Remains valid after
-          # the memory is deleted; pass it as `memory_id` to
-          # [List memory versions](/en/api/beta/memory_stores/memory_versions/list) to
-          # retrieve the memory's retained versions, including the `deleted` row while the
+          # The ID of the memory that this version belongs to (`mem_...`).
+          #
+          # The ID stays valid after the memory is deleted. Pass it as `memory_id` to
+          # [List Memory Versions](https://platform.claude.com/docs/en/api/beta/memory_stores/memory_versions/list)
+          # to get the memory's retained versions, including its `deleted` version while the
           # lineage is retained.
           sig { returns(String) }
           attr_accessor :memory_id
@@ -41,11 +42,7 @@ module Anthropic
           end
           attr_accessor :operation
 
-          sig do
-            returns(
-              Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type::TaggedSymbol
-            )
-          end
+          sig { returns(Symbol) }
           attr_accessor :type
 
           # The memory's UTF-8 text content as of this version. `null` when `view=basic`,
@@ -64,13 +61,16 @@ module Anthropic
           sig { returns(T.nilable(Integer)) }
           attr_accessor :content_size_bytes
 
-          # Who performed this write: one of `session_actor`, `api_actor`, `user_actor`, or
-          # `service_account_actor`; `null` when no writer is recorded. Captured at write
-          # time and preserved through redaction. A `session_actor` is an agent writing
-          # through the store's mounted filesystem at `/mnt/memory/`. The API key that
-          # created that session is not recorded on agent writes, so attribution names who
-          # made the write, not who is ultimately responsible; look up session provenance
-          # via the [Sessions API](/en/api/beta/sessions/retrieve).
+          # Who made this change to the memory, or `null` if the author wasn't recorded.
+          #
+          # Redacting the version doesn't change this field. A `session_actor` here is an
+          # agent that wrote through the store's mounted filesystem at `/mnt/memory/`. The
+          # version doesn't record the API key that created that session. So the author in
+          # `created_by` is who made the change, not who is ultimately responsible for it.
+          #
+          # You can
+          # [retrieve the session](https://platform.claude.com/docs/en/api/beta/sessions/retrieve)
+          # to learn more about where the change came from.
           sig do
             returns(
               T.nilable(
@@ -98,10 +98,14 @@ module Anthropic
           sig { returns(T.nilable(String)) }
           attr_accessor :path
 
-          # When this version was redacted, in RFC 3339 format, or `null` if it has not been
-          # redacted. When set, `content`, `path`, `content_size_bytes`, and
-          # `content_sha256` are all `null`. See
-          # [Redact a memory version](/en/api/beta/memory_stores/memory_versions/redact).
+          # When the version was redacted, in RFC 3339, or `null` if it hasn't been.
+          #
+          # When set, `content`, `path`, `content_size_bytes`, and `content_sha256` are
+          # `null`.
+          #
+          # See the
+          # [memory guide](https://platform.claude.com/docs/en/managed-agents/memory#redact-a-version)
+          # to learn more about redaction.
           sig { returns(T.nilable(Time)) }
           attr_accessor :redacted_at
 
@@ -130,14 +134,20 @@ module Anthropic
           end
           attr_writer :redacted_by
 
-          # A `memory_version` object: one immutable, attributed row in a memory's
-          # append-only history. Every non-no-op mutation to a memory produces a new
-          # version. Versions belong to the store (not the individual memory) and are not
-          # deleted with the memory; each version is retained for at least the version
-          # retention period after it was written, unless the store itself is deleted.
-          # Retrieving a redacted version returns 200 with `content`, `path`,
-          # `content_size_bytes`, and `content_sha256` set to `null`; branch on
-          # `redacted_at`, not HTTP status.
+          # One entry in a memory's history, recording a single change and who made it.
+          #
+          # Every change to a memory adds one version. Only redaction can change a version
+          # after that. Versions belong to the memory store and stay after the memory is
+          # deleted. Each version is retained for at least the version retention period
+          # after it was written, unless the store itself is deleted.
+          #
+          # Retrieving a redacted version succeeds, with `content`, `path`,
+          # `content_size_bytes`, and `content_sha256` set to `null`. Check `redacted_at` to
+          # find out whether a version was redacted.
+          #
+          # See the
+          # [memory guide](https://platform.claude.com/docs/en/managed-agents/memory#audit-memory-changes)
+          # to learn more about memory versions.
           sig do
             params(
               id: String,
@@ -146,8 +156,6 @@ module Anthropic
               memory_store_id: String,
               operation:
                 Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersionOperation::OrSymbol,
-              type:
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type::OrSymbol,
               content: T.nilable(String),
               content_sha256: T.nilable(String),
               content_size_bytes: T.nilable(Integer),
@@ -166,7 +174,8 @@ module Anthropic
                   Anthropic::Beta::MemoryStores::BetaManagedAgentsAPIActor::OrHash,
                   Anthropic::Beta::MemoryStores::BetaManagedAgentsUserActor::OrHash,
                   Anthropic::Beta::MemoryStores::BetaManagedAgentsServiceAccountActor::OrHash
-                )
+                ),
+              type: Symbol
             ).returns(T.attached_class)
           end
           def self.new(
@@ -174,17 +183,17 @@ module Anthropic
             id:,
             # When this version was written, in RFC 3339 format.
             created_at:,
-            # ID of the memory this version snapshots (a `mem_...` value). Remains valid after
-            # the memory is deleted; pass it as `memory_id` to
-            # [List memory versions](/en/api/beta/memory_stores/memory_versions/list) to
-            # retrieve the memory's retained versions, including the `deleted` row while the
+            # The ID of the memory that this version belongs to (`mem_...`).
+            #
+            # The ID stays valid after the memory is deleted. Pass it as `memory_id` to
+            # [List Memory Versions](https://platform.claude.com/docs/en/api/beta/memory_stores/memory_versions/list)
+            # to get the memory's retained versions, including its `deleted` version while the
             # lineage is retained.
             memory_id:,
             # ID of the memory store this version belongs to (a `memstore_...` value).
             memory_store_id:,
             # The kind of mutation this version records: `created`, `modified`, or `deleted`.
             operation:,
-            type:,
             # The memory's UTF-8 text content as of this version. `null` when `view=basic`,
             # when `operation` is `deleted`, or when `redacted_at` is set.
             content: nil,
@@ -195,26 +204,34 @@ module Anthropic
             # Size of `content` in bytes as of this version. `null` when `redacted_at` is set
             # or `operation` is `deleted`. Populated regardless of `view` otherwise.
             content_size_bytes: nil,
-            # Who performed this write: one of `session_actor`, `api_actor`, `user_actor`, or
-            # `service_account_actor`; `null` when no writer is recorded. Captured at write
-            # time and preserved through redaction. A `session_actor` is an agent writing
-            # through the store's mounted filesystem at `/mnt/memory/`. The API key that
-            # created that session is not recorded on agent writes, so attribution names who
-            # made the write, not who is ultimately responsible; look up session provenance
-            # via the [Sessions API](/en/api/beta/sessions/retrieve).
+            # Who made this change to the memory, or `null` if the author wasn't recorded.
+            #
+            # Redacting the version doesn't change this field. A `session_actor` here is an
+            # agent that wrote through the store's mounted filesystem at `/mnt/memory/`. The
+            # version doesn't record the API key that created that session. So the author in
+            # `created_by` is who made the change, not who is ultimately responsible for it.
+            #
+            # You can
+            # [retrieve the session](https://platform.claude.com/docs/en/api/beta/sessions/retrieve)
+            # to learn more about where the change came from.
             created_by: nil,
             # The memory's path at the time of this write. `null` if and only if `redacted_at`
             # is set.
             path: nil,
-            # When this version was redacted, in RFC 3339 format, or `null` if it has not been
-            # redacted. When set, `content`, `path`, `content_size_bytes`, and
-            # `content_sha256` are all `null`. See
-            # [Redact a memory version](/en/api/beta/memory_stores/memory_versions/redact).
+            # When the version was redacted, in RFC 3339, or `null` if it hasn't been.
+            #
+            # When set, `content`, `path`, `content_size_bytes`, and `content_sha256` are
+            # `null`.
+            #
+            # See the
+            # [memory guide](https://platform.claude.com/docs/en/managed-agents/memory#redact-a-version)
+            # to learn more about redaction.
             redacted_at: nil,
             # Who redacted this version, or `null` if it has not been redacted. In practice
             # always an `api_actor`, `user_actor`, or `service_account_actor` (agents do not
             # have a redact capability).
-            redacted_by: nil
+            redacted_by: nil,
+            type: :memory_version
           )
           end
 
@@ -227,8 +244,7 @@ module Anthropic
                 memory_store_id: String,
                 operation:
                   Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersionOperation::TaggedSymbol,
-                type:
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type::TaggedSymbol,
+                type: Symbol,
                 content: T.nilable(String),
                 content_sha256: T.nilable(String),
                 content_size_bytes: T.nilable(Integer),
@@ -243,35 +259,6 @@ module Anthropic
           end
           def to_hash
           end
-
-          module Type
-            extend Anthropic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            MEMORY_VERSION =
-              T.let(
-                :memory_version,
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsMemoryVersion::Type::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
         end
       end
     end

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_version_operation.rbi

@@ -4,8 +4,10 @@ module Anthropic
   module Models
     module Beta
       module MemoryStores
-        # The kind of mutation a `memory_version` records. Every non-no-op mutation to a
-        # memory appends exactly one version row with one of these values.
+        # The kind of change that a memory version records.
+        #
+        # Every change to a memory adds one version. If you update a memory and nothing
+        # changes, the memory doesn't get a new version.
         module BetaManagedAgentsMemoryVersionOperation
           extend Anthropic::Internal::Type::Enum
 

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_memory_view.rbi

@@ -4,11 +4,11 @@ module Anthropic
   module Models
     module Beta
       module MemoryStores
-        # Selects which projection of a `memory` or `memory_version` the server returns.
-        # `basic` returns the object with `content` set to `null`; `full` populates
-        # `content`. When omitted, the default is endpoint-specific: retrieve operations
-        # default to `full`; list, create, and update operations default to `basic`.
-        # Listing with `view=full` caps `limit` at 20.
+        # Whether a `memory` or `memory_version` in the response includes its `content`.
+        # Defaults to `full` on retrieve operations and to `basic` on list, create, and
+        # update operations.
+        #
+        # With `full`, list operations return at most 20 items per page.
         module BetaManagedAgentsMemoryView
           extend Anthropic::Internal::Type::Enum
 

data/rbi/anthropic/models/beta/memory_stores/beta_managed_agents_precondition.rbi

@@ -13,11 +13,7 @@ module Anthropic
               )
             end
 
-          sig do
-            returns(
-              Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type::OrSymbol
-            )
-          end
+          sig { returns(Symbol) }
           attr_accessor :type
 
           # Expected `content_sha256` of the stored memory (64 lowercase hexadecimal
@@ -36,62 +32,23 @@ module Anthropic
           # current content, not the destination path. Currently the only supported variant
           # is `content_sha256`.
           sig do
-            params(
-              type:
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type::OrSymbol,
-              content_sha256: String
-            ).returns(T.attached_class)
+            params(content_sha256: String, type: Symbol).returns(
+              T.attached_class
+            )
           end
           def self.new(
-            type:,
             # Expected `content_sha256` of the stored memory (64 lowercase hexadecimal
             # characters). Typically the `content_sha256` returned by a prior read or list
             # call. Because the server applies no content normalization, clients can also
             # compute this locally as the SHA-256 of the UTF-8 content bytes.
-            content_sha256: nil
+            content_sha256: nil,
+            type: :content_sha256
           )
           end
 
-          sig do
-            override.returns(
-              {
-                type:
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type::OrSymbol,
-                content_sha256: String
-              }
-            )
-          end
+          sig { override.returns({ type: Symbol, content_sha256: String }) }
           def to_hash
           end
-
-          module Type
-            extend Anthropic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            CONTENT_SHA256 =
-              T.let(
-                :content_sha256,
-                Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Anthropic::Beta::MemoryStores::BetaManagedAgentsPrecondition::Type::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
         end
       end
     end