cadenya 0.2.0 → 0.4.0

data/rbi/cadenya/models/tool_set_adapter_mcp.rbi

@@ -9,10 +9,10 @@ module Cadenya
         end
 
       # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::McpToolFilter)) }
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
       attr_reader :exclude_tools
 
-      sig { params(exclude_tools: Cadenya::McpToolFilter::OrHash).void }
+      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
       attr_writer :exclude_tools
 
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
@@ -22,21 +22,19 @@ module Cadenya
       attr_writer :headers
 
       # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::McpToolFilter)) }
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
       attr_reader :include_tools
 
-      sig { params(include_tools: Cadenya::McpToolFilter::OrHash).void }
+      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
       attr_writer :include_tools
 
-      # Approval filters that will automatically set the approval requirement on the
-      # tools synced from the MCP server
-      sig { returns(T.nilable(Cadenya::ToolSetAdapterMcp::ToolApprovals)) }
+      # 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::ToolSetAdapterMcp::ToolApprovals::OrHash
-        ).void
+        params(tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash).void
       end
       attr_writer :tool_approvals
 
@@ -48,10 +46,10 @@ module Cadenya
 
       sig do
         params(
-          exclude_tools: Cadenya::McpToolFilter::OrHash,
+          exclude_tools: Cadenya::ToolFilter::OrHash,
           headers: T::Hash[Symbol, String],
-          include_tools: Cadenya::McpToolFilter::OrHash,
-          tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals::OrHash,
+          include_tools: Cadenya::ToolFilter::OrHash,
+          tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash,
           url: String
         ).returns(T.attached_class)
       end
@@ -61,8 +59,8 @@ module Cadenya
         headers: nil,
         # Top-level filter with simple boolean logic (no nesting)
         include_tools: nil,
-        # Approval filters that will automatically set the approval requirement on the
-        # tools synced from the MCP server
+        # Approval filters that will automatically set the approval requirement on tools
+        # synced from an external source
         tool_approvals: nil,
         url: nil
       )
@@ -71,60 +69,16 @@ module Cadenya
       sig do
         override.returns(
           {
-            exclude_tools: Cadenya::McpToolFilter,
+            exclude_tools: Cadenya::ToolFilter,
             headers: T::Hash[Symbol, String],
-            include_tools: Cadenya::McpToolFilter,
-            tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals,
+            include_tools: Cadenya::ToolFilter,
+            tool_approvals: Cadenya::ApprovalRequirementFilter,
             url: String
           }
         )
       end
       def to_hash
       end
-
-      class ToolApprovals < Cadenya::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Cadenya::ToolSetAdapterMcp::ToolApprovals,
-              Cadenya::Internal::AnyHash
-            )
-          end
-
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :always
-
-        sig { params(always: T::Boolean).void }
-        attr_writer :always
-
-        # Top-level filter with simple boolean logic (no nesting)
-        sig { returns(T.nilable(Cadenya::McpToolFilter)) }
-        attr_reader :only
-
-        sig { params(only: Cadenya::McpToolFilter::OrHash).void }
-        attr_writer :only
-
-        # Approval filters that will automatically set the approval requirement on the
-        # tools synced from the MCP server
-        sig do
-          params(
-            always: T::Boolean,
-            only: Cadenya::McpToolFilter::OrHash
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          always: nil,
-          # Top-level filter with simple boolean logic (no nesting)
-          only: nil
-        )
-        end
-
-        sig do
-          override.returns({ always: T::Boolean, only: Cadenya::McpToolFilter })
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/cadenya/models/tool_set_adapter_openapi.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterOpenAPI < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterOpenAPI, Cadenya::Internal::AnyHash)
+        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
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_get_openapi_spec_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetGetOpenAPISpecParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::ToolSetGetOpenAPISpecParams,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :tool_set_id
+
+      sig do
+        params(
+          workspace_id: String,
+          tool_set_id: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(workspace_id:, tool_set_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            tool_set_id: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_get_openapi_spec_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetGetOpenAPISpecResponse < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cadenya::Models::ToolSetGetOpenAPISpecResponse,
+            Cadenya::Internal::AnyHash
+          )
+        end
+
+      # The consumed OpenAPI specification as a JSON string.
+      sig { returns(T.nilable(String)) }
+      attr_reader :spec
+
+      sig { params(spec: String).void }
+      attr_writer :spec
+
+      sig { params(spec: String).returns(T.attached_class) }
+      def self.new(
+        # The consumed OpenAPI specification as a JSON string.
+        spec: nil
+      )
+      end
+
+      sig { override.returns({ spec: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/config_openapi.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ConfigOpenAPI < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ConfigOpenAPI, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :method_
+
+        sig { params(method_: String).void }
+        attr_writer :method_
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :operation_id
+
+        sig { params(operation_id: String).void }
+        attr_writer :operation_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :path
+
+        sig { params(path: String).void }
+        attr_writer :path
+
+        sig do
+          params(method_: String, operation_id: String, path: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(method_: nil, operation_id: nil, path: nil)
+        end
+
+        sig do
+          override.returns(
+            { method_: String, operation_id: String, path: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -21,23 +21,31 @@ module Cadenya
         sig { params(mcp: Cadenya::ToolSets::ConfigMcp::OrHash).void }
         attr_writer :mcp
 
+        sig { returns(T.nilable(Cadenya::ToolSets::ConfigOpenAPI)) }
+        attr_reader :openapi
+
+        sig { params(openapi: Cadenya::ToolSets::ConfigOpenAPI::OrHash).void }
+        attr_writer :openapi
+
         # Config defines the adapter to use for the tool. This is used to determine how
         # the tool is called. For example, if the tool is an HTTP tool, the adapter will
         # be Http. If the tool is an inline tool, the adapter will be Inline.
         sig do
           params(
             http: Cadenya::ToolSets::ConfigHTTP::OrHash,
-            mcp: Cadenya::ToolSets::ConfigMcp::OrHash
+            mcp: Cadenya::ToolSets::ConfigMcp::OrHash,
+            openapi: Cadenya::ToolSets::ConfigOpenAPI::OrHash
           ).returns(T.attached_class)
         end
-        def self.new(http: nil, mcp: nil)
+        def self.new(http: nil, mcp: nil, openapi: nil)
         end
 
         sig do
           override.returns(
             {
               http: Cadenya::ToolSets::ConfigHTTP,
-              mcp: Cadenya::ToolSets::ConfigMcp
+              mcp: Cadenya::ToolSets::ConfigMcp,
+              openapi: Cadenya::ToolSets::ConfigOpenAPI
             }
           )
         end

data/rbi/cadenya/models/workspace.rbi

@@ -20,17 +20,29 @@ module Cadenya
       sig { params(spec: Cadenya::WorkspaceSpec::OrHash).void }
       attr_writer :spec
 
+      # Lifecycle status of the workspace. Archived workspaces reject all requests
+      # scoped to them. Server-populated.
+      sig { returns(T.nilable(Cadenya::Workspace::Status::TaggedSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Cadenya::Workspace::Status::OrSymbol).void }
+      attr_writer :status
+
       sig do
         params(
           metadata: Cadenya::AccountResourceMetadata::OrHash,
-          spec: Cadenya::WorkspaceSpec::OrHash
+          spec: Cadenya::WorkspaceSpec::OrHash,
+          status: Cadenya::Workspace::Status::OrSymbol
         ).returns(T.attached_class)
       end
       def self.new(
         # AccountResourceMetadata is used to represent a resource that is associated to an
         # account but not to a workspace.
         metadata:,
-        spec:
+        spec:,
+        # Lifecycle status of the workspace. Archived workspaces reject all requests
+        # scoped to them. Server-populated.
+        status: nil
       )
       end
 
@@ -38,12 +50,36 @@ module Cadenya
         override.returns(
           {
             metadata: Cadenya::AccountResourceMetadata,
-            spec: Cadenya::WorkspaceSpec
+            spec: Cadenya::WorkspaceSpec,
+            status: Cadenya::Workspace::Status::TaggedSymbol
           }
         )
       end
       def to_hash
       end
+
+      # Lifecycle status of the workspace. Archived workspaces reject all requests
+      # scoped to them. Server-populated.
+      module Status
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::Workspace::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STATUS_ENABLED =
+          T.let(:STATUS_ENABLED, Cadenya::Workspace::Status::TaggedSymbol)
+        STATUS_DISABLED =
+          T.let(:STATUS_DISABLED, Cadenya::Workspace::Status::TaggedSymbol)
+        STATUS_ARCHIVED =
+          T.let(:STATUS_ARCHIVED, Cadenya::Workspace::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Cadenya::Workspace::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/workspace_admin/member_add_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module WorkspaceAdmin
+      class MemberAddParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::WorkspaceAdmin::MemberAddParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        # Email address to add (resolve-or-invite). Mutually exclusive with profile_id.
+        sig { returns(T.nilable(String)) }
+        attr_reader :email
+
+        sig { params(email: String).void }
+        attr_writer :email
+
+        # An existing account profile to add. Mutually exclusive with email.
+        sig { returns(T.nilable(String)) }
+        attr_reader :profile_id
+
+        sig { params(profile_id: String).void }
+        attr_writer :profile_id
+
+        sig do
+          params(
+            workspace_id: String,
+            email: String,
+            profile_id: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          # Email address to add (resolve-or-invite). Mutually exclusive with profile_id.
+          email: nil,
+          # An existing account profile to add. Mutually exclusive with email.
+          profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              email: String,
+              profile_id: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/workspace_admin/member_list_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module WorkspaceAdmin
+      class MemberListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::WorkspaceAdmin::MemberListParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        # Pagination cursor from previous response
+        sig { returns(T.nilable(String)) }
+        attr_reader :cursor
+
+        sig { params(cursor: String).void }
+        attr_writer :cursor
+
+        # Maximum number of results to return
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+            workspace_id: String,
+            cursor: String,
+            limit: Integer,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          # Pagination cursor from previous response
+          cursor: nil,
+          # Maximum number of results to return
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              cursor: String,
+              limit: Integer,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/workspace_admin/member_remove_params.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module WorkspaceAdmin
+      class MemberRemoveParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::WorkspaceAdmin::MemberRemoveParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :profile_id
+
+        sig do
+          params(
+            workspace_id: String,
+            profile_id: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(workspace_id:, profile_id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              profile_id: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end