cadenya 0.1.0

data/rbi/cadenya/models/memory_layers/memory_entry_detail.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module MemoryLayers
+      class MemoryEntryDetail < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::MemoryLayers::MemoryEntryDetail,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # The resolved body of the entry. For entries created or updated via an upload_id,
+        # this is the ingested content, not the original upload handle. May be empty; an
+        # entry with only a key and description is valid (e.g., a stub skill being
+        # drafted, or an entry where the frontmatter alone is the payload).
+        sig { returns(String) }
+        attr_accessor :content
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :metadata
+
+        # MemoryEntrySpec is the metadata portion of an entry — the fields that identify
+        # and describe it, without the body. It appears on both the summary (MemoryEntry)
+        # and detail (MemoryEntryDetail) views.
+        sig { returns(Cadenya::MemoryLayers::MemoryEntrySpec) }
+        attr_reader :spec
+
+        sig do
+          params(spec: Cadenya::MemoryLayers::MemoryEntrySpec::OrHash).void
+        end
+        attr_writer :spec
+
+        sig { returns(T.nilable(Cadenya::MemoryLayers::MemoryEntryInfo)) }
+        attr_reader :info
+
+        sig do
+          params(info: Cadenya::MemoryLayers::MemoryEntryInfo::OrHash).void
+        end
+        attr_writer :info
+
+        # MemoryEntryDetail is the full representation of an entry, including the resolved
+        # content body. Returned by GetMemoryEntry, CreateMemoryEntry, and
+        # UpdateMemoryEntry.
+        sig do
+          params(
+            content: String,
+            metadata: Cadenya::ResourceMetadata::OrHash,
+            spec: Cadenya::MemoryLayers::MemoryEntrySpec::OrHash,
+            info: Cadenya::MemoryLayers::MemoryEntryInfo::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The resolved body of the entry. For entries created or updated via an upload_id,
+          # this is the ingested content, not the original upload handle. May be empty; an
+          # entry with only a key and description is valid (e.g., a stub skill being
+          # drafted, or an entry where the frontmatter alone is the payload).
+          content:,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          metadata:,
+          # MemoryEntrySpec is the metadata portion of an entry — the fields that identify
+          # and describe it, without the body. It appears on both the summary (MemoryEntry)
+          # and detail (MemoryEntryDetail) views.
+          spec:,
+          info: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content: String,
+              metadata: Cadenya::ResourceMetadata,
+              spec: Cadenya::MemoryLayers::MemoryEntrySpec,
+              info: Cadenya::MemoryLayers::MemoryEntryInfo
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layers/memory_entry_info.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module MemoryLayers
+      class MemoryEntryInfo < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::MemoryLayers::MemoryEntryInfo,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # A profile identifies a user or non-human principal (such as an API key) at the
+        # account level. Profiles are account-scoped and can be granted access to multiple
+        # workspaces.
+        sig { returns(T.nilable(Cadenya::Profile)) }
+        attr_reader :created_by
+
+        sig { params(created_by: Cadenya::Profile::OrHash).void }
+        attr_writer :created_by
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(T.nilable(Cadenya::ResourceMetadata)) }
+        attr_reader :memory_layer
+
+        sig { params(memory_layer: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :memory_layer
+
+        sig do
+          params(
+            created_by: Cadenya::Profile::OrHash,
+            memory_layer: Cadenya::ResourceMetadata::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A profile identifies a user or non-human principal (such as an API key) at the
+          # account level. Profiles are account-scoped and can be granted access to multiple
+          # workspaces.
+          created_by: nil,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          memory_layer: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              created_by: Cadenya::Profile,
+              memory_layer: Cadenya::ResourceMetadata
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layers/memory_entry_spec.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module MemoryLayers
+      class MemoryEntrySpec < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::MemoryLayers::MemoryEntrySpec,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # The lookup key for this entry within its layer. Must conform to the S3 object
+        # key safe-characters spec: ASCII alphanumerics and the special characters !, -,
+        # \_, ., \*, ', (, ), and /. Forward slashes may be used to suggest hierarchy
+        # (e.g., "skills/postmortem/write"), but lookups are flat — the key is a single
+        # opaque string, not a path.
+        #
+        # Additional rules enforced by the service:
+        #
+        # - May not begin or end with /
+        # - May not contain consecutive slashes (//)
+        # - May not begin with reserved prefixes (cadenya/, system/)
+        # - Case-sensitive
+        # - Unique within the parent layer
+        #
+        # For skills entries, this key is also the id the model passes to
+        # memory_load_skill when it decides to load the entry's content.
+        sig { returns(String) }
+        attr_accessor :key
+
+        # One-line "when to use this" hint shown in the frontmatter manifest for skills
+        # entries. The model uses this to decide whether to load the body, so it should be
+        # written for the model as the audience. Ignored for layer types that do not
+        # advertise frontmatter.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # MemoryEntrySpec is the metadata portion of an entry — the fields that identify
+        # and describe it, without the body. It appears on both the summary (MemoryEntry)
+        # and detail (MemoryEntryDetail) views.
+        sig do
+          params(key: String, description: String).returns(T.attached_class)
+        end
+        def self.new(
+          # The lookup key for this entry within its layer. Must conform to the S3 object
+          # key safe-characters spec: ASCII alphanumerics and the special characters !, -,
+          # \_, ., \*, ', (, ), and /. Forward slashes may be used to suggest hierarchy
+          # (e.g., "skills/postmortem/write"), but lookups are flat — the key is a single
+          # opaque string, not a path.
+          #
+          # Additional rules enforced by the service:
+          #
+          # - May not begin or end with /
+          # - May not contain consecutive slashes (//)
+          # - May not begin with reserved prefixes (cadenya/, system/)
+          # - Case-sensitive
+          # - Unique within the parent layer
+          #
+          # For skills entries, this key is also the id the model passes to
+          # memory_load_skill when it decides to load the entry's content.
+          key:,
+          # One-line "when to use this" hint shown in the frontmatter manifest for skills
+          # entries. The model uses this to decide whether to load the body, so it should be
+          # written for the model as the audience. Ignored for layer types that do not
+          # advertise frontmatter.
+          description: nil
+        )
+        end
+
+        sig { override.returns({ key: String, description: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layers/memory_entry_update_spec.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module MemoryLayers
+      class MemoryEntryUpdateSpec < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::MemoryLayers::MemoryEntryUpdateSpec,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :content
+
+        sig { params(content: String).void }
+        attr_writer :content
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :key
+
+        sig { params(key: String).void }
+        attr_writer :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :upload_id
+
+        sig { params(upload_id: String).void }
+        attr_writer :upload_id
+
+        # MemoryEntryUpdateSpec is the input shape for UpdateMemoryEntry. Fields present
+        # in the request's update_mask are applied; unset fields are left alone. The
+        # source oneof is optional for updates — omit it to leave the body untouched, or
+        # set exactly one branch to replace it.
+        sig do
+          params(
+            content: String,
+            description: String,
+            key: String,
+            upload_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(content: nil, description: nil, key: nil, upload_id: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              content: String,
+              description: String,
+              key: String,
+              upload_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_read.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryRead < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::MemoryRead, Cadenya::Internal::AnyHash) }
+
+      # The specific entry that was read.
+      sig { returns(T.nilable(String)) }
+      attr_reader :memory_entry_id
+
+      sig { params(memory_entry_id: String).void }
+      attr_writer :memory_entry_id
+
+      # The layer the entry resolved to. The top-most layer that contained the key —
+      # other layers beneath it that also contained the key are shadowed and not
+      # referenced here.
+      sig { returns(T.nilable(String)) }
+      attr_reader :memory_layer_id
+
+      sig { params(memory_layer_id: String).void }
+      attr_writer :memory_layer_id
+
+      # Human-readable description of the read, set by the runtime. For example: "Loaded
+      # skill", "Resolved context key". Not machine-parsed; intended for UI display
+      # alongside the other events in an objective's timeline.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # MemoryRead is emitted each time the agent resolves a key against the memory
+      # stack and loads an entry. Lookups that miss (key not found in any layer) do not
+      # emit this event.
+      sig do
+        params(
+          memory_entry_id: String,
+          memory_layer_id: String,
+          message: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The specific entry that was read.
+        memory_entry_id: nil,
+        # The layer the entry resolved to. The top-most layer that contained the key —
+        # other layers beneath it that also contained the key are shadowed and not
+        # referenced here.
+        memory_layer_id: nil,
+        # Human-readable description of the read, set by the runtime. For example: "Loaded
+        # skill", "Resolved context key". Not machine-parsed; intended for UI display
+        # alongside the other events in an objective's timeline.
+        message: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { memory_entry_id: String, memory_layer_id: String, message: String }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_reference.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryReference < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryReference, Cadenya::Internal::AnyHash)
+        end
+
+      # When set, pushes only this entry from memory_layer_id onto the stack — behaves
+      # as a single-entry layer (only this key resolves at this position). The entry
+      # must belong to memory_layer_id; mismatches are rejected with InvalidArgument.
+      sig { returns(T.nilable(String)) }
+      attr_reader :memory_entry_id
+
+      sig { params(memory_entry_id: String).void }
+      attr_writer :memory_entry_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :memory_layer_id
+
+      sig { params(memory_layer_id: String).void }
+      attr_writer :memory_layer_id
+
+      # MemoryReference identifies a memory layer or a specific entry within one, for
+      # composition into a memory stack. Used on objectives (where entry pinning is
+      # permitted).
+      #
+      # memory*layer_id accepts both the canonical form (memlyr*…) and the external-id
+      # form (external_id:my-custom-id). The same applies to memory_entry_id when set.
+      sig do
+        params(memory_entry_id: String, memory_layer_id: String).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # When set, pushes only this entry from memory_layer_id onto the stack — behaves
+        # as a single-entry layer (only this key resolves at this position). The entry
+        # must belong to memory_layer_id; mismatches are rejected with InvalidArgument.
+        memory_entry_id: nil,
+        memory_layer_id: nil
+      )
+      end
+
+      sig do
+        override.returns({ memory_entry_id: String, memory_layer_id: String })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/model.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class Model < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::Model, Cadenya::Internal::AnyHash) }
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(Cadenya::ResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::ResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      # Model specification
+      sig { returns(Cadenya::ModelSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ModelSpec::OrHash).void }
+      attr_writer :spec
+
+      sig do
+        params(
+          metadata: Cadenya::ResourceMetadata::OrHash,
+          spec: Cadenya::ModelSpec::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        metadata:,
+        # Model specification
+        spec:
+      )
+      end
+
+      sig do
+        override.returns(
+          { metadata: Cadenya::ResourceMetadata, spec: Cadenya::ModelSpec }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/model_list_params.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ModelListParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ModelListParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # Filter by bundle_key — return only resources owned by this bundle.
+      sig { returns(T.nilable(String)) }
+      attr_reader :bundle_key
+
+      sig { params(bundle_key: String).void }
+      attr_writer :bundle_key
+
+      # Pagination cursor from previous response
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Maximum number of results to return
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Filter by name prefix
+      sig { returns(T.nilable(String)) }
+      attr_reader :prefix
+
+      sig { params(prefix: String).void }
+      attr_writer :prefix
+
+      # Free-form search query
+      sig { returns(T.nilable(String)) }
+      attr_reader :query
+
+      sig { params(query: String).void }
+      attr_writer :query
+
+      # Sort order for results (asc or desc by creation time)
+      sig { returns(T.nilable(String)) }
+      attr_reader :sort_order
+
+      sig { params(sort_order: String).void }
+      attr_writer :sort_order
+
+      # Filter by model status
+      sig { returns(T.nilable(Cadenya::ModelListParams::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Cadenya::ModelListParams::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          workspace_id: String,
+          bundle_key: String,
+          cursor: String,
+          limit: Integer,
+          prefix: String,
+          query: String,
+          sort_order: String,
+          status: Cadenya::ModelListParams::Status::OrSymbol,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # Filter by bundle_key — return only resources owned by this bundle.
+        bundle_key: nil,
+        # Pagination cursor from previous response
+        cursor: nil,
+        # Maximum number of results to return
+        limit: nil,
+        # Filter by name prefix
+        prefix: nil,
+        # Free-form search query
+        query: nil,
+        # Sort order for results (asc or desc by creation time)
+        sort_order: nil,
+        # Filter by model status
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            bundle_key: String,
+            cursor: String,
+            limit: Integer,
+            prefix: String,
+            query: String,
+            sort_order: String,
+            status: Cadenya::ModelListParams::Status::OrSymbol,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by model status
+      module Status
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::ModelListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MODEL_STATUS_UNSPECIFIED =
+          T.let(
+            :MODEL_STATUS_UNSPECIFIED,
+            Cadenya::ModelListParams::Status::TaggedSymbol
+          )
+        MODEL_STATUS_ENABLED =
+          T.let(
+            :MODEL_STATUS_ENABLED,
+            Cadenya::ModelListParams::Status::TaggedSymbol
+          )
+        MODEL_STATUS_DISABLED =
+          T.let(
+            :MODEL_STATUS_DISABLED,
+            Cadenya::ModelListParams::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ModelListParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/model_retrieve_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ModelRetrieveParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ModelRetrieveParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        params(
+          workspace_id: String,
+          id: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(workspace_id:, id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end