cadenya 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88a495d13fa3197bd62108f4a356f43b3dc8d8b280f6a11584afd3484fbb0135
-  data.tar.gz: 7cd25a4bbea3d69c830e18e2f61db051165da239d5d41d0c9547b426ea166aa9
+  metadata.gz: 56345beed04805e02e3d9160438370098e235277a458b4d99964df96d689d1fa
+  data.tar.gz: 48e4a95347381ea29f7f4523d1098af4aab96e1a9a43e5187a6c115120848087
 SHA512:
-  metadata.gz: b2f73a4957a9e5f1adcf9b8f51b9a39223a4cf1bc9e8c721c4c4d7ace807ce1eb73acc57cba38847967b99211b87726f1ca625b0ddfeeb140a3526851bfbb7da
-  data.tar.gz: 8974859e7ae5d2035635ea7f0ea5a3c843cafd2f71b0efae359af83572b73402a81b4d683b306db724fc3b65beecd44eb1b50705f57bef1116f54ff63515ce82
+  metadata.gz: 9e343691120327cdd8c6c1d14df4f15d77344f9a625ec59fff2d743999330aacecb0fad0fe0290ebd8bd2094bce006b60e95e225ef4c1f403700542bfe03feff
+  data.tar.gz: 218de860735ffcfcc65da64a9ca06675bfee2a54f45c5588ec400e5d330d9cedd7e9730a3078592ad4924d4698a291c2a26fe0baf79f181bbdc527c6b58d540b

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.24.0 (2026-07-01)
+
+Full Changelog: [v0.23.0...v0.24.0](https://github.com/cadenya/cadenya-ruby/compare/v0.23.0...v0.24.0)
+
+### Features
+
+* **api:** api update ([2dc6e63](https://github.com/cadenya/cadenya-ruby/commit/2dc6e631c0c63392b148ea3458ce560593bcf27a))
+
 ## 0.23.0 (2026-07-01)
 
 Full Changelog: [v0.22.0...v0.23.0](https://github.com/cadenya/cadenya-ruby/compare/v0.22.0...v0.23.0)

data/README.md

@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "cadenya", "~> 0.23.0"
+gem "cadenya", "~> 0.24.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/cadenya/models/ai_provider_key_spec.rb

@@ -3,20 +3,23 @@
 module Cadenya
   module Models
     class AIProviderKeySpec < Cadenya::Internal::Type::BaseModel
-      # @!attribute api_key
-      #   The provider credential. Accepted on create/update; never populated in responses
-      #   (the server returns an empty value to avoid leaking it).
+      # @!attribute config
+      #   AIProviderConfig holds non-secret, provider-specific settings. The set case must
+      #   correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
+      #   Gemini) simply leave this unset. The endpoint of a named provider is fixed and
+      #   intentionally not overridable here; use the OpenAI-compatible provider to target
+      #   a custom endpoint.
       #
-      #   @return [String, nil]
-      optional :api_key, String, api_name: :apiKey
+      #   @return [Cadenya::Models::AIProviderKeySpec::Config, nil]
+      optional :config, -> { Cadenya::AIProviderKeySpec::Config }
 
-      # @!attribute openrouter
-      #   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.
+      # @!attribute credentials
+      #   AIProviderCredential is the secret material used to authenticate with a
+      #   provider. The set case must correspond to AIProviderKeySpec.provider. The server
+      #   encrypts the serialized message at rest and never returns it on reads.
       #
-      #   @return [Object, nil]
-      optional :openrouter, Cadenya::Internal::Type::Unknown
+      #   @return [Cadenya::Models::AIProviderKeySpec::Credentials, nil]
+      optional :credentials, -> { Cadenya::AIProviderKeySpec::Credentials }
 
       # @!attribute provider
       #   The AI provider this key authenticates against.
@@ -24,16 +27,163 @@ module Cadenya
       #   @return [Symbol, Cadenya::Models::AIProviderKeySpec::Provider, nil]
       optional :provider, enum: -> { Cadenya::AIProviderKeySpec::Provider }
 
-      # @!method initialize(api_key: nil, openrouter: nil, provider: nil)
+      # @!method initialize(config: nil, credentials: nil, provider: nil)
       #   Some parameter documentations has been truncated, see
       #   {Cadenya::Models::AIProviderKeySpec} for more details.
       #
-      #   @param api_key [String] The provider credential. Accepted on create/update; never populated in
+      #   @param config [Cadenya::Models::AIProviderKeySpec::Config] AIProviderConfig holds non-secret, provider-specific settings. The set case
       #
-      #   @param openrouter [Object] OpenRouterConfig holds OpenRouter-specific settings. Empty for now; it exists
+      #   @param credentials [Cadenya::Models::AIProviderKeySpec::Credentials] AIProviderCredential is the secret material used to authenticate with a
       #
       #   @param provider [Symbol, Cadenya::Models::AIProviderKeySpec::Provider] The AI provider this key authenticates against.
 
+      # @see Cadenya::Models::AIProviderKeySpec#config
+      class Config < Cadenya::Internal::Type::BaseModel
+        # @!attribute openai
+        #   OpenAIConfig holds OpenAI-specific settings.
+        #
+        #   @return [Cadenya::Models::AIProviderKeySpec::Config::OpenAI, nil]
+        optional :openai, -> { Cadenya::AIProviderKeySpec::Config::OpenAI }
+
+        # @!attribute openai_compatible
+        #   OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
+        #   Completions API. The base URL is required and its model catalog is discovered
+        #   live via GET {base_url}/models.
+        #
+        #   @return [Cadenya::Models::AIProviderKeySpec::Config::OpenAICompatible, nil]
+        optional :openai_compatible,
+                 -> { Cadenya::AIProviderKeySpec::Config::OpenAICompatible },
+                 api_name: :openaiCompatible
+
+        # @!attribute openrouter
+        #   OpenRouterConfig holds OpenRouter-specific settings.
+        #
+        #   @return [Cadenya::Models::AIProviderKeySpec::Config::Openrouter, nil]
+        optional :openrouter, -> { Cadenya::AIProviderKeySpec::Config::Openrouter }
+
+        # @!method initialize(openai: nil, openai_compatible: nil, openrouter: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Cadenya::Models::AIProviderKeySpec::Config} for more details.
+        #
+        #   AIProviderConfig holds non-secret, provider-specific settings. The set case must
+        #   correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
+        #   Gemini) simply leave this unset. The endpoint of a named provider is fixed and
+        #   intentionally not overridable here; use the OpenAI-compatible provider to target
+        #   a custom endpoint.
+        #
+        #   @param openai [Cadenya::Models::AIProviderKeySpec::Config::OpenAI] OpenAIConfig holds OpenAI-specific settings.
+        #
+        #   @param openai_compatible [Cadenya::Models::AIProviderKeySpec::Config::OpenAICompatible] OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI
+        #
+        #   @param openrouter [Cadenya::Models::AIProviderKeySpec::Config::Openrouter] OpenRouterConfig holds OpenRouter-specific settings.
+
+        # @see Cadenya::Models::AIProviderKeySpec::Config#openai
+        class OpenAI < Cadenya::Internal::Type::BaseModel
+          # @!attribute organization_id
+          #   Sent as the OpenAI-Organization header when set.
+          #
+          #   @return [String, nil]
+          optional :organization_id, String, api_name: :organizationId
+
+          # @!attribute project_id
+          #   Sent as the OpenAI-Project header when set.
+          #
+          #   @return [String, nil]
+          optional :project_id, String, api_name: :projectId
+
+          # @!method initialize(organization_id: nil, project_id: nil)
+          #   OpenAIConfig holds OpenAI-specific settings.
+          #
+          #   @param organization_id [String] Sent as the OpenAI-Organization header when set.
+          #
+          #   @param project_id [String] Sent as the OpenAI-Project header when set.
+        end
+
+        # @see Cadenya::Models::AIProviderKeySpec::Config#openai_compatible
+        class OpenAICompatible < Cadenya::Internal::Type::BaseModel
+          # @!attribute base_url
+          #
+          #   @return [String, nil]
+          optional :base_url, String, api_name: :baseUrl
+
+          # @!method initialize(base_url: nil)
+          #   OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
+          #   Completions API. The base URL is required and its model catalog is discovered
+          #   live via GET {base_url}/models.
+          #
+          #   @param base_url [String]
+        end
+
+        # @see Cadenya::Models::AIProviderKeySpec::Config#openrouter
+        class Openrouter < Cadenya::Internal::Type::BaseModel
+          # @!attribute region
+          #   Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
+          #
+          #   @return [String, nil]
+          optional :region, String
+
+          # @!method initialize(region: nil)
+          #   OpenRouterConfig holds OpenRouter-specific settings.
+          #
+          #   @param region [String] Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
+        end
+      end
+
+      # @see Cadenya::Models::AIProviderKeySpec#credentials
+      class Credentials < Cadenya::Internal::Type::BaseModel
+        # @!attribute api_key
+        #   CredentialAPIKey carries a single bearer/header API key.
+        #
+        #   @return [Cadenya::Models::AIProviderKeySpec::Credentials::APIKey, nil]
+        optional :api_key, -> { Cadenya::AIProviderKeySpec::Credentials::APIKey }, api_name: :apiKey
+
+        # @!attribute headers
+        #   CredentialHeaders carries arbitrary HTTP headers sent with every request to the
+        #   provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
+        #
+        #   @return [Cadenya::Models::AIProviderKeySpec::Credentials::Headers, nil]
+        optional :headers, -> { Cadenya::AIProviderKeySpec::Credentials::Headers }
+
+        # @!method initialize(api_key: nil, headers: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Cadenya::Models::AIProviderKeySpec::Credentials} for more details.
+        #
+        #   AIProviderCredential is the secret material used to authenticate with a
+        #   provider. The set case must correspond to AIProviderKeySpec.provider. The server
+        #   encrypts the serialized message at rest and never returns it on reads.
+        #
+        #   @param api_key [Cadenya::Models::AIProviderKeySpec::Credentials::APIKey] CredentialAPIKey carries a single bearer/header API key.
+        #
+        #   @param headers [Cadenya::Models::AIProviderKeySpec::Credentials::Headers] CredentialHeaders carries arbitrary HTTP headers sent with every request to
+
+        # @see Cadenya::Models::AIProviderKeySpec::Credentials#api_key
+        class APIKey < Cadenya::Internal::Type::BaseModel
+          # @!attribute api_key
+          #
+          #   @return [String, nil]
+          optional :api_key, String, api_name: :apiKey
+
+          # @!method initialize(api_key: nil)
+          #   CredentialAPIKey carries a single bearer/header API key.
+          #
+          #   @param api_key [String]
+        end
+
+        # @see Cadenya::Models::AIProviderKeySpec::Credentials#headers
+        class Headers < Cadenya::Internal::Type::BaseModel
+          # @!attribute headers
+          #
+          #   @return [Hash{Symbol=>String}, nil]
+          optional :headers, Cadenya::Internal::Type::HashOf[String]
+
+          # @!method initialize(headers: nil)
+          #   CredentialHeaders carries arbitrary HTTP headers sent with every request to the
+          #   provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
+          #
+          #   @param headers [Hash{Symbol=>String}]
+        end
+      end
+
       # The AI provider this key authenticates against.
       #
       # @see Cadenya::Models::AIProviderKeySpec#provider
@@ -42,6 +192,10 @@ module Cadenya
 
         AI_PROVIDER_UNSPECIFIED = :AI_PROVIDER_UNSPECIFIED
         AI_PROVIDER_OPENROUTER = :AI_PROVIDER_OPENROUTER
+        AI_PROVIDER_OPENAI = :AI_PROVIDER_OPENAI
+        AI_PROVIDER_ANTHROPIC = :AI_PROVIDER_ANTHROPIC
+        AI_PROVIDER_GEMINI = :AI_PROVIDER_GEMINI
+        AI_PROVIDER_OPENAI_COMPATIBLE = :AI_PROVIDER_OPENAI_COMPATIBLE
 
         # @!method self.values
         #   @return [Array<Symbol>]

data/lib/cadenya/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cadenya
-  VERSION = "0.23.0"
+  VERSION = "0.24.0"
 end

data/rbi/cadenya/models/ai_provider_key_spec.rbi

@@ -8,22 +8,29 @@ module Cadenya
           T.any(Cadenya::AIProviderKeySpec, Cadenya::Internal::AnyHash)
         end
 
-      # The provider credential. Accepted on create/update; never populated in responses
-      # (the server returns an empty value to avoid leaking it).
-      sig { returns(T.nilable(String)) }
-      attr_reader :api_key
+      # AIProviderConfig holds non-secret, provider-specific settings. The set case must
+      # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
+      # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
+      # intentionally not overridable here; use the OpenAI-compatible provider to target
+      # a custom endpoint.
+      sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Config)) }
+      attr_reader :config
 
-      sig { params(api_key: String).void }
-      attr_writer :api_key
+      sig { params(config: Cadenya::AIProviderKeySpec::Config::OrHash).void }
+      attr_writer :config
 
-      # 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
+      # AIProviderCredential is the secret material used to authenticate with a
+      # provider. The set case must correspond to AIProviderKeySpec.provider. The server
+      # encrypts the serialized message at rest and never returns it on reads.
+      sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials)) }
+      attr_reader :credentials
 
-      sig { params(openrouter: T.anything).void }
-      attr_writer :openrouter
+      sig do
+        params(
+          credentials: Cadenya::AIProviderKeySpec::Credentials::OrHash
+        ).void
+      end
+      attr_writer :credentials
 
       # The AI provider this key authenticates against.
       sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Provider::OrSymbol)) }
@@ -36,19 +43,22 @@ module Cadenya
 
       sig do
         params(
-          api_key: String,
-          openrouter: T.anything,
+          config: Cadenya::AIProviderKeySpec::Config::OrHash,
+          credentials: Cadenya::AIProviderKeySpec::Credentials::OrHash,
           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,
-        # 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,
+        # AIProviderConfig holds non-secret, provider-specific settings. The set case must
+        # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
+        # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
+        # intentionally not overridable here; use the OpenAI-compatible provider to target
+        # a custom endpoint.
+        config: nil,
+        # AIProviderCredential is the secret material used to authenticate with a
+        # provider. The set case must correspond to AIProviderKeySpec.provider. The server
+        # encrypts the serialized message at rest and never returns it on reads.
+        credentials: nil,
         # The AI provider this key authenticates against.
         provider: nil
       )
@@ -57,8 +67,8 @@ module Cadenya
       sig do
         override.returns(
           {
-            api_key: String,
-            openrouter: T.anything,
+            config: Cadenya::AIProviderKeySpec::Config,
+            credentials: Cadenya::AIProviderKeySpec::Credentials,
             provider: Cadenya::AIProviderKeySpec::Provider::OrSymbol
           }
         )
@@ -66,6 +76,315 @@ module Cadenya
       def to_hash
       end
 
+      class Config < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::AIProviderKeySpec::Config,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # OpenAIConfig holds OpenAI-specific settings.
+        sig { returns(T.nilable(Cadenya::AIProviderKeySpec::Config::OpenAI)) }
+        attr_reader :openai
+
+        sig do
+          params(
+            openai: Cadenya::AIProviderKeySpec::Config::OpenAI::OrHash
+          ).void
+        end
+        attr_writer :openai
+
+        # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
+        # Completions API. The base URL is required and its model catalog is discovered
+        # live via GET {base_url}/models.
+        sig do
+          returns(
+            T.nilable(Cadenya::AIProviderKeySpec::Config::OpenAICompatible)
+          )
+        end
+        attr_reader :openai_compatible
+
+        sig do
+          params(
+            openai_compatible:
+              Cadenya::AIProviderKeySpec::Config::OpenAICompatible::OrHash
+          ).void
+        end
+        attr_writer :openai_compatible
+
+        # OpenRouterConfig holds OpenRouter-specific settings.
+        sig do
+          returns(T.nilable(Cadenya::AIProviderKeySpec::Config::Openrouter))
+        end
+        attr_reader :openrouter
+
+        sig do
+          params(
+            openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter::OrHash
+          ).void
+        end
+        attr_writer :openrouter
+
+        # AIProviderConfig holds non-secret, provider-specific settings. The set case must
+        # correspond to AIProviderKeySpec.provider. Providers with no settings (Anthropic,
+        # Gemini) simply leave this unset. The endpoint of a named provider is fixed and
+        # intentionally not overridable here; use the OpenAI-compatible provider to target
+        # a custom endpoint.
+        sig do
+          params(
+            openai: Cadenya::AIProviderKeySpec::Config::OpenAI::OrHash,
+            openai_compatible:
+              Cadenya::AIProviderKeySpec::Config::OpenAICompatible::OrHash,
+            openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # OpenAIConfig holds OpenAI-specific settings.
+          openai: nil,
+          # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
+          # Completions API. The base URL is required and its model catalog is discovered
+          # live via GET {base_url}/models.
+          openai_compatible: nil,
+          # OpenRouterConfig holds OpenRouter-specific settings.
+          openrouter: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              openai: Cadenya::AIProviderKeySpec::Config::OpenAI,
+              openai_compatible:
+                Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
+              openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class OpenAI < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::AIProviderKeySpec::Config::OpenAI,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          # Sent as the OpenAI-Organization header when set.
+          sig { returns(T.nilable(String)) }
+          attr_reader :organization_id
+
+          sig { params(organization_id: String).void }
+          attr_writer :organization_id
+
+          # Sent as the OpenAI-Project header when set.
+          sig { returns(T.nilable(String)) }
+          attr_reader :project_id
+
+          sig { params(project_id: String).void }
+          attr_writer :project_id
+
+          # OpenAIConfig holds OpenAI-specific settings.
+          sig do
+            params(organization_id: String, project_id: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # Sent as the OpenAI-Organization header when set.
+            organization_id: nil,
+            # Sent as the OpenAI-Project header when set.
+            project_id: nil
+          )
+          end
+
+          sig do
+            override.returns({ organization_id: String, project_id: String })
+          end
+          def to_hash
+          end
+        end
+
+        class OpenAICompatible < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :base_url
+
+          sig { params(base_url: String).void }
+          attr_writer :base_url
+
+          # OpenAICompatibleConfig configures a generic endpoint that speaks the OpenAI Chat
+          # Completions API. The base URL is required and its model catalog is discovered
+          # live via GET {base_url}/models.
+          sig { params(base_url: String).returns(T.attached_class) }
+          def self.new(base_url: nil)
+          end
+
+          sig { override.returns({ base_url: String }) }
+          def to_hash
+          end
+        end
+
+        class Openrouter < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::AIProviderKeySpec::Config::Openrouter,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          # Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
+          sig { returns(T.nilable(String)) }
+          attr_reader :region
+
+          sig { params(region: String).void }
+          attr_writer :region
+
+          # OpenRouterConfig holds OpenRouter-specific settings.
+          sig { params(region: String).returns(T.attached_class) }
+          def self.new(
+            # Data-residency region (e.g. "us", "eu"). Empty uses the provider default.
+            region: nil
+          )
+          end
+
+          sig { override.returns({ region: String }) }
+          def to_hash
+          end
+        end
+      end
+
+      class Credentials < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::AIProviderKeySpec::Credentials,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # CredentialAPIKey carries a single bearer/header API key.
+        sig do
+          returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials::APIKey))
+        end
+        attr_reader :api_key
+
+        sig do
+          params(
+            api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey::OrHash
+          ).void
+        end
+        attr_writer :api_key
+
+        # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
+        # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
+        sig do
+          returns(T.nilable(Cadenya::AIProviderKeySpec::Credentials::Headers))
+        end
+        attr_reader :headers
+
+        sig do
+          params(
+            headers: Cadenya::AIProviderKeySpec::Credentials::Headers::OrHash
+          ).void
+        end
+        attr_writer :headers
+
+        # AIProviderCredential is the secret material used to authenticate with a
+        # provider. The set case must correspond to AIProviderKeySpec.provider. The server
+        # encrypts the serialized message at rest and never returns it on reads.
+        sig do
+          params(
+            api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey::OrHash,
+            headers: Cadenya::AIProviderKeySpec::Credentials::Headers::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # CredentialAPIKey carries a single bearer/header API key.
+          api_key: nil,
+          # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
+          # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
+          headers: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey,
+              headers: Cadenya::AIProviderKeySpec::Credentials::Headers
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class APIKey < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::AIProviderKeySpec::Credentials::APIKey,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :api_key
+
+          sig { params(api_key: String).void }
+          attr_writer :api_key
+
+          # CredentialAPIKey carries a single bearer/header API key.
+          sig { params(api_key: String).returns(T.attached_class) }
+          def self.new(api_key: nil)
+          end
+
+          sig { override.returns({ api_key: String }) }
+          def to_hash
+          end
+        end
+
+        class Headers < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::AIProviderKeySpec::Credentials::Headers,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :headers
+
+          sig { params(headers: T::Hash[Symbol, String]).void }
+          attr_writer :headers
+
+          # CredentialHeaders carries arbitrary HTTP headers sent with every request to the
+          # provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
+          sig do
+            params(headers: T::Hash[Symbol, String]).returns(T.attached_class)
+          end
+          def self.new(headers: nil)
+          end
+
+          sig { override.returns({ headers: T::Hash[Symbol, String] }) }
+          def to_hash
+          end
+        end
+      end
+
       # The AI provider this key authenticates against.
       module Provider
         extend Cadenya::Internal::Type::Enum
@@ -84,6 +403,26 @@ module Cadenya
             :AI_PROVIDER_OPENROUTER,
             Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
           )
+        AI_PROVIDER_OPENAI =
+          T.let(
+            :AI_PROVIDER_OPENAI,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
+        AI_PROVIDER_ANTHROPIC =
+          T.let(
+            :AI_PROVIDER_ANTHROPIC,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
+        AI_PROVIDER_GEMINI =
+          T.let(
+            :AI_PROVIDER_GEMINI,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
+        AI_PROVIDER_OPENAI_COMPATIBLE =
+          T.let(
+            :AI_PROVIDER_OPENAI_COMPATIBLE,
+            Cadenya::AIProviderKeySpec::Provider::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/sig/cadenya/models/ai_provider_key_spec.rbs

@@ -2,19 +2,23 @@ module Cadenya
   module Models
     type ai_provider_key_spec =
       {
-        api_key: String,
-        openrouter: top,
+        config: Cadenya::AIProviderKeySpec::Config,
+        credentials: Cadenya::AIProviderKeySpec::Credentials,
         provider: Cadenya::Models::AIProviderKeySpec::provider
       }
 
     class AIProviderKeySpec < Cadenya::Internal::Type::BaseModel
-      attr_reader api_key: String?
+      attr_reader config: Cadenya::AIProviderKeySpec::Config?
 
-      def api_key=: (String) -> String
+      def config=: (
+        Cadenya::AIProviderKeySpec::Config
+      ) -> Cadenya::AIProviderKeySpec::Config
 
-      attr_reader openrouter: top?
+      attr_reader credentials: Cadenya::AIProviderKeySpec::Credentials?
 
-      def openrouter=: (top) -> top
+      def credentials=: (
+        Cadenya::AIProviderKeySpec::Credentials
+      ) -> Cadenya::AIProviderKeySpec::Credentials
 
       attr_reader provider: Cadenya::Models::AIProviderKeySpec::provider?
 
@@ -23,24 +27,170 @@ module Cadenya
       ) -> Cadenya::Models::AIProviderKeySpec::provider
 
       def initialize: (
-        ?api_key: String,
-        ?openrouter: top,
+        ?config: Cadenya::AIProviderKeySpec::Config,
+        ?credentials: Cadenya::AIProviderKeySpec::Credentials,
         ?provider: Cadenya::Models::AIProviderKeySpec::provider
       ) -> void
 
       def to_hash: -> {
-        api_key: String,
-        openrouter: top,
+        config: Cadenya::AIProviderKeySpec::Config,
+        credentials: Cadenya::AIProviderKeySpec::Credentials,
         provider: Cadenya::Models::AIProviderKeySpec::provider
       }
 
-      type provider = :AI_PROVIDER_UNSPECIFIED | :AI_PROVIDER_OPENROUTER
+      type config =
+        {
+          openai: Cadenya::AIProviderKeySpec::Config::OpenAI,
+          openai_compatible: Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
+          openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter
+        }
+
+      class Config < Cadenya::Internal::Type::BaseModel
+        attr_reader openai: Cadenya::AIProviderKeySpec::Config::OpenAI?
+
+        def openai=: (
+          Cadenya::AIProviderKeySpec::Config::OpenAI
+        ) -> Cadenya::AIProviderKeySpec::Config::OpenAI
+
+        attr_reader openai_compatible: Cadenya::AIProviderKeySpec::Config::OpenAICompatible?
+
+        def openai_compatible=: (
+          Cadenya::AIProviderKeySpec::Config::OpenAICompatible
+        ) -> Cadenya::AIProviderKeySpec::Config::OpenAICompatible
+
+        attr_reader openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter?
+
+        def openrouter=: (
+          Cadenya::AIProviderKeySpec::Config::Openrouter
+        ) -> Cadenya::AIProviderKeySpec::Config::Openrouter
+
+        def initialize: (
+          ?openai: Cadenya::AIProviderKeySpec::Config::OpenAI,
+          ?openai_compatible: Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
+          ?openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter
+        ) -> void
+
+        def to_hash: -> {
+          openai: Cadenya::AIProviderKeySpec::Config::OpenAI,
+          openai_compatible: Cadenya::AIProviderKeySpec::Config::OpenAICompatible,
+          openrouter: Cadenya::AIProviderKeySpec::Config::Openrouter
+        }
+
+        type openai = { organization_id: String, project_id: String }
+
+        class OpenAI < Cadenya::Internal::Type::BaseModel
+          attr_reader organization_id: String?
+
+          def organization_id=: (String) -> String
+
+          attr_reader project_id: String?
+
+          def project_id=: (String) -> String
+
+          def initialize: (
+            ?organization_id: String,
+            ?project_id: String
+          ) -> void
+
+          def to_hash: -> { organization_id: String, project_id: String }
+        end
+
+        type openai_compatible = { base_url: String }
+
+        class OpenAICompatible < Cadenya::Internal::Type::BaseModel
+          attr_reader base_url: String?
+
+          def base_url=: (String) -> String
+
+          def initialize: (?base_url: String) -> void
+
+          def to_hash: -> { base_url: String }
+        end
+
+        type openrouter = { region: String }
+
+        class Openrouter < Cadenya::Internal::Type::BaseModel
+          attr_reader region: String?
+
+          def region=: (String) -> String
+
+          def initialize: (?region: String) -> void
+
+          def to_hash: -> { region: String }
+        end
+      end
+
+      type credentials =
+        {
+          api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey,
+          headers: Cadenya::AIProviderKeySpec::Credentials::Headers
+        }
+
+      class Credentials < Cadenya::Internal::Type::BaseModel
+        attr_reader api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey?
+
+        def api_key=: (
+          Cadenya::AIProviderKeySpec::Credentials::APIKey
+        ) -> Cadenya::AIProviderKeySpec::Credentials::APIKey
+
+        attr_reader headers: Cadenya::AIProviderKeySpec::Credentials::Headers?
+
+        def headers=: (
+          Cadenya::AIProviderKeySpec::Credentials::Headers
+        ) -> Cadenya::AIProviderKeySpec::Credentials::Headers
+
+        def initialize: (
+          ?api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey,
+          ?headers: Cadenya::AIProviderKeySpec::Credentials::Headers
+        ) -> void
+
+        def to_hash: -> {
+          api_key: Cadenya::AIProviderKeySpec::Credentials::APIKey,
+          headers: Cadenya::AIProviderKeySpec::Credentials::Headers
+        }
+
+        type api_key = { api_key: String }
+
+        class APIKey < Cadenya::Internal::Type::BaseModel
+          attr_reader api_key: String?
+
+          def api_key=: (String) -> String
+
+          def initialize: (?api_key: String) -> void
+
+          def to_hash: -> { api_key: String }
+        end
+
+        type headers = { headers: ::Hash[Symbol, String] }
+
+        class Headers < Cadenya::Internal::Type::BaseModel
+          attr_reader headers: ::Hash[Symbol, String]?
+
+          def headers=: (::Hash[Symbol, String]) -> ::Hash[Symbol, String]
+
+          def initialize: (?headers: ::Hash[Symbol, String]) -> void
+
+          def to_hash: -> { headers: ::Hash[Symbol, String] }
+        end
+      end
+
+      type provider =
+        :AI_PROVIDER_UNSPECIFIED
+        | :AI_PROVIDER_OPENROUTER
+        | :AI_PROVIDER_OPENAI
+        | :AI_PROVIDER_ANTHROPIC
+        | :AI_PROVIDER_GEMINI
+        | :AI_PROVIDER_OPENAI_COMPATIBLE
 
       module Provider
         extend Cadenya::Internal::Type::Enum
 
         AI_PROVIDER_UNSPECIFIED: :AI_PROVIDER_UNSPECIFIED
         AI_PROVIDER_OPENROUTER: :AI_PROVIDER_OPENROUTER
+        AI_PROVIDER_OPENAI: :AI_PROVIDER_OPENAI
+        AI_PROVIDER_ANTHROPIC: :AI_PROVIDER_ANTHROPIC
+        AI_PROVIDER_GEMINI: :AI_PROVIDER_GEMINI
+        AI_PROVIDER_OPENAI_COMPATIBLE: :AI_PROVIDER_OPENAI_COMPATIBLE
 
         def self?.values: -> ::Array[Cadenya::Models::AIProviderKeySpec::provider]
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cadenya
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Cadenya