cadenya 0.1.0 → 0.3.0

data/rbi/cadenya/models/string_matcher.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcher < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcher, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :contains
+
+      sig { params(contains: String).void }
+      attr_writer :contains
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :ends_with
+
+      sig { params(ends_with: String).void }
+      attr_writer :ends_with
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :exact
+
+      sig { params(exact: String).void }
+      attr_writer :exact
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :regex
+
+      sig { params(regex: String).void }
+      attr_writer :regex
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :starts_with
+
+      sig { params(starts_with: String).void }
+      attr_writer :starts_with
+
+      # String matching operations
+      sig do
+        params(
+          case_sensitive: T::Boolean,
+          contains: String,
+          ends_with: String,
+          exact: String,
+          regex: String,
+          starts_with: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        case_sensitive: nil,
+        contains: nil,
+        ends_with: nil,
+        exact: nil,
+        regex: nil,
+        starts_with: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            case_sensitive: T::Boolean,
+            contains: String,
+            ends_with: String,
+            exact: String,
+            regex: String,
+            starts_with: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/sub_agent_spawned.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class SubAgentSpawned < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::SubAgentSpawned, Cadenya::Internal::AnyHash)
+        end
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(T.nilable(Cadenya::ResourceMetadata)) }
+      attr_reader :agent
+
+      sig { params(agent: Cadenya::ResourceMetadata::OrHash).void }
+      attr_writer :agent
+
+      # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+      # runs)
+      sig { returns(T.nilable(Cadenya::OperationMetadata)) }
+      attr_reader :objective
+
+      sig { params(objective: Cadenya::OperationMetadata::OrHash).void }
+      attr_writer :objective
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :task
+
+      sig { params(task: String).void }
+      attr_writer :task
+
+      sig do
+        params(
+          agent: Cadenya::ResourceMetadata::OrHash,
+          objective: Cadenya::OperationMetadata::OrHash,
+          task: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        agent: nil,
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        objective: nil,
+        task: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent: Cadenya::ResourceMetadata,
+            objective: Cadenya::OperationMetadata,
+            task: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/sub_agent_updated.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class SubAgentUpdated < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::SubAgentUpdated, Cadenya::Internal::AnyHash)
+        end
+
+      # BareMetadata contains the minimal metadata for a resource: the ID and an
+      # optional human-readable name. These are used for reference fields where the full
+      # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+      # e.g., the tool references inside an agent variation spec or the tools assigned
+      # to an objective. Both fields are server-populated; clients provide IDs through
+      # sibling fields rather than by constructing a BareMetadata themselves.
+      sig { returns(T.nilable(Cadenya::BareMetadata)) }
+      attr_reader :agent
+
+      sig { params(agent: Cadenya::BareMetadata::OrHash).void }
+      attr_writer :agent
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # BareMetadata contains the minimal metadata for a resource: the ID and an
+      # optional human-readable name. These are used for reference fields where the full
+      # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+      # e.g., the tool references inside an agent variation spec or the tools assigned
+      # to an objective. Both fields are server-populated; clients provide IDs through
+      # sibling fields rather than by constructing a BareMetadata themselves.
+      sig { returns(T.nilable(Cadenya::BareMetadata)) }
+      attr_reader :objective
+
+      sig { params(objective: Cadenya::BareMetadata::OrHash).void }
+      attr_writer :objective
+
+      sig { returns(T.nilable(Cadenya::SubAgentUpdated::Status::TaggedSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Cadenya::SubAgentUpdated::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          agent: Cadenya::BareMetadata::OrHash,
+          message: String,
+          objective: Cadenya::BareMetadata::OrHash,
+          status: Cadenya::SubAgentUpdated::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # BareMetadata contains the minimal metadata for a resource: the ID and an
+        # optional human-readable name. These are used for reference fields where the full
+        # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+        # e.g., the tool references inside an agent variation spec or the tools assigned
+        # to an objective. Both fields are server-populated; clients provide IDs through
+        # sibling fields rather than by constructing a BareMetadata themselves.
+        agent: nil,
+        message: nil,
+        # BareMetadata contains the minimal metadata for a resource: the ID and an
+        # optional human-readable name. These are used for reference fields where the full
+        # metadata (account scoping, timestamps, labels, external IDs) is not needed —
+        # e.g., the tool references inside an agent variation spec or the tools assigned
+        # to an objective. Both fields are server-populated; clients provide IDs through
+        # sibling fields rather than by constructing a BareMetadata themselves.
+        objective: nil,
+        status: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent: Cadenya::BareMetadata,
+            message: String,
+            objective: Cadenya::BareMetadata,
+            status: Cadenya::SubAgentUpdated::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::SubAgentUpdated::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STATUS_UNSPECIFIED =
+          T.let(
+            :STATUS_UNSPECIFIED,
+            Cadenya::SubAgentUpdated::Status::TaggedSymbol
+          )
+        STATUS_PENDING =
+          T.let(:STATUS_PENDING, Cadenya::SubAgentUpdated::Status::TaggedSymbol)
+        STATUS_RUNNING =
+          T.let(:STATUS_RUNNING, Cadenya::SubAgentUpdated::Status::TaggedSymbol)
+        STATUS_COMPLETED =
+          T.let(
+            :STATUS_COMPLETED,
+            Cadenya::SubAgentUpdated::Status::TaggedSymbol
+          )
+        STATUS_FAILED =
+          T.let(:STATUS_FAILED, Cadenya::SubAgentUpdated::Status::TaggedSymbol)
+        STATUS_CANCELLED =
+          T.let(
+            :STATUS_CANCELLED,
+            Cadenya::SubAgentUpdated::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::SubAgentUpdated::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_filter.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolFilter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolFilter, Cadenya::Internal::AnyHash) }
+
+      sig { returns(Cadenya::ToolFilter::Operator::OrSymbol) }
+      attr_accessor :operator
+
+      sig { returns(T.nilable(T::Array[Cadenya::AttributeFilter])) }
+      attr_reader :filters
+
+      sig { params(filters: T::Array[Cadenya::AttributeFilter::OrHash]).void }
+      attr_writer :filters
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig do
+        params(
+          operator: Cadenya::ToolFilter::Operator::OrSymbol,
+          filters: T::Array[Cadenya::AttributeFilter::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(operator:, filters: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            operator: Cadenya::ToolFilter::Operator::OrSymbol,
+            filters: T::Array[Cadenya::AttributeFilter]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Operator
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::ToolFilter::Operator) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OPERATOR_UNSPECIFIED =
+          T.let(
+            :OPERATOR_UNSPECIFIED,
+            Cadenya::ToolFilter::Operator::TaggedSymbol
+          )
+        OPERATOR_AND =
+          T.let(:OPERATOR_AND, Cadenya::ToolFilter::Operator::TaggedSymbol)
+        OPERATOR_OR =
+          T.let(:OPERATOR_OR, Cadenya::ToolFilter::Operator::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolFilter::Operator::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -20,18 +20,29 @@ module Cadenya
       sig { params(mcp: Cadenya::ToolSetAdapterMcp::OrHash).void }
       attr_writer :mcp
 
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterOpenAPI)) }
+      attr_reader :openapi
+
+      sig { params(openapi: Cadenya::ToolSetAdapterOpenAPI::OrHash).void }
+      attr_writer :openapi
+
       sig do
         params(
           http: Cadenya::ToolSetAdapterHTTP::OrHash,
-          mcp: Cadenya::ToolSetAdapterMcp::OrHash
+          mcp: Cadenya::ToolSetAdapterMcp::OrHash,
+          openapi: Cadenya::ToolSetAdapterOpenAPI::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::ToolSetAdapterHTTP, mcp: Cadenya::ToolSetAdapterMcp }
+          {
+            http: Cadenya::ToolSetAdapterHTTP,
+            mcp: Cadenya::ToolSetAdapterMcp,
+            openapi: Cadenya::ToolSetAdapterOpenAPI
+          }
         )
       end
       def to_hash

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