cadenya 0.23.0 → 0.25.0

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/rbi/cadenya/models/tool_sets/config_mcp.rbi

@@ -3,7 +3,46 @@
 module Cadenya
   module Models
     module ToolSets
-      ConfigMcp = T.let(T.anything, Cadenya::Internal::Type::Converter)
+      class ConfigMcp < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ConfigMcp, Cadenya::Internal::AnyHash)
+          end
+
+        # Behavior hints synced from the MCP server's tool definition (ToolAnnotations in
+        # the MCP specification). All hints are advisory: servers are not required to send
+        # them, and clients should not rely on them for security decisions. Absent hints
+        # keep the MCP spec defaults (destructiveHint and openWorldHint default to true;
+        # readOnlyHint and idempotentHint default to false).
+        sig { returns(T.nilable(Cadenya::ToolSets::McpAnnotations)) }
+        attr_reader :annotations
+
+        sig do
+          params(annotations: Cadenya::ToolSets::McpAnnotations::OrHash).void
+        end
+        attr_writer :annotations
+
+        sig do
+          params(
+            annotations: Cadenya::ToolSets::McpAnnotations::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Behavior hints synced from the MCP server's tool definition (ToolAnnotations in
+          # the MCP specification). All hints are advisory: servers are not required to send
+          # them, and clients should not rely on them for security decisions. Absent hints
+          # keep the MCP spec defaults (destructiveHint and openWorldHint default to true;
+          # readOnlyHint and idempotentHint default to false).
+          annotations: nil
+        )
+        end
+
+        sig do
+          override.returns({ annotations: Cadenya::ToolSets::McpAnnotations })
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/tool_sets/mcp_annotations.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class McpAnnotations < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::McpAnnotations, Cadenya::Internal::AnyHash)
+          end
+
+        # If true, the tool may perform destructive updates to its environment. Only
+        # meaningful when read_only_hint is false.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :destructive_hint
+
+        sig { params(destructive_hint: T::Boolean).void }
+        attr_writer :destructive_hint
+
+        # If true, calling the tool repeatedly with the same arguments has no additional
+        # effect. Only meaningful when read_only_hint is false.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :idempotent_hint
+
+        sig { params(idempotent_hint: T::Boolean).void }
+        attr_writer :idempotent_hint
+
+        # If true, the tool may interact with an "open world" of external entities (e.g.
+        # web search); if false, its domain is closed.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :open_world_hint
+
+        sig { params(open_world_hint: T::Boolean).void }
+        attr_writer :open_world_hint
+
+        # If true, the tool does not modify its environment.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :read_only_hint
+
+        sig { params(read_only_hint: T::Boolean).void }
+        attr_writer :read_only_hint
+
+        # A human-readable title for the tool.
+        sig { returns(T.nilable(String)) }
+        attr_reader :title
+
+        sig { params(title: String).void }
+        attr_writer :title
+
+        # Behavior hints synced from the MCP server's tool definition (ToolAnnotations in
+        # the MCP specification). All hints are advisory: servers are not required to send
+        # them, and clients should not rely on them for security decisions. Absent hints
+        # keep the MCP spec defaults (destructiveHint and openWorldHint default to true;
+        # readOnlyHint and idempotentHint default to false).
+        sig do
+          params(
+            destructive_hint: T::Boolean,
+            idempotent_hint: T::Boolean,
+            open_world_hint: T::Boolean,
+            read_only_hint: T::Boolean,
+            title: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # If true, the tool may perform destructive updates to its environment. Only
+          # meaningful when read_only_hint is false.
+          destructive_hint: nil,
+          # If true, calling the tool repeatedly with the same arguments has no additional
+          # effect. Only meaningful when read_only_hint is false.
+          idempotent_hint: nil,
+          # If true, the tool may interact with an "open world" of external entities (e.g.
+          # web search); if false, its domain is closed.
+          open_world_hint: nil,
+          # If true, the tool does not modify its environment.
+          read_only_hint: nil,
+          # A human-readable title for the tool.
+          title: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              destructive_hint: T::Boolean,
+              idempotent_hint: T::Boolean,
+              open_world_hint: T::Boolean,
+              read_only_hint: T::Boolean,
+              title: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_spec_config.rbi

@@ -15,10 +15,10 @@ module Cadenya
         sig { params(http: Cadenya::ToolSets::ConfigHTTP::OrHash).void }
         attr_writer :http
 
-        sig { returns(T.nilable(T.anything)) }
+        sig { returns(T.nilable(Cadenya::ToolSets::ConfigMcp)) }
         attr_reader :mcp
 
-        sig { params(mcp: T.anything).void }
+        sig { params(mcp: Cadenya::ToolSets::ConfigMcp::OrHash).void }
         attr_writer :mcp
 
         sig { returns(T.nilable(Cadenya::ToolSets::ConfigOpenAPI)) }
@@ -33,7 +33,7 @@ module Cadenya
         sig do
           params(
             http: Cadenya::ToolSets::ConfigHTTP::OrHash,
-            mcp: T.anything,
+            mcp: Cadenya::ToolSets::ConfigMcp::OrHash,
             openapi: Cadenya::ToolSets::ConfigOpenAPI::OrHash
           ).returns(T.attached_class)
         end
@@ -44,7 +44,7 @@ module Cadenya
           override.returns(
             {
               http: Cadenya::ToolSets::ConfigHTTP,
-              mcp: T.anything,
+              mcp: Cadenya::ToolSets::ConfigMcp,
               openapi: Cadenya::ToolSets::ConfigOpenAPI
             }
           )