cadenya 0.1.0

data/rbi/cadenya/models/memory_entry_item.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryEntryItem < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryEntryItem, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :key
+
+      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 :upload_id
+
+      sig { params(upload_id: String).void }
+      attr_writer :upload_id
+
+      sig do
+        params(
+          key: String,
+          content: String,
+          description: String,
+          upload_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(key:, content: nil, description: nil, upload_id: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            key: String,
+            content: String,
+            description: String,
+            upload_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayer < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::MemoryLayer, 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
+
+      sig { returns(Cadenya::MemoryLayerSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::MemoryLayerSpec::OrHash).void }
+      attr_writer :spec
+
+      sig { returns(T.nilable(Cadenya::MemoryLayerInfo)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::MemoryLayerInfo::OrHash).void }
+      attr_writer :info
+
+      # MemoryLayer is a named container of memory entries that can be composed into an
+      # objective's memory stack. Layers are workspace-scoped resources. The layer type
+      # controls how its entries participate in the agent loop — see MemoryLayerType for
+      # details.
+      #
+      # See "Memory stack composition" above for how layers compose at lookup time.
+      sig do
+        params(
+          metadata: Cadenya::ResourceMetadata::OrHash,
+          spec: Cadenya::MemoryLayerSpec::OrHash,
+          info: Cadenya::MemoryLayerInfo::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        metadata:,
+        spec:,
+        info: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            metadata: Cadenya::ResourceMetadata,
+            spec: Cadenya::MemoryLayerSpec,
+            info: Cadenya::MemoryLayerInfo
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer_create_params.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerCreateParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerCreateParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # CreateResourceMetadata contains the user-provided fields for creating a
+      # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+      # profile_id, created_at) are excluded since they are set by the server.
+      sig { returns(Cadenya::CreateResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::CreateResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::MemoryLayerSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::MemoryLayerSpec::OrHash).void }
+      attr_writer :spec
+
+      sig do
+        params(
+          workspace_id: String,
+          metadata: Cadenya::CreateResourceMetadata::OrHash,
+          spec: Cadenya::MemoryLayerSpec::OrHash,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # CreateResourceMetadata contains the user-provided fields for creating a
+        # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+        # profile_id, created_at) are excluded since they are set by the server.
+        metadata:,
+        spec:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            metadata: Cadenya::CreateResourceMetadata,
+            spec: Cadenya::MemoryLayerSpec,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer_delete_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerDeleteParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerDeleteParams, 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

data/rbi/cadenya/models/memory_layer_entry.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerEntry < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerEntry, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Cadenya::MemoryLayerSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::MemoryLayerSpec::OrHash).void }
+      attr_writer :spec
+
+      # Memory entries in this layer, keyed by external_id.
+      sig { returns(T.nilable(T::Hash[Symbol, Cadenya::MemoryEntryItem])) }
+      attr_reader :entries
+
+      sig do
+        params(entries: T::Hash[Symbol, Cadenya::MemoryEntryItem::OrHash]).void
+      end
+      attr_writer :entries
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      sig do
+        params(
+          name: String,
+          spec: Cadenya::MemoryLayerSpec::OrHash,
+          entries: T::Hash[Symbol, Cadenya::MemoryEntryItem::OrHash],
+          labels: T::Hash[Symbol, String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        name:,
+        spec:,
+        # Memory entries in this layer, keyed by external_id.
+        entries: nil,
+        labels: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            spec: Cadenya::MemoryLayerSpec,
+            entries: T::Hash[Symbol, Cadenya::MemoryEntryItem],
+            labels: T::Hash[Symbol, String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer_info.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerInfo < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerInfo, 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
+
+      # Number of entries currently in this layer.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :entry_count
+
+      sig { params(entry_count: Integer).void }
+      attr_writer :entry_count
+
+      # Timestamp of the most recent objective that resolved against this layer. Useful
+      # for surfacing unused layers in the dashboard.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :last_used_at
+
+      sig { params(last_used_at: Time).void }
+      attr_writer :last_used_at
+
+      sig do
+        params(
+          created_by: Cadenya::Profile::OrHash,
+          entry_count: Integer,
+          last_used_at: Time
+        ).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,
+        # Number of entries currently in this layer.
+        entry_count: nil,
+        # Timestamp of the most recent objective that resolved against this layer. Useful
+        # for surfacing unused layers in the dashboard.
+        last_used_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            created_by: Cadenya::Profile,
+            entry_count: Integer,
+            last_used_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer_list_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerListParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerListParams, 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
+
+      # When set to true you may use more of your alloted API rate-limit
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_info
+
+      sig { params(include_info: T::Boolean).void }
+      attr_writer :include_info
+
+      # Maximum number of results to return
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Filter expression (query param: 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 layer type
+      sig { returns(T.nilable(Cadenya::MemoryLayerListParams::Type::OrSymbol)) }
+      attr_reader :type
+
+      sig { params(type: Cadenya::MemoryLayerListParams::Type::OrSymbol).void }
+      attr_writer :type
+
+      sig do
+        params(
+          workspace_id: String,
+          bundle_key: String,
+          cursor: String,
+          include_info: T::Boolean,
+          limit: Integer,
+          prefix: String,
+          query: String,
+          sort_order: String,
+          type: Cadenya::MemoryLayerListParams::Type::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,
+        # When set to true you may use more of your alloted API rate-limit
+        include_info: nil,
+        # Maximum number of results to return
+        limit: nil,
+        # Filter expression (query param: prefix)
+        prefix: nil,
+        # Free-form search query
+        query: nil,
+        # Sort order for results (asc or desc by creation time)
+        sort_order: nil,
+        # Filter by layer type
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            bundle_key: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            prefix: String,
+            query: String,
+            sort_order: String,
+            type: Cadenya::MemoryLayerListParams::Type::OrSymbol,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by layer type
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::MemoryLayerListParams::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MEMORY_LAYER_TYPE_UNSPECIFIED =
+          T.let(
+            :MEMORY_LAYER_TYPE_UNSPECIFIED,
+            Cadenya::MemoryLayerListParams::Type::TaggedSymbol
+          )
+        MEMORY_LAYER_TYPE_EPISODIC =
+          T.let(
+            :MEMORY_LAYER_TYPE_EPISODIC,
+            Cadenya::MemoryLayerListParams::Type::TaggedSymbol
+          )
+        MEMORY_LAYER_TYPE_SKILLS =
+          T.let(
+            :MEMORY_LAYER_TYPE_SKILLS,
+            Cadenya::MemoryLayerListParams::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::MemoryLayerListParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/memory_layer_retrieve_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerRetrieveParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerRetrieveParams, 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

data/rbi/cadenya/models/memory_layer_spec.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class MemoryLayerSpec < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::MemoryLayerSpec, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::MemoryLayerSpec::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Human-readable description of the layer's purpose. Encouraged for user-created
+      # layers; system-managed layers may have a generated description.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # For layers with a finite lifetime (e.g., episodic), the time at which the layer
+      # becomes eligible for cleanup. Set by the system; unset for persistent layers.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :expires_at
+
+      sig { params(expires_at: Time).void }
+      attr_writer :expires_at
+
+      # Server-set. True for layers managed by the system (e.g., episodic layers created
+      # automatically when an objective uses an episodic_key). System-managed layers
+      # cannot be assigned to objective stacks via the API and cannot be mutated by
+      # clients — their lifecycle is controlled entirely by the runtime.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :system_managed
+
+      sig { params(system_managed: T::Boolean).void }
+      attr_writer :system_managed
+
+      sig do
+        params(
+          type: Cadenya::MemoryLayerSpec::Type::OrSymbol,
+          description: String,
+          expires_at: Time,
+          system_managed: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        type:,
+        # Human-readable description of the layer's purpose. Encouraged for user-created
+        # layers; system-managed layers may have a generated description.
+        description: nil,
+        # For layers with a finite lifetime (e.g., episodic), the time at which the layer
+        # becomes eligible for cleanup. Set by the system; unset for persistent layers.
+        expires_at: nil,
+        # Server-set. True for layers managed by the system (e.g., episodic layers created
+        # automatically when an objective uses an episodic_key). System-managed layers
+        # cannot be assigned to objective stacks via the API and cannot be mutated by
+        # clients — their lifecycle is controlled entirely by the runtime.
+        system_managed: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            type: Cadenya::MemoryLayerSpec::Type::OrSymbol,
+            description: String,
+            expires_at: Time,
+            system_managed: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::MemoryLayerSpec::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MEMORY_LAYER_TYPE_UNSPECIFIED =
+          T.let(
+            :MEMORY_LAYER_TYPE_UNSPECIFIED,
+            Cadenya::MemoryLayerSpec::Type::TaggedSymbol
+          )
+        MEMORY_LAYER_TYPE_EPISODIC =
+          T.let(
+            :MEMORY_LAYER_TYPE_EPISODIC,
+            Cadenya::MemoryLayerSpec::Type::TaggedSymbol
+          )
+        MEMORY_LAYER_TYPE_SKILLS =
+          T.let(
+            :MEMORY_LAYER_TYPE_SKILLS,
+            Cadenya::MemoryLayerSpec::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::MemoryLayerSpec::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end