cadenya 0.1.0

data/rbi/cadenya/models/tool_approval_requested.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolApprovalRequested < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolApprovalRequested, Cadenya::Internal::AnyHash)
+        end
+
+      # The ID of the objective tool call record. Use this ID with the ApproveToolCall
+      # or DenyToolCall RPCs to approve or deny the tool call.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_call_id
+
+      sig { params(tool_call_id: String).void }
+      attr_writer :tool_call_id
+
+      sig { params(tool_call_id: String).returns(T.attached_class) }
+      def self.new(
+        # The ID of the objective tool call record. Use this ID with the ApproveToolCall
+        # or DenyToolCall RPCs to approve or deny the tool call.
+        tool_call_id: nil
+      )
+      end
+
+      sig { override.returns({ tool_call_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_approved.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolApproved < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolApproved, Cadenya::Internal::AnyHash)
+        end
+
+      # The ID of the objective tool call record that was approved via the
+      # ApproveToolCall RPC.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_call_id
+
+      sig { params(tool_call_id: String).void }
+      attr_writer :tool_call_id
+
+      sig { params(tool_call_id: String).returns(T.attached_class) }
+      def self.new(
+        # The ID of the objective tool call record that was approved via the
+        # ApproveToolCall RPC.
+        tool_call_id: nil
+      )
+      end
+
+      sig { override.returns({ tool_call_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_called.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolCalled < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolCalled, Cadenya::Internal::AnyHash) }
+
+      # The ID of the objective tool call record that was executed.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_call_id
+
+      sig { params(tool_call_id: String).void }
+      attr_writer :tool_call_id
+
+      sig { params(tool_call_id: String).returns(T.attached_class) }
+      def self.new(
+        # The ID of the objective tool call record that was executed.
+        tool_call_id: nil
+      )
+      end
+
+      sig { override.returns({ tool_call_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_denied.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolDenied < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolDenied, Cadenya::Internal::AnyHash) }
+
+      # The memo provided by the reviewer when denying the tool call. This is passed to
+      # the agent to provide further instructions.
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      # The ID of the objective tool call record that was denied via the DenyToolCall
+      # RPC.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_call_id
+
+      sig { params(tool_call_id: String).void }
+      attr_writer :tool_call_id
+
+      sig do
+        params(memo: String, tool_call_id: String).returns(T.attached_class)
+      end
+      def self.new(
+        # The memo provided by the reviewer when denying the tool call. This is passed to
+        # the agent to provide further instructions.
+        memo: nil,
+        # The ID of the objective tool call record that was denied via the DenyToolCall
+        # RPC.
+        tool_call_id: nil
+      )
+      end
+
+      sig { override.returns({ memo: String, tool_call_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_entry.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolEntry < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolEntry, Cadenya::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Cadenya::ToolSets::ToolSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ToolSets::ToolSpec::OrHash).void }
+      attr_writer :spec
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      sig do
+        params(
+          name: String,
+          spec: Cadenya::ToolSets::ToolSpec::OrHash,
+          labels: T::Hash[Symbol, String]
+        ).returns(T.attached_class)
+      end
+      def self.new(name:, spec:, labels: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            spec: Cadenya::ToolSets::ToolSpec,
+            labels: T::Hash[Symbol, String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_error.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolError < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolError, Cadenya::Internal::AnyHash) }
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # The ID of the objective tool call record that encountered an error during
+      # execution.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_call_id
+
+      sig { params(tool_call_id: String).void }
+      attr_writer :tool_call_id
+
+      sig do
+        params(message: String, tool_call_id: String).returns(T.attached_class)
+      end
+      def self.new(
+        message: nil,
+        # The ID of the objective tool call record that encountered an error during
+        # execution.
+        tool_call_id: nil
+      )
+      end
+
+      sig { override.returns({ message: String, tool_call_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_result.rbi

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

data/rbi/cadenya/models/tool_set.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSet < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolSet, Cadenya::Internal::AnyHash) }
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(Cadenya::ResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::ResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::ToolSetSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ToolSetSpec::OrHash).void }
+      attr_writer :spec
+
+      # Tool set information
+      sig { returns(T.nilable(Cadenya::ToolSetInfo)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::ToolSetInfo::OrHash).void }
+      attr_writer :info
+
+      sig do
+        params(
+          metadata: Cadenya::ResourceMetadata::OrHash,
+          spec: Cadenya::ToolSetSpec::OrHash,
+          info: Cadenya::ToolSetInfo::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        metadata:,
+        spec:,
+        # Tool set information
+        info: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            metadata: Cadenya::ResourceMetadata,
+            spec: Cadenya::ToolSetSpec,
+            info: Cadenya::ToolSetInfo
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapter, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterHTTP)) }
+      attr_reader :http
+
+      sig { params(http: Cadenya::ToolSetAdapterHTTP::OrHash).void }
+      attr_writer :http
+
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterMcp)) }
+      attr_reader :mcp
+
+      sig { params(mcp: Cadenya::ToolSetAdapterMcp::OrHash).void }
+      attr_writer :mcp
+
+      sig do
+        params(
+          http: Cadenya::ToolSetAdapterHTTP::OrHash,
+          mcp: Cadenya::ToolSetAdapterMcp::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(http: nil, mcp: nil)
+      end
+
+      sig do
+        override.returns(
+          { http: Cadenya::ToolSetAdapterHTTP, mcp: Cadenya::ToolSetAdapterMcp }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_http.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterHTTP < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterHTTP, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :base_url
+
+      sig { params(base_url: String).void }
+      attr_writer :base_url
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      sig do
+        params(base_url: String, headers: T::Hash[Symbol, String]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(base_url: nil, headers: nil)
+      end
+
+      sig do
+        override.returns({ base_url: String, headers: T::Hash[Symbol, String] })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_mcp.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterMcp < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterMcp, Cadenya::Internal::AnyHash)
+        end
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::McpToolFilter)) }
+      attr_reader :exclude_tools
+
+      sig { params(exclude_tools: Cadenya::McpToolFilter::OrHash).void }
+      attr_writer :exclude_tools
+
+      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::McpToolFilter)) }
+      attr_reader :include_tools
+
+      sig { params(include_tools: Cadenya::McpToolFilter::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)) }
+      attr_reader :tool_approvals
+
+      sig do
+        params(
+          tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals::OrHash
+        ).void
+      end
+      attr_writer :tool_approvals
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+
+      sig { params(url: String).void }
+      attr_writer :url
+
+      sig do
+        params(
+          exclude_tools: Cadenya::McpToolFilter::OrHash,
+          headers: T::Hash[Symbol, String],
+          include_tools: Cadenya::McpToolFilter::OrHash,
+          tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals::OrHash,
+          url: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Top-level filter with simple boolean logic (no nesting)
+        exclude_tools: nil,
+        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
+        tool_approvals: nil,
+        url: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            exclude_tools: Cadenya::McpToolFilter,
+            headers: T::Hash[Symbol, String],
+            include_tools: Cadenya::McpToolFilter,
+            tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals,
+            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_create_params.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetCreateParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetCreateParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # CreateResourceMetadata contains the user-provided fields for creating a
+      # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+      # profile_id, created_at) are excluded since they are set by the server.
+      sig { returns(Cadenya::CreateResourceMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::CreateResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(Cadenya::ToolSetSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ToolSetSpec::OrHash).void }
+      attr_writer :spec
+
+      sig do
+        params(
+          workspace_id: String,
+          metadata: Cadenya::CreateResourceMetadata::OrHash,
+          spec: Cadenya::ToolSetSpec::OrHash,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        # CreateResourceMetadata contains the user-provided fields for creating a
+        # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+        # profile_id, created_at) are excluded since they are set by the server.
+        metadata:,
+        spec:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            metadata: Cadenya::CreateResourceMetadata,
+            spec: Cadenya::ToolSetSpec,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_delete_params.rbi

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

data/rbi/cadenya/models/tool_set_entry.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetEntry < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetEntry, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Cadenya::ToolSetSpec) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ToolSetSpec::OrHash).void }
+      attr_writer :spec
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      # Tools in this tool set, keyed by external_id.
+      sig { returns(T.nilable(T::Hash[Symbol, Cadenya::ToolEntry])) }
+      attr_reader :tools
+
+      sig { params(tools: T::Hash[Symbol, Cadenya::ToolEntry::OrHash]).void }
+      attr_writer :tools
+
+      sig do
+        params(
+          name: String,
+          spec: Cadenya::ToolSetSpec::OrHash,
+          labels: T::Hash[Symbol, String],
+          tools: T::Hash[Symbol, Cadenya::ToolEntry::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        name:,
+        spec:,
+        labels: nil,
+        # Tools in this tool set, keyed by external_id.
+        tools: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            spec: Cadenya::ToolSetSpec,
+            labels: T::Hash[Symbol, String],
+            tools: T::Hash[Symbol, Cadenya::ToolEntry]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end