cadenya 0.49.0 → 0.50.0

data/rbi/cadenya/models/tool_set_adapter_mcp.rbi

@@ -2,10 +2,10 @@
 
 module Cadenya
   module Models
-    class ToolSetAdapterMcp < Cadenya::Internal::Type::BaseModel
+    class ToolSetAdapterMCP < Cadenya::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
-          T.any(Cadenya::ToolSetAdapterMcp, Cadenya::Internal::AnyHash)
+          T.any(Cadenya::ToolSetAdapterMCP, Cadenya::Internal::AnyHash)
         end
 
       # Top-level filter with simple boolean logic (no nesting)
@@ -29,23 +29,38 @@ module Cadenya
       attr_writer :include_tools
 
       # Defines behavior for just-in-time capable tool set adapters (IE: MCP).
-      sig { returns(T.nilable(Cadenya::ToolSetAdapterMcp::JustInTime)) }
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterMCP::JustInTime)) }
       attr_reader :just_in_time
 
       sig do
         params(
-          just_in_time: Cadenya::ToolSetAdapterMcp::JustInTime::OrHash
+          just_in_time: Cadenya::ToolSetAdapterMCP::JustInTime::OrHash
         ).void
       end
       attr_writer :just_in_time
 
       # Approval filters that will automatically set the approval requirement on tools
       # synced from an external source
-      sig { returns(T.nilable(Cadenya::ApprovalRequirementFilter)) }
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways,
+              Cadenya::ApprovalRequirementFilterOnly
+            )
+          )
+        )
+      end
       attr_reader :tool_approvals
 
       sig do
-        params(tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash).void
+        params(
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            )
+        ).void
       end
       attr_writer :tool_approvals
 
@@ -60,8 +75,12 @@ module Cadenya
           exclude_tools: Cadenya::ToolFilter::OrHash,
           headers: T::Hash[Symbol, String],
           include_tools: Cadenya::ToolFilter::OrHash,
-          just_in_time: Cadenya::ToolSetAdapterMcp::JustInTime::OrHash,
-          tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash,
+          just_in_time: Cadenya::ToolSetAdapterMCP::JustInTime::OrHash,
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            ),
           url: String
         ).returns(T.attached_class)
       end
@@ -86,8 +105,12 @@ module Cadenya
             exclude_tools: Cadenya::ToolFilter,
             headers: T::Hash[Symbol, String],
             include_tools: Cadenya::ToolFilter,
-            just_in_time: Cadenya::ToolSetAdapterMcp::JustInTime,
-            tool_approvals: Cadenya::ApprovalRequirementFilter,
+            just_in_time: Cadenya::ToolSetAdapterMCP::JustInTime,
+            tool_approvals:
+              T.any(
+                Cadenya::ApprovalRequirementFilterAlways,
+                Cadenya::ApprovalRequirementFilterOnly
+              ),
             url: String
           }
         )
@@ -99,7 +122,7 @@ module Cadenya
         OrHash =
           T.type_alias do
             T.any(
-              Cadenya::ToolSetAdapterMcp::JustInTime,
+              Cadenya::ToolSetAdapterMCP::JustInTime,
               Cadenya::Internal::AnyHash
             )
           end

data/rbi/cadenya/models/tool_set_adapter_mcp_variant.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterMCPVariant < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterMCPVariant, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::ToolSetAdapterMCP) }
+      attr_reader :mcp
+
+      sig { params(mcp: Cadenya::ToolSetAdapterMCP::OrHash).void }
+      attr_writer :mcp
+
+      sig { returns(Cadenya::ToolSetAdapterMCPVariant::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          mcp: Cadenya::ToolSetAdapterMCP::OrHash,
+          type: Cadenya::ToolSetAdapterMCPVariant::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(mcp:, type:)
+      end
+
+      sig do
+        override.returns(
+          {
+            mcp: Cadenya::ToolSetAdapterMCP,
+            type: Cadenya::ToolSetAdapterMCPVariant::Type::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterMCPVariant::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MCP = T.let(:mcp, Cadenya::ToolSetAdapterMCPVariant::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterMCPVariant::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_openapi.rbi

@@ -2,125 +2,21 @@
 
 module Cadenya
   module Models
-    class ToolSetAdapterOpenAPI < Cadenya::Internal::Type::BaseModel
-      OrHash =
+    module ToolSetAdapterOpenAPI
+      extend Cadenya::Internal::Type::Union
+
+      Variants =
         T.type_alias do
-          T.any(Cadenya::ToolSetAdapterOpenAPI, Cadenya::Internal::AnyHash)
+          T.any(
+            Cadenya::ToolSetAdapterOpenAPIURL,
+            Cadenya::ToolSetAdapterOpenAPIUploadID
+          )
         end
 
-      # Base URL for dispatching tool calls. If set, overrides the server resolved from
-      # the spec's servers array.
-      sig { returns(T.nilable(String)) }
-      attr_reader :base_url
-
-      sig { params(base_url: String).void }
-      attr_writer :base_url
-
-      # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::ToolFilter)) }
-      attr_reader :exclude_tools
-
-      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
-      attr_writer :exclude_tools
-
-      # Headers sent when fetching the spec from a URL and when dispatching tool calls.
-      sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      attr_reader :headers
-
-      sig { params(headers: T::Hash[Symbol, String]).void }
-      attr_writer :headers
-
-      # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::ToolFilter)) }
-      attr_reader :include_tools
-
-      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
-      attr_writer :include_tools
-
-      # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
-      # field). Used to select which server URL to dispatch to when base_url is not set.
-      # If unset, the first server is used. Ignored when base_url is set.
-      sig { returns(T.nilable(String)) }
-      attr_reader :server_name
-
-      sig { params(server_name: String).void }
-      attr_writer :server_name
-
-      # Approval filters that will automatically set the approval requirement on tools
-      # synced from an external source
-      sig { returns(T.nilable(Cadenya::ApprovalRequirementFilter)) }
-      attr_reader :tool_approvals
-
-      sig do
-        params(tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash).void
-      end
-      attr_writer :tool_approvals
-
-      # ID of a COMPLETE Upload containing the OpenAPI spec document.
-      sig { returns(T.nilable(String)) }
-      attr_reader :upload_id
-
-      sig { params(upload_id: String).void }
-      attr_writer :upload_id
-
-      # URL to fetch the OpenAPI spec from. Synced automatically every hour.
-      sig { returns(T.nilable(String)) }
-      attr_reader :url
-
-      sig { params(url: String).void }
-      attr_writer :url
-
-      sig do
-        params(
-          base_url: String,
-          exclude_tools: Cadenya::ToolFilter::OrHash,
-          headers: T::Hash[Symbol, String],
-          include_tools: Cadenya::ToolFilter::OrHash,
-          server_name: String,
-          tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash,
-          upload_id: String,
-          url: String
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # Base URL for dispatching tool calls. If set, overrides the server resolved from
-        # the spec's servers array.
-        base_url: nil,
-        # Top-level filter with simple boolean logic (no nesting)
-        exclude_tools: nil,
-        # Headers sent when fetching the spec from a URL and when dispatching tool calls.
-        headers: nil,
-        # Top-level filter with simple boolean logic (no nesting)
-        include_tools: nil,
-        # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
-        # field). Used to select which server URL to dispatch to when base_url is not set.
-        # If unset, the first server is used. Ignored when base_url is set.
-        server_name: nil,
-        # Approval filters that will automatically set the approval requirement on tools
-        # synced from an external source
-        tool_approvals: nil,
-        # ID of a COMPLETE Upload containing the OpenAPI spec document.
-        upload_id: nil,
-        # URL to fetch the OpenAPI spec from. Synced automatically every hour.
-        url: nil
-      )
-      end
-
       sig do
-        override.returns(
-          {
-            base_url: String,
-            exclude_tools: Cadenya::ToolFilter,
-            headers: T::Hash[Symbol, String],
-            include_tools: Cadenya::ToolFilter,
-            server_name: String,
-            tool_approvals: Cadenya::ApprovalRequirementFilter,
-            upload_id: String,
-            url: String
-          }
-        )
+        override.returns(T::Array[Cadenya::ToolSetAdapterOpenAPI::Variants])
       end
-      def to_hash
+      def self.variants
       end
     end
   end

data/rbi/cadenya/models/tool_set_adapter_openapi_upload_id.rbi

@@ -0,0 +1,169 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterOpenAPIUploadID < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::ToolSetAdapterOpenAPIUploadID,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Cadenya::ToolSetAdapterOpenAPIUploadID::Type::OrSymbol) }
+      attr_accessor :type
+
+      # ID of a COMPLETE Upload containing the OpenAPI spec document.
+      sig { returns(String) }
+      attr_accessor :upload_id
+
+      # Base URL for dispatching tool calls. If set, overrides the server resolved from
+      # the spec's servers array.
+      sig { returns(T.nilable(String)) }
+      attr_reader :base_url
+
+      sig { params(base_url: String).void }
+      attr_writer :base_url
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :exclude_tools
+
+      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :exclude_tools
+
+      # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :include_tools
+
+      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :include_tools
+
+      # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+      # field). Used to select which server URL to dispatch to when base_url is not set.
+      # If unset, the first server is used. Ignored when base_url is set.
+      sig { returns(T.nilable(String)) }
+      attr_reader :server_name
+
+      sig { params(server_name: String).void }
+      attr_writer :server_name
+
+      # Approval filters that will automatically set the approval requirement on tools
+      # synced from an external source
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways,
+              Cadenya::ApprovalRequirementFilterOnly
+            )
+          )
+        )
+      end
+      attr_reader :tool_approvals
+
+      sig do
+        params(
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            )
+        ).void
+      end
+      attr_writer :tool_approvals
+
+      sig do
+        params(
+          type: Cadenya::ToolSetAdapterOpenAPIUploadID::Type::OrSymbol,
+          upload_id: String,
+          base_url: String,
+          exclude_tools: Cadenya::ToolFilter::OrHash,
+          headers: T::Hash[Symbol, String],
+          include_tools: Cadenya::ToolFilter::OrHash,
+          server_name: String,
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        type:,
+        # ID of a COMPLETE Upload containing the OpenAPI spec document.
+        upload_id:,
+        # Base URL for dispatching tool calls. If set, overrides the server resolved from
+        # the spec's servers array.
+        base_url: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        exclude_tools: nil,
+        # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+        headers: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        include_tools: nil,
+        # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+        # field). Used to select which server URL to dispatch to when base_url is not set.
+        # If unset, the first server is used. Ignored when base_url is set.
+        server_name: nil,
+        # Approval filters that will automatically set the approval requirement on tools
+        # synced from an external source
+        tool_approvals: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            type: Cadenya::ToolSetAdapterOpenAPIUploadID::Type::OrSymbol,
+            upload_id: String,
+            base_url: String,
+            exclude_tools: Cadenya::ToolFilter,
+            headers: T::Hash[Symbol, String],
+            include_tools: Cadenya::ToolFilter,
+            server_name: String,
+            tool_approvals:
+              T.any(
+                Cadenya::ApprovalRequirementFilterAlways,
+                Cadenya::ApprovalRequirementFilterOnly
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterOpenAPIUploadID::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        UPLOAD_ID =
+          T.let(
+            :uploadId,
+            Cadenya::ToolSetAdapterOpenAPIUploadID::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterOpenAPIUploadID::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_openapi_url.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterOpenAPIURL < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterOpenAPIURL, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::ToolSetAdapterOpenAPIURL::Type::OrSymbol) }
+      attr_accessor :type
+
+      # URL to fetch the OpenAPI spec from. Synced automatically every hour.
+      sig { returns(String) }
+      attr_accessor :url
+
+      # Base URL for dispatching tool calls. If set, overrides the server resolved from
+      # the spec's servers array.
+      sig { returns(T.nilable(String)) }
+      attr_reader :base_url
+
+      sig { params(base_url: String).void }
+      attr_writer :base_url
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :exclude_tools
+
+      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :exclude_tools
+
+      # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :include_tools
+
+      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :include_tools
+
+      # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+      # field). Used to select which server URL to dispatch to when base_url is not set.
+      # If unset, the first server is used. Ignored when base_url is set.
+      sig { returns(T.nilable(String)) }
+      attr_reader :server_name
+
+      sig { params(server_name: String).void }
+      attr_writer :server_name
+
+      # Approval filters that will automatically set the approval requirement on tools
+      # synced from an external source
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways,
+              Cadenya::ApprovalRequirementFilterOnly
+            )
+          )
+        )
+      end
+      attr_reader :tool_approvals
+
+      sig do
+        params(
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            )
+        ).void
+      end
+      attr_writer :tool_approvals
+
+      sig do
+        params(
+          type: Cadenya::ToolSetAdapterOpenAPIURL::Type::OrSymbol,
+          url: String,
+          base_url: String,
+          exclude_tools: Cadenya::ToolFilter::OrHash,
+          headers: T::Hash[Symbol, String],
+          include_tools: Cadenya::ToolFilter::OrHash,
+          server_name: String,
+          tool_approvals:
+            T.any(
+              Cadenya::ApprovalRequirementFilterAlways::OrHash,
+              Cadenya::ApprovalRequirementFilterOnly::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        type:,
+        # URL to fetch the OpenAPI spec from. Synced automatically every hour.
+        url:,
+        # Base URL for dispatching tool calls. If set, overrides the server resolved from
+        # the spec's servers array.
+        base_url: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        exclude_tools: nil,
+        # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+        headers: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        include_tools: nil,
+        # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+        # field). Used to select which server URL to dispatch to when base_url is not set.
+        # If unset, the first server is used. Ignored when base_url is set.
+        server_name: nil,
+        # Approval filters that will automatically set the approval requirement on tools
+        # synced from an external source
+        tool_approvals: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            type: Cadenya::ToolSetAdapterOpenAPIURL::Type::OrSymbol,
+            url: String,
+            base_url: String,
+            exclude_tools: Cadenya::ToolFilter,
+            headers: T::Hash[Symbol, String],
+            include_tools: Cadenya::ToolFilter,
+            server_name: String,
+            tool_approvals:
+              T.any(
+                Cadenya::ApprovalRequirementFilterAlways,
+                Cadenya::ApprovalRequirementFilterOnly
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterOpenAPIURL::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        URL = T.let(:url, Cadenya::ToolSetAdapterOpenAPIURL::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterOpenAPIURL::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_openapi_variant.rbi

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterOpenAPIVariant < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::ToolSetAdapterOpenAPIVariant,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(
+          T.any(
+            Cadenya::ToolSetAdapterOpenAPIURL,
+            Cadenya::ToolSetAdapterOpenAPIUploadID
+          )
+        )
+      end
+      attr_accessor :openapi
+
+      sig { returns(Cadenya::ToolSetAdapterOpenAPIVariant::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          openapi:
+            T.any(
+              Cadenya::ToolSetAdapterOpenAPIURL::OrHash,
+              Cadenya::ToolSetAdapterOpenAPIUploadID::OrHash
+            ),
+          type: Cadenya::ToolSetAdapterOpenAPIVariant::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(openapi:, type:)
+      end
+
+      sig do
+        override.returns(
+          {
+            openapi:
+              T.any(
+                Cadenya::ToolSetAdapterOpenAPIURL,
+                Cadenya::ToolSetAdapterOpenAPIUploadID
+              ),
+            type: Cadenya::ToolSetAdapterOpenAPIVariant::Type::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterOpenAPIVariant::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OPENAPI =
+          T.let(
+            :openapi,
+            Cadenya::ToolSetAdapterOpenAPIVariant::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterOpenAPIVariant::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end