cadenya 0.1.0

data/rbi/cadenya/models/agents/agent_variation_info.rbi

@@ -0,0 +1,176 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationInfo = Agents::AgentVariationInfo
+
+    module Agents
+      class AgentVariationInfo < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationInfo,
+              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
+
+        # Total number of objective feedbacks received for this variation
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :feedback_count
+
+        sig { params(feedback_count: Integer).void }
+        attr_writer :feedback_count
+
+        # Thompson Sampling score: posterior mean of Beta(ts_alpha, ts_beta). Range [0, 1]
+        # where 0.5 = neutral, >0.5 = positive, <0.5 = negative.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :score
+
+        sig { params(score: Float).void }
+        attr_writer :score
+
+        # All tools, tool sets, and sub-agents assigned to this variation. Populated on
+        # reads so clients can render a variation's full assignment list without calling
+        # the add/remove endpoints just to enumerate.
+        sig do
+          returns(T.nilable(T::Array[Cadenya::Agents::VariationAssignment]))
+        end
+        attr_reader :assignments
+
+        sig do
+          params(
+            assignments: T::Array[Cadenya::Agents::VariationAssignment::OrHash]
+          ).void
+        end
+        attr_writer :assignments
+
+        # Read-only list of memory layer assignments for this variation, returned in
+        # ascending `position` (bottom → top). Capped at 10 entries.
+        sig do
+          returns(
+            T.nilable(T::Array[Cadenya::Agents::VariationMemoryLayerAssignment])
+          )
+        end
+        attr_reader :memory_layer_assignments
+
+        sig do
+          params(
+            memory_layer_assignments:
+              T::Array[Cadenya::Agents::VariationMemoryLayerAssignment::OrHash]
+          ).void
+        end
+        attr_writer :memory_layer_assignments
+
+        # Count of memory layer assignments.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :memory_layer_count
+
+        sig { params(memory_layer_count: Integer).void }
+        attr_writer :memory_layer_count
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(T.nilable(Cadenya::ResourceMetadata)) }
+        attr_reader :model
+
+        sig { params(model: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :model
+
+        # Number of sub-agents assigned to this variation
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :sub_agent_count
+
+        sig { params(sub_agent_count: Integer).void }
+        attr_writer :sub_agent_count
+
+        # Number of individual tools assigned to this variation
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :tool_count
+
+        sig { params(tool_count: Integer).void }
+        attr_writer :tool_count
+
+        # Number of tool sets assigned to this variation
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :tool_set_count
+
+        sig { params(tool_set_count: Integer).void }
+        attr_writer :tool_set_count
+
+        # AgentVariationInfo provides read-only summary information about a variation
+        sig do
+          params(
+            assignments: T::Array[Cadenya::Agents::VariationAssignment::OrHash],
+            created_by: Cadenya::Profile::OrHash,
+            feedback_count: Integer,
+            memory_layer_assignments:
+              T::Array[Cadenya::Agents::VariationMemoryLayerAssignment::OrHash],
+            memory_layer_count: Integer,
+            model: Cadenya::ResourceMetadata::OrHash,
+            score: Float,
+            sub_agent_count: Integer,
+            tool_count: Integer,
+            tool_set_count: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # All tools, tool sets, and sub-agents assigned to this variation. Populated on
+          # reads so clients can render a variation's full assignment list without calling
+          # the add/remove endpoints just to enumerate.
+          assignments: nil,
+          # 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,
+          # Total number of objective feedbacks received for this variation
+          feedback_count: nil,
+          # Read-only list of memory layer assignments for this variation, returned in
+          # ascending `position` (bottom → top). Capped at 10 entries.
+          memory_layer_assignments: nil,
+          # Count of memory layer assignments.
+          memory_layer_count: nil,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          model: nil,
+          # Thompson Sampling score: posterior mean of Beta(ts_alpha, ts_beta). Range [0, 1]
+          # where 0.5 = neutral, >0.5 = positive, <0.5 = negative.
+          score: nil,
+          # Number of sub-agents assigned to this variation
+          sub_agent_count: nil,
+          # Number of individual tools assigned to this variation
+          tool_count: nil,
+          # Number of tool sets assigned to this variation
+          tool_set_count: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              assignments: T::Array[Cadenya::Agents::VariationAssignment],
+              created_by: Cadenya::Profile,
+              feedback_count: Integer,
+              memory_layer_assignments:
+                T::Array[Cadenya::Agents::VariationMemoryLayerAssignment],
+              memory_layer_count: Integer,
+              model: Cadenya::ResourceMetadata,
+              score: Float,
+              sub_agent_count: Integer,
+              tool_count: Integer,
+              tool_set_count: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/agents/agent_variation_spec.rbi

@@ -0,0 +1,197 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationSpec = Agents::AgentVariationSpec
+
+    module Agents
+      class AgentVariationSpec < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationSpec,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # CompactionConfig defines how context window compaction behaves for objectives
+        # using this variation.
+        sig do
+          returns(
+            T.nilable(Cadenya::Agents::AgentVariationSpecCompactionConfig)
+          )
+        end
+        attr_reader :compaction_config
+
+        sig do
+          params(
+            compaction_config:
+              Cadenya::Agents::AgentVariationSpecCompactionConfig::OrHash
+          ).void
+        end
+        attr_writer :compaction_config
+
+        # Execution constraints
+        sig do
+          returns(T.nilable(Cadenya::Agents::AgentVariationSpecConstraints))
+        end
+        attr_reader :constraints
+
+        sig do
+          params(
+            constraints: Cadenya::Agents::AgentVariationSpecConstraints::OrHash
+          ).void
+        end
+        attr_writer :constraints
+
+        # Human-readable description of what this variation does or when it should be used
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # Enable episodic memory for objectives using this variation. When true, the
+        # system automatically creates a document namespace for each objective using the
+        # objective's episodic_key as the external_id, allowing the agent to store and
+        # retrieve documents specific to that episode.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :enable_episodic_memory
+
+        sig { params(enable_episodic_memory: T::Boolean).void }
+        attr_writer :enable_episodic_memory
+
+        # How long episodic memories should be retained. After this duration, episodic
+        # document namespaces can be automatically cleaned up. If not set, episodic
+        # memories are retained indefinitely.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :episodic_memory_ttl
+
+        sig { params(episodic_memory_ttl: Integer).void }
+        attr_writer :episodic_memory_ttl
+
+        # ModelConfig defines the model configuration for a variation
+        sig do
+          returns(T.nilable(Cadenya::Agents::AgentVariationSpecModelConfig))
+        end
+        attr_reader :model_config
+
+        sig do
+          params(
+            model_config: Cadenya::Agents::AgentVariationSpecModelConfig::OrHash
+          ).void
+        end
+        attr_writer :model_config
+
+        # ProgressiveDiscovery is used to indicate that the agent should automatically
+        # discover tools that are not explicitly assigned to it. Max tools is the maximum
+        # number of tools that can be discovered per search. Hints are optional hints for
+        # tool search. These are used in conjunction with the context-aware tool search
+        # and can help select the best tools for the task.
+        sig do
+          returns(
+            T.nilable(Cadenya::Agents::AgentVariationSpecProgressiveDiscovery)
+          )
+        end
+        attr_reader :progressive_discovery
+
+        sig do
+          params(
+            progressive_discovery:
+              Cadenya::Agents::AgentVariationSpecProgressiveDiscovery::OrHash
+          ).void
+        end
+        attr_writer :progressive_discovery
+
+        # The system prompt for this variation
+        sig { returns(T.nilable(String)) }
+        attr_reader :prompt
+
+        sig { params(prompt: String).void }
+        attr_writer :prompt
+
+        # Weight for weighted random selection (>= 0). P(v) = v.weight / sum(all_weights).
+        # Only used when the agent's variation_selection_mode is WEIGHTED. A weight of 0
+        # means never auto-selected, but can still be chosen explicitly via variation_id
+        # on CreateObjectiveRequest.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :weight
+
+        sig { params(weight: Integer).void }
+        attr_writer :weight
+
+        # AgentVariationSpec defines the operational configuration for a variation
+        sig do
+          params(
+            compaction_config:
+              Cadenya::Agents::AgentVariationSpecCompactionConfig::OrHash,
+            constraints: Cadenya::Agents::AgentVariationSpecConstraints::OrHash,
+            description: String,
+            enable_episodic_memory: T::Boolean,
+            episodic_memory_ttl: Integer,
+            model_config:
+              Cadenya::Agents::AgentVariationSpecModelConfig::OrHash,
+            progressive_discovery:
+              Cadenya::Agents::AgentVariationSpecProgressiveDiscovery::OrHash,
+            prompt: String,
+            weight: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # CompactionConfig defines how context window compaction behaves for objectives
+          # using this variation.
+          compaction_config: nil,
+          # Execution constraints
+          constraints: nil,
+          # Human-readable description of what this variation does or when it should be used
+          description: nil,
+          # Enable episodic memory for objectives using this variation. When true, the
+          # system automatically creates a document namespace for each objective using the
+          # objective's episodic_key as the external_id, allowing the agent to store and
+          # retrieve documents specific to that episode.
+          enable_episodic_memory: nil,
+          # How long episodic memories should be retained. After this duration, episodic
+          # document namespaces can be automatically cleaned up. If not set, episodic
+          # memories are retained indefinitely.
+          episodic_memory_ttl: nil,
+          # ModelConfig defines the model configuration for a variation
+          model_config: nil,
+          # ProgressiveDiscovery is used to indicate that the agent should automatically
+          # discover tools that are not explicitly assigned to it. Max tools is the maximum
+          # number of tools that can be discovered per search. Hints are optional hints for
+          # tool search. These are used in conjunction with the context-aware tool search
+          # and can help select the best tools for the task.
+          progressive_discovery: nil,
+          # The system prompt for this variation
+          prompt: nil,
+          # Weight for weighted random selection (>= 0). P(v) = v.weight / sum(all_weights).
+          # Only used when the agent's variation_selection_mode is WEIGHTED. A weight of 0
+          # means never auto-selected, but can still be chosen explicitly via variation_id
+          # on CreateObjectiveRequest.
+          weight: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              compaction_config:
+                Cadenya::Agents::AgentVariationSpecCompactionConfig,
+              constraints: Cadenya::Agents::AgentVariationSpecConstraints,
+              description: String,
+              enable_episodic_memory: T::Boolean,
+              episodic_memory_ttl: Integer,
+              model_config: Cadenya::Agents::AgentVariationSpecModelConfig,
+              progressive_discovery:
+                Cadenya::Agents::AgentVariationSpecProgressiveDiscovery,
+              prompt: String,
+              weight: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/agents/agent_variation_spec_compaction_config.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationSpecCompactionConfig =
+      Agents::AgentVariationSpecCompactionConfig
+
+    module Agents
+      class AgentVariationSpecCompactionConfig < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationSpecCompactionConfig,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # SummarizationStrategy configures LLM-powered summarization of older conversation
+        # turns.
+        sig do
+          returns(
+            T.nilable(Cadenya::Agents::CompactionConfigSummarizationStrategy)
+          )
+        end
+        attr_reader :summarization
+
+        sig do
+          params(
+            summarization:
+              Cadenya::Agents::CompactionConfigSummarizationStrategy::OrHash
+          ).void
+        end
+        attr_writer :summarization
+
+        # ToolResultClearingStrategy configures clearing of older tool result content.
+        sig do
+          returns(
+            T.nilable(
+              Cadenya::Agents::CompactionConfigToolResultClearingStrategy
+            )
+          )
+        end
+        attr_reader :tool_result_clearing
+
+        sig do
+          params(
+            tool_result_clearing:
+              Cadenya::Agents::CompactionConfigToolResultClearingStrategy::OrHash
+          ).void
+        end
+        attr_writer :tool_result_clearing
+
+        # Trigger threshold as a percentage of the model's context window (0.0 to 1.0).
+        # When input tokens reach this percentage of the model's limit, compaction
+        # triggers. Default: 0.75 (75%)
+        sig { returns(T.nilable(Float)) }
+        attr_reader :trigger_threshold
+
+        sig { params(trigger_threshold: Float).void }
+        attr_writer :trigger_threshold
+
+        # CompactionConfig defines how context window compaction behaves for objectives
+        # using this variation.
+        sig do
+          params(
+            summarization:
+              Cadenya::Agents::CompactionConfigSummarizationStrategy::OrHash,
+            tool_result_clearing:
+              Cadenya::Agents::CompactionConfigToolResultClearingStrategy::OrHash,
+            trigger_threshold: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # SummarizationStrategy configures LLM-powered summarization of older conversation
+          # turns.
+          summarization: nil,
+          # ToolResultClearingStrategy configures clearing of older tool result content.
+          tool_result_clearing: nil,
+          # Trigger threshold as a percentage of the model's context window (0.0 to 1.0).
+          # When input tokens reach this percentage of the model's limit, compaction
+          # triggers. Default: 0.75 (75%)
+          trigger_threshold: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              summarization:
+                Cadenya::Agents::CompactionConfigSummarizationStrategy,
+              tool_result_clearing:
+                Cadenya::Agents::CompactionConfigToolResultClearingStrategy,
+              trigger_threshold: Float
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/agents/agent_variation_spec_constraints.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationSpecConstraints = Agents::AgentVariationSpecConstraints
+
+    module Agents
+      class AgentVariationSpecConstraints < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationSpecConstraints,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # The maximum number of sub-objectives that can be created. 0 means no limit.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_sub_objectives
+
+        sig { params(max_sub_objectives: Integer).void }
+        attr_writer :max_sub_objectives
+
+        # The maximum number of tool calls that can be made. 0 means no limit.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_tool_calls
+
+        sig { params(max_tool_calls: Integer).void }
+        attr_writer :max_tool_calls
+
+        sig do
+          params(max_sub_objectives: Integer, max_tool_calls: Integer).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The maximum number of sub-objectives that can be created. 0 means no limit.
+          max_sub_objectives: nil,
+          # The maximum number of tool calls that can be made. 0 means no limit.
+          max_tool_calls: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { max_sub_objectives: Integer, max_tool_calls: Integer }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/agents/agent_variation_spec_model_config.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationSpecModelConfig = Agents::AgentVariationSpecModelConfig
+
+    module Agents
+      class AgentVariationSpecModelConfig < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationSpecModelConfig,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # The model identifier in family/model format (e.g., "claude/opus-4.6",
+        # "claude/sonnet-4.5")
+        sig { returns(T.nilable(String)) }
+        attr_reader :model_id
+
+        sig { params(model_id: String).void }
+        attr_writer :model_id
+
+        # Sampling temperature for model inference (0.0 to 1.0) Lower values produce more
+        # deterministic outputs, higher values increase randomness
+        sig { returns(T.nilable(Float)) }
+        attr_reader :temperature
+
+        sig { params(temperature: Float).void }
+        attr_writer :temperature
+
+        # ModelConfig defines the model configuration for a variation
+        sig do
+          params(model_id: String, temperature: Float).returns(T.attached_class)
+        end
+        def self.new(
+          # The model identifier in family/model format (e.g., "claude/opus-4.6",
+          # "claude/sonnet-4.5")
+          model_id: nil,
+          # Sampling temperature for model inference (0.0 to 1.0) Lower values produce more
+          # deterministic outputs, higher values increase randomness
+          temperature: nil
+        )
+        end
+
+        sig { override.returns({ model_id: String, temperature: Float }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/agents/agent_variation_spec_progressive_discovery.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    AgentVariationSpecProgressiveDiscovery =
+      Agents::AgentVariationSpecProgressiveDiscovery
+
+    module Agents
+      class AgentVariationSpecProgressiveDiscovery < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Agents::AgentVariationSpecProgressiveDiscovery,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :hints
+
+        sig { params(hints: T::Array[String]).void }
+        attr_writer :hints
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_tools
+
+        sig { params(max_tools: Integer).void }
+        attr_writer :max_tools
+
+        # Rerank Threshold is an optional value that instructs whether or not to run a
+        # search result through a embedding/reranker process which can improve performance
+        # and reduce context bloat when tools reach the configured threshold. If a tool
+        # match must exceed 0.8, for example, the tool very closely match the query the
+        # tool search performed.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :rerank_threshold
+
+        sig { params(rerank_threshold: Float).void }
+        attr_writer :rerank_threshold
+
+        # ProgressiveDiscovery is used to indicate that the agent should automatically
+        # discover tools that are not explicitly assigned to it. Max tools is the maximum
+        # number of tools that can be discovered per search. Hints are optional hints for
+        # tool search. These are used in conjunction with the context-aware tool search
+        # and can help select the best tools for the task.
+        sig do
+          params(
+            hints: T::Array[String],
+            max_tools: Integer,
+            rerank_threshold: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          hints: nil,
+          max_tools: nil,
+          # Rerank Threshold is an optional value that instructs whether or not to run a
+          # search result through a embedding/reranker process which can improve performance
+          # and reduce context bloat when tools reach the configured threshold. If a tool
+          # match must exceed 0.8, for example, the tool very closely match the query the
+          # tool search performed.
+          rerank_threshold: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              hints: T::Array[String],
+              max_tools: Integer,
+              rerank_threshold: Float
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end