cadenya 0.4.0 → 0.6.0

data/rbi/cadenya/models/ai_provider_key_spec.rbi

@@ -16,41 +16,83 @@ module Cadenya
       sig { params(api_key: String).void }
       attr_writer :api_key
 
-      # The AI provider this key authenticates against. Currently "openrouter".
-      sig { returns(T.nilable(String)) }
-      attr_reader :provider
+      # OpenRouterConfig holds OpenRouter-specific settings. Empty for now; it exists as
+      # the oneof seam so provider-specific options (region, base URL, etc.) can be
+      # added later without restructuring the spec.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :openrouter
 
-      sig { params(provider: String).void }
-      attr_writer :provider
+      sig { params(openrouter: T.anything).void }
+      attr_writer :openrouter
 
-      # The provider region. "us" or "eu". Defaults to "us".
-      sig { returns(T.nilable(String)) }
-      attr_reader :region
+      # The AI provider this key authenticates against.
+      sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Provider::OrSymbol)) }
+      attr_reader :provider
 
-      sig { params(region: String).void }
-      attr_writer :region
+      sig do
+        params(provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol).void
+      end
+      attr_writer :provider
 
       sig do
-        params(api_key: String, provider: String, region: String).returns(
-          T.attached_class
-        )
+        params(
+          api_key: String,
+          openrouter: T.anything,
+          provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol
+        ).returns(T.attached_class)
       end
       def self.new(
         # The provider credential. Accepted on create/update; never populated in responses
         # (the server returns an empty value to avoid leaking it).
         api_key: nil,
-        # The AI provider this key authenticates against. Currently "openrouter".
-        provider: nil,
-        # The provider region. "us" or "eu". Defaults to "us".
-        region: nil
+        # OpenRouterConfig holds OpenRouter-specific settings. Empty for now; it exists as
+        # the oneof seam so provider-specific options (region, base URL, etc.) can be
+        # added later without restructuring the spec.
+        openrouter: nil,
+        # The AI provider this key authenticates against.
+        provider: nil
       )
       end
 
       sig do
-        override.returns({ api_key: String, provider: String, region: String })
+        override.returns(
+          {
+            api_key: String,
+            openrouter: T.anything,
+            provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol
+          }
+        )
       end
       def to_hash
       end
+
+      # The AI provider this key authenticates against.
+      module Provider
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::AIProviderKeySpec::Provider) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AI_PROVIDER_UNSPECIFIED =
+          T.let(
+            :AI_PROVIDER_UNSPECIFIED,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
+        AI_PROVIDER_OPENROUTER =
+          T.let(
+            :AI_PROVIDER_OPENROUTER,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::AIProviderKeySpec::Provider::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/model.rbi

@@ -20,27 +20,139 @@ module Cadenya
       sig { params(spec: Cadenya::ModelSpec::OrHash).void }
       attr_writer :spec
 
+      # ModelInfo carries server-derived, read-only details about a model.
+      sig { returns(T.nilable(Cadenya::Model::Info)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::Model::Info::OrHash).void }
+      attr_writer :info
+
       sig do
         params(
           metadata: Cadenya::ResourceMetadata::OrHash,
-          spec: Cadenya::ModelSpec::OrHash
+          spec: Cadenya::ModelSpec::OrHash,
+          info: Cadenya::Model::Info::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
         # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
         metadata:,
         # Model specification
-        spec:
+        spec:,
+        # ModelInfo carries server-derived, read-only details about a model.
+        info: nil
       )
       end
 
       sig do
         override.returns(
-          { metadata: Cadenya::ResourceMetadata, spec: Cadenya::ModelSpec }
+          {
+            metadata: Cadenya::ResourceMetadata,
+            spec: Cadenya::ModelSpec,
+            info: Cadenya::Model::Info
+          }
         )
       end
       def to_hash
       end
+
+      class Info < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::Model::Info, Cadenya::Internal::AnyHash)
+          end
+
+        # Number of agent variations currently provisioned on this model. Useful for
+        # previewing how many variations a swap would affect.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :agent_variation_count
+
+        sig { params(agent_variation_count: Integer).void }
+        attr_writer :agent_variation_count
+
+        # BareMetadata contains the minimal metadata for a resource: the ID and an
+        # optional human-readable name. These are used for reference fields where the full
+        # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+        # e.g., the tool references inside an agent variation spec or the tools assigned
+        # to an objective. Both fields are server-populated; clients provide IDs through
+        # sibling fields rather than by constructing a BareMetadata themselves.
+        sig { returns(T.nilable(Cadenya::BareMetadata)) }
+        attr_reader :ai_provider_key
+
+        sig { params(ai_provider_key: Cadenya::BareMetadata::OrHash).void }
+        attr_writer :ai_provider_key
+
+        # The AI provider this model routes through (via its provider key).
+        sig { returns(T.nilable(Cadenya::Model::Info::Provider::TaggedSymbol)) }
+        attr_reader :provider
+
+        sig { params(provider: Cadenya::Model::Info::Provider::OrSymbol).void }
+        attr_writer :provider
+
+        # ModelInfo carries server-derived, read-only details about a model.
+        sig do
+          params(
+            agent_variation_count: Integer,
+            ai_provider_key: Cadenya::BareMetadata::OrHash,
+            provider: Cadenya::Model::Info::Provider::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Number of agent variations currently provisioned on this model. Useful for
+          # previewing how many variations a swap would affect.
+          agent_variation_count: nil,
+          # BareMetadata contains the minimal metadata for a resource: the ID and an
+          # optional human-readable name. These are used for reference fields where the full
+          # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+          # e.g., the tool references inside an agent variation spec or the tools assigned
+          # to an objective. Both fields are server-populated; clients provide IDs through
+          # sibling fields rather than by constructing a BareMetadata themselves.
+          ai_provider_key: nil,
+          # The AI provider this model routes through (via its provider key).
+          provider: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              agent_variation_count: Integer,
+              ai_provider_key: Cadenya::BareMetadata,
+              provider: Cadenya::Model::Info::Provider::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The AI provider this model routes through (via its provider key).
+        module Provider
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Cadenya::Model::Info::Provider) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          AI_PROVIDER_UNSPECIFIED =
+            T.let(
+              :AI_PROVIDER_UNSPECIFIED,
+              Cadenya::Model::Info::Provider::TaggedSymbol
+            )
+          AI_PROVIDER_OPENROUTER =
+            T.let(
+              :AI_PROVIDER_OPENROUTER,
+              Cadenya::Model::Info::Provider::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Cadenya::Model::Info::Provider::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/model_list_params.rbi

@@ -14,6 +14,14 @@ module Cadenya
       sig { returns(String) }
       attr_accessor :workspace_id
 
+      # Filter to models provisioned on a specific AI provider key. Accepts the key's id
+      # or an "external_id:"-prefixed slug.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ai_provider_key_id
+
+      sig { params(ai_provider_key_id: String).void }
+      attr_writer :ai_provider_key_id
+
       # Filter by bundle_key — return only resources owned by this bundle.
       sig { returns(T.nilable(String)) }
       attr_reader :bundle_key
@@ -28,6 +36,14 @@ module Cadenya
       sig { params(cursor: String).void }
       attr_writer :cursor
 
+      # When true, populate each item's info (e.g. the AI provider), at the cost of
+      # extra lookups.
+      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
@@ -66,8 +82,10 @@ module Cadenya
       sig do
         params(
           workspace_id: String,
+          ai_provider_key_id: String,
           bundle_key: String,
           cursor: String,
+          include_info: T::Boolean,
           limit: Integer,
           prefix: String,
           query: String,
@@ -78,10 +96,16 @@ module Cadenya
       end
       def self.new(
         workspace_id:,
+        # Filter to models provisioned on a specific AI provider key. Accepts the key's id
+        # or an "external_id:"-prefixed slug.
+        ai_provider_key_id: nil,
         # Filter by bundle_key — return only resources owned by this bundle.
         bundle_key: nil,
         # Pagination cursor from previous response
         cursor: nil,
+        # When true, populate each item's info (e.g. the AI provider), at the cost of
+        # extra lookups.
+        include_info: nil,
         # Maximum number of results to return
         limit: nil,
         # Filter by name prefix
@@ -100,8 +124,10 @@ module Cadenya
         override.returns(
           {
             workspace_id: String,
+            ai_provider_key_id: String,
             bundle_key: String,
             cursor: String,
+            include_info: T::Boolean,
             limit: Integer,
             prefix: String,
             query: String,

data/rbi/cadenya/models/model_swap_params.rbi

@@ -0,0 +1,99 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ModelSwapParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ModelSwapParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # The swaps to perform.
+      sig { returns(T.nilable(T::Array[Cadenya::ModelSwapParams::ModelSwap])) }
+      attr_reader :model_swaps
+
+      sig do
+        params(
+          model_swaps: T::Array[Cadenya::ModelSwapParams::ModelSwap::OrHash]
+        ).void
+      end
+      attr_writer :model_swaps
+
+      sig do
+        params(
+          workspace_id: String,
+          model_swaps: T::Array[Cadenya::ModelSwapParams::ModelSwap::OrHash],
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # The swaps to perform.
+        model_swaps: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            model_swaps: T::Array[Cadenya::ModelSwapParams::ModelSwap],
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ModelSwap < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::ModelSwapParams::ModelSwap,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # The model variations are currently on. Accepts an id or "external_id:" slug.
+        sig { returns(T.nilable(String)) }
+        attr_reader :current_model_id
+
+        sig { params(current_model_id: String).void }
+        attr_writer :current_model_id
+
+        # The model to move variations to. Accepts an id or "external_id:" slug.
+        sig { returns(T.nilable(String)) }
+        attr_reader :next_model_id
+
+        sig { params(next_model_id: String).void }
+        attr_writer :next_model_id
+
+        sig do
+          params(current_model_id: String, next_model_id: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The model variations are currently on. Accepts an id or "external_id:" slug.
+          current_model_id: nil,
+          # The model to move variations to. Accepts an id or "external_id:" slug.
+          next_model_id: nil
+        )
+        end
+
+        sig do
+          override.returns({ current_model_id: String, next_model_id: String })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/model_swap_response.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ModelSwapResponse = T.let(T.anything, Cadenya::Internal::Type::Converter)
+  end
+end

data/rbi/cadenya/models.rbi

@@ -145,6 +145,8 @@ module Cadenya
 
   ModelSpec = Cadenya::Models::ModelSpec
 
+  ModelSwapParams = Cadenya::Models::ModelSwapParams
+
   Objective = Cadenya::Models::Objective
 
   ObjectiveCancelParams = Cadenya::Models::ObjectiveCancelParams

data/rbi/cadenya/resources/ai_provider_keys.rbi

@@ -75,6 +75,7 @@ module Cadenya
         params(
           workspace_id: String,
           cursor: String,
+          include_info: T::Boolean,
           limit: Integer,
           prefix: String,
           query: String,
@@ -87,6 +88,9 @@ module Cadenya
         workspace_id,
         # Pagination cursor from previous response
         cursor: nil,
+        # When true, populate each item's info (model counts), at the cost of extra
+        # lookups.
+        include_info: nil,
         # Maximum number of results to return
         limit: nil,
         # Filter expression (query param: prefix)

data/rbi/cadenya/resources/models.rbi

@@ -27,8 +27,10 @@ module Cadenya
       sig do
         params(
           workspace_id: String,
+          ai_provider_key_id: String,
           bundle_key: String,
           cursor: String,
+          include_info: T::Boolean,
           limit: Integer,
           prefix: String,
           query: String,
@@ -40,10 +42,16 @@ module Cadenya
       def list(
         # Workspace ID.
         workspace_id,
+        # Filter to models provisioned on a specific AI provider key. Accepts the key's id
+        # or an "external_id:"-prefixed slug.
+        ai_provider_key_id: nil,
         # Filter by bundle_key — return only resources owned by this bundle.
         bundle_key: nil,
         # Pagination cursor from previous response
         cursor: nil,
+        # When true, populate each item's info (e.g. the AI provider), at the cost of
+        # extra lookups.
+        include_info: nil,
         # Maximum number of results to return
         limit: nil,
         # Filter by name prefix
@@ -78,6 +86,24 @@ module Cadenya
       )
       end
 
+      # Reassigns agent variations from one model to another in bulk. Runs
+      # asynchronously and returns immediately.
+      sig do
+        params(
+          workspace_id: String,
+          model_swaps: T::Array[Cadenya::ModelSwapParams::ModelSwap::OrHash],
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.anything)
+      end
+      def swap(
+        # Workspace ID.
+        workspace_id,
+        # The swaps to perform.
+        model_swaps: nil,
+        request_options: {}
+      )
+      end
+
       # @api private
       sig { params(client: Cadenya::Client).returns(T.attached_class) }
       def self.new(client:)

data/sig/cadenya/models/ai_provider_key.rbs

@@ -1,22 +1,55 @@
 module Cadenya
   module Models
     type ai_provider_key =
-      { metadata: Cadenya::ResourceMetadata, spec: Cadenya::AIProviderKeySpec }
+      {
+        metadata: Cadenya::ResourceMetadata,
+        spec: Cadenya::AIProviderKeySpec,
+        info: Cadenya::AIProviderKey::Info
+      }
 
     class AIProviderKey < Cadenya::Internal::Type::BaseModel
       attr_accessor metadata: Cadenya::ResourceMetadata
 
       attr_accessor spec: Cadenya::AIProviderKeySpec
 
+      attr_reader info: Cadenya::AIProviderKey::Info?
+
+      def info=: (Cadenya::AIProviderKey::Info) -> Cadenya::AIProviderKey::Info
+
       def initialize: (
         metadata: Cadenya::ResourceMetadata,
-        spec: Cadenya::AIProviderKeySpec
+        spec: Cadenya::AIProviderKeySpec,
+        ?info: Cadenya::AIProviderKey::Info
       ) -> void
 
       def to_hash: -> {
         metadata: Cadenya::ResourceMetadata,
-        spec: Cadenya::AIProviderKeySpec
+        spec: Cadenya::AIProviderKeySpec,
+        info: Cadenya::AIProviderKey::Info
       }
+
+      type info =
+        { disabled_model_count: Integer, enabled_model_count: Integer }
+
+      class Info < Cadenya::Internal::Type::BaseModel
+        attr_reader disabled_model_count: Integer?
+
+        def disabled_model_count=: (Integer) -> Integer
+
+        attr_reader enabled_model_count: Integer?
+
+        def enabled_model_count=: (Integer) -> Integer
+
+        def initialize: (
+          ?disabled_model_count: Integer,
+          ?enabled_model_count: Integer
+        ) -> void
+
+        def to_hash: -> {
+          disabled_model_count: Integer,
+          enabled_model_count: Integer
+        }
+      end
     end
   end
 end

data/sig/cadenya/models/ai_provider_key_list_params.rbs

@@ -4,6 +4,7 @@ module Cadenya
       {
         workspace_id: String,
         cursor: String,
+        include_info: bool,
         limit: Integer,
         prefix: String,
         query: String,
@@ -21,6 +22,10 @@ module Cadenya
 
       def cursor=: (String) -> String
 
+      attr_reader include_info: bool?
+
+      def include_info=: (bool) -> bool
+
       attr_reader limit: Integer?
 
       def limit=: (Integer) -> Integer
@@ -40,6 +45,7 @@ module Cadenya
       def initialize: (
         workspace_id: String,
         ?cursor: String,
+        ?include_info: bool,
         ?limit: Integer,
         ?prefix: String,
         ?query: String,
@@ -50,6 +56,7 @@ module Cadenya
       def to_hash: -> {
         workspace_id: String,
         cursor: String,
+        include_info: bool,
         limit: Integer,
         prefix: String,
         query: String,

data/sig/cadenya/models/ai_provider_key_spec.rbs

@@ -1,28 +1,49 @@
 module Cadenya
   module Models
     type ai_provider_key_spec =
-      { api_key: String, provider: String, region: String }
+      {
+        api_key: String,
+        openrouter: top,
+        provider: Cadenya::Models::AIProviderKeySpec::provider
+      }
 
     class AIProviderKeySpec < Cadenya::Internal::Type::BaseModel
       attr_reader api_key: String?
 
       def api_key=: (String) -> String
 
-      attr_reader provider: String?
+      attr_reader openrouter: top?
 
-      def provider=: (String) -> String
+      def openrouter=: (top) -> top
 
-      attr_reader region: String?
+      attr_reader provider: Cadenya::Models::AIProviderKeySpec::provider?
 
-      def region=: (String) -> String
+      def provider=: (
+        Cadenya::Models::AIProviderKeySpec::provider
+      ) -> Cadenya::Models::AIProviderKeySpec::provider
 
       def initialize: (
         ?api_key: String,
-        ?provider: String,
-        ?region: String
+        ?openrouter: top,
+        ?provider: Cadenya::Models::AIProviderKeySpec::provider
       ) -> void
 
-      def to_hash: -> { api_key: String, provider: String, region: String }
+      def to_hash: -> {
+        api_key: String,
+        openrouter: top,
+        provider: Cadenya::Models::AIProviderKeySpec::provider
+      }
+
+      type provider = :AI_PROVIDER_UNSPECIFIED | :AI_PROVIDER_OPENROUTER
+
+      module Provider
+        extend Cadenya::Internal::Type::Enum
+
+        AI_PROVIDER_UNSPECIFIED: :AI_PROVIDER_UNSPECIFIED
+        AI_PROVIDER_OPENROUTER: :AI_PROVIDER_OPENROUTER
+
+        def self?.values: -> ::Array[Cadenya::Models::AIProviderKeySpec::provider]
+      end
     end
   end
 end