cadenya 0.1.0

data/rbi/cadenya/models/model_set_status_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ModelSetStatusParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ModelSetStatusParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The new status for the model
+      sig do
+        returns(T.nilable(Cadenya::ModelSetStatusParams::Status::OrSymbol))
+      end
+      attr_reader :status
+
+      sig do
+        params(status: Cadenya::ModelSetStatusParams::Status::OrSymbol).void
+      end
+      attr_writer :status
+
+      sig do
+        params(
+          workspace_id: String,
+          id: String,
+          status: Cadenya::ModelSetStatusParams::Status::OrSymbol,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        id:,
+        # The new status for the model
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            status: Cadenya::ModelSetStatusParams::Status::OrSymbol,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The new status for the model
+      module Status
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::ModelSetStatusParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MODEL_STATUS_UNSPECIFIED =
+          T.let(
+            :MODEL_STATUS_UNSPECIFIED,
+            Cadenya::ModelSetStatusParams::Status::TaggedSymbol
+          )
+        MODEL_STATUS_ENABLED =
+          T.let(
+            :MODEL_STATUS_ENABLED,
+            Cadenya::ModelSetStatusParams::Status::TaggedSymbol
+          )
+        MODEL_STATUS_DISABLED =
+          T.let(
+            :MODEL_STATUS_DISABLED,
+            Cadenya::ModelSetStatusParams::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ModelSetStatusParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/model_spec.rbi

@@ -0,0 +1,132 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ModelSpec < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ModelSpec, Cadenya::Internal::AnyHash) }
+
+      # The model family (e.g., "claude-sonnet-4.6", "gpt-5.4", "gemini-2.5-flash")
+      sig { returns(T.nilable(String)) }
+      attr_reader :family
+
+      sig { params(family: String).void }
+      attr_writer :family
+
+      # Cost per million input tokens in cents (e.g., 300 = $3.00)
+      sig { returns(T.nilable(String)) }
+      attr_reader :input_price_per_million_tokens
+
+      sig { params(input_price_per_million_tokens: String).void }
+      attr_writer :input_price_per_million_tokens
+
+      # Maximum number of input tokens the model supports
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_input_tokens
+
+      sig { params(max_input_tokens: Integer).void }
+      attr_writer :max_input_tokens
+
+      # Maximum number of output tokens the model can generate
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_output_tokens
+
+      sig { params(max_output_tokens: Integer).void }
+      attr_writer :max_output_tokens
+
+      # Cost per million output tokens in cents (e.g., 1500 = $15.00)
+      sig { returns(T.nilable(String)) }
+      attr_reader :output_price_per_million_tokens
+
+      sig { params(output_price_per_million_tokens: String).void }
+      attr_writer :output_price_per_million_tokens
+
+      # The model provider (e.g., "anthropic", "openai", "google")
+      sig { returns(T.nilable(String)) }
+      attr_reader :provider
+
+      sig { params(provider: String).void }
+      attr_writer :provider
+
+      # The status of the model in the workspace
+      sig { returns(T.nilable(Cadenya::ModelSpec::Status::TaggedSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Cadenya::ModelSpec::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          family: String,
+          input_price_per_million_tokens: String,
+          max_input_tokens: Integer,
+          max_output_tokens: Integer,
+          output_price_per_million_tokens: String,
+          provider: String,
+          status: Cadenya::ModelSpec::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The model family (e.g., "claude-sonnet-4.6", "gpt-5.4", "gemini-2.5-flash")
+        family: nil,
+        # Cost per million input tokens in cents (e.g., 300 = $3.00)
+        input_price_per_million_tokens: nil,
+        # Maximum number of input tokens the model supports
+        max_input_tokens: nil,
+        # Maximum number of output tokens the model can generate
+        max_output_tokens: nil,
+        # Cost per million output tokens in cents (e.g., 1500 = $15.00)
+        output_price_per_million_tokens: nil,
+        # The model provider (e.g., "anthropic", "openai", "google")
+        provider: nil,
+        # The status of the model in the workspace
+        status: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            family: String,
+            input_price_per_million_tokens: String,
+            max_input_tokens: Integer,
+            max_output_tokens: Integer,
+            output_price_per_million_tokens: String,
+            provider: String,
+            status: Cadenya::ModelSpec::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The status of the model in the workspace
+      module Status
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::ModelSpec::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MODEL_STATUS_UNSPECIFIED =
+          T.let(
+            :MODEL_STATUS_UNSPECIFIED,
+            Cadenya::ModelSpec::Status::TaggedSymbol
+          )
+        MODEL_STATUS_ENABLED =
+          T.let(:MODEL_STATUS_ENABLED, Cadenya::ModelSpec::Status::TaggedSymbol)
+        MODEL_STATUS_DISABLED =
+          T.let(
+            :MODEL_STATUS_DISABLED,
+            Cadenya::ModelSpec::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(T::Array[Cadenya::ModelSpec::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class Objective < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::Objective, Cadenya::Internal::AnyHash) }
+
+      sig { returns(Cadenya::ObjectiveData) }
+      attr_reader :data
+
+      sig { params(data: Cadenya::ObjectiveData::OrHash).void }
+      attr_writer :data
+
+      # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+      # runs)
+      sig { returns(Cadenya::OperationMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::OperationMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::ObjectiveStatus) }
+      attr_reader :status
+
+      sig { params(status: Cadenya::ObjectiveStatus::OrHash).void }
+      attr_writer :status
+
+      # ObjectiveInfo provides read-only aggregated statistics about an objective's
+      # execution
+      sig { returns(T.nilable(Cadenya::ObjectiveInfo)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::ObjectiveInfo::OrHash).void }
+      attr_writer :info
+
+      # Read-only list of the last five windows of execution for this objective, ordered
+      # by most recent first. Is only included in singular RPC calls (GetObjective, for
+      # example).
+      sig { returns(T.nilable(T::Array[Cadenya::ObjectiveContextWindow])) }
+      attr_reader :last_five_windows
+
+      sig do
+        params(
+          last_five_windows: T::Array[Cadenya::ObjectiveContextWindow::OrHash]
+        ).void
+      end
+      attr_writer :last_five_windows
+
+      sig do
+        params(
+          data: Cadenya::ObjectiveData::OrHash,
+          metadata: Cadenya::OperationMetadata::OrHash,
+          status: Cadenya::ObjectiveStatus::OrHash,
+          info: Cadenya::ObjectiveInfo::OrHash,
+          last_five_windows: T::Array[Cadenya::ObjectiveContextWindow::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        metadata:,
+        status:,
+        # ObjectiveInfo provides read-only aggregated statistics about an objective's
+        # execution
+        info: nil,
+        # Read-only list of the last five windows of execution for this objective, ordered
+        # by most recent first. Is only included in singular RPC calls (GetObjective, for
+        # example).
+        last_five_windows: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Cadenya::ObjectiveData,
+            metadata: Cadenya::OperationMetadata,
+            status: Cadenya::ObjectiveStatus,
+            info: Cadenya::ObjectiveInfo,
+            last_five_windows: T::Array[Cadenya::ObjectiveContextWindow]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_cancel_params.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ObjectiveCancelParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ObjectiveCancelParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :objective_id
+
+      # Optional reason for cancellation
+      sig { returns(T.nilable(String)) }
+      attr_reader :reason
+
+      sig { params(reason: String).void }
+      attr_writer :reason
+
+      sig do
+        params(
+          workspace_id: String,
+          objective_id: String,
+          reason: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        objective_id:,
+        # Optional reason for cancellation
+        reason: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            objective_id: String,
+            reason: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_compact_params.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ObjectiveCompactParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ObjectiveCompactParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :objective_id
+
+      # 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
+
+      sig do
+        params(
+          workspace_id: String,
+          objective_id: String,
+          compaction_config:
+            Cadenya::Agents::AgentVariationSpecCompactionConfig::OrHash,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        objective_id:,
+        # CompactionConfig defines how context window compaction behaves for objectives
+        # using this variation.
+        compaction_config: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            objective_id: String,
+            compaction_config:
+              Cadenya::Agents::AgentVariationSpecCompactionConfig,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_compact_response.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ObjectiveCompactResponse < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::Models::ObjectiveCompactResponse,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      # The new context window created by the compaction
+      sig { returns(T.nilable(Cadenya::ObjectiveContextWindowData)) }
+      attr_reader :context_window
+
+      sig do
+        params(context_window: Cadenya::ObjectiveContextWindowData::OrHash).void
+      end
+      attr_writer :context_window
+
+      # Compact objective response
+      sig do
+        params(
+          context_window: Cadenya::ObjectiveContextWindowData::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The new context window created by the compaction
+        context_window: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { context_window: Cadenya::ObjectiveContextWindowData }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_context_window.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ObjectiveContextWindow < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ObjectiveContextWindow, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::ObjectiveContextWindowData) }
+      attr_reader :data
+
+      sig { params(data: Cadenya::ObjectiveContextWindowData::OrHash).void }
+      attr_writer :data
+
+      # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+      # runs)
+      sig { returns(Cadenya::OperationMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::OperationMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(T.nilable(Cadenya::ObjectiveContextWindow::Info)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::ObjectiveContextWindow::Info::OrHash).void }
+      attr_writer :info
+
+      # ObjectiveContextWindow is a window of chat completions that is grouped together
+      # to prevent context-window overflows. Context windows also allow agents to
+      # compact their windows and carry on into a new one.
+      sig do
+        params(
+          data: Cadenya::ObjectiveContextWindowData::OrHash,
+          metadata: Cadenya::OperationMetadata::OrHash,
+          info: Cadenya::ObjectiveContextWindow::Info::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        metadata:,
+        info: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Cadenya::ObjectiveContextWindowData,
+            metadata: Cadenya::OperationMetadata,
+            info: Cadenya::ObjectiveContextWindow::Info
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Info < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::ObjectiveContextWindow::Info,
+              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
+
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        sig { returns(T.nilable(Cadenya::OperationMetadata)) }
+        attr_reader :objective
+
+        sig { params(objective: Cadenya::OperationMetadata::OrHash).void }
+        attr_writer :objective
+
+        sig do
+          params(
+            created_by: Cadenya::Profile::OrHash,
+            objective: Cadenya::OperationMetadata::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,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          objective: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              created_by: Cadenya::Profile,
+              objective: Cadenya::OperationMetadata
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_context_window_data.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ObjectiveContextWindowData < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ObjectiveContextWindowData, Cadenya::Internal::AnyHash)
+        end
+
+      # The instructions for this window to continue from a previous window's chat
+      # history.
+      sig { returns(T.nilable(String)) }
+      attr_reader :previous_window_continue_instructions
+
+      sig { params(previous_window_continue_instructions: String).void }
+      attr_writer :previous_window_continue_instructions
+
+      # A calculated value for how many completion tokens (output tokens) have been used
+      # in this context window
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :completion_tokens
+
+      sig { params(completion_tokens: Integer).void }
+      attr_writer :completion_tokens
+
+      # The objective's ID that this window belongs to
+      sig { returns(T.nilable(String)) }
+      attr_reader :objective_id
+
+      sig { params(objective_id: String).void }
+      attr_writer :objective_id
+
+      # A calculated value for how many prompt tokens (input tokens) have been used in
+      # this context window
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :prompt_tokens
+
+      sig { params(prompt_tokens: Integer).void }
+      attr_writer :prompt_tokens
+
+      # sequence is a numeric representation of which context window this is. Sequences
+      # are useful to perform a max(sequence) on in order to calculate how many context
+      # windows an objective has.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :sequence
+
+      sig { params(sequence: Integer).void }
+      attr_writer :sequence
+
+      sig do
+        params(
+          completion_tokens: Integer,
+          objective_id: String,
+          previous_window_continue_instructions: String,
+          prompt_tokens: Integer,
+          sequence: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A calculated value for how many completion tokens (output tokens) have been used
+        # in this context window
+        completion_tokens: nil,
+        # The objective's ID that this window belongs to
+        objective_id: nil,
+        # The instructions for this window to continue from a previous window's chat
+        # history.
+        previous_window_continue_instructions: nil,
+        # A calculated value for how many prompt tokens (input tokens) have been used in
+        # this context window
+        prompt_tokens: nil,
+        # sequence is a numeric representation of which context window this is. Sequences
+        # are useful to perform a max(sequence) on in order to calculate how many context
+        # windows an objective has.
+        sequence: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            completion_tokens: Integer,
+            objective_id: String,
+            previous_window_continue_instructions: String,
+            prompt_tokens: Integer,
+            sequence: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end