cadenya 0.52.0 → 1.0.1

data/rbi/cadenya/models/tenants/subject_list_params.rbi

@@ -1,110 +0,0 @@
-# typed: strong
-
-module Cadenya
-  module Models
-    module Tenants
-      class SubjectListParams < Cadenya::Internal::Type::BaseModel
-        extend Cadenya::Internal::Type::RequestParameters::Converter
-        include Cadenya::Internal::Type::RequestParameters
-
-        OrHash =
-          T.type_alias do
-            T.any(
-              Cadenya::Tenants::SubjectListParams,
-              Cadenya::Internal::AnyHash
-            )
-          end
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :workspace_id
-
-        sig { params(workspace_id: String).void }
-        attr_writer :workspace_id
-
-        sig { returns(String) }
-        attr_accessor :tenant_id
-
-        # Pagination cursor from previous response.
-        sig { returns(T.nilable(String)) }
-        attr_reader :cursor
-
-        sig { params(cursor: String).void }
-        attr_writer :cursor
-
-        # When true, the `info` field on each returned subject is populated.
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :include_info
-
-        sig { params(include_info: T::Boolean).void }
-        attr_writer :include_info
-
-        # Maximum number of results to return.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :limit
-
-        sig { params(limit: Integer).void }
-        attr_writer :limit
-
-        # Substring match against the subject's name and external_id.
-        sig { returns(T.nilable(String)) }
-        attr_reader :query
-
-        sig { params(query: String).void }
-        attr_writer :query
-
-        # Sort order for results (asc or desc by creation time).
-        sig { returns(T.nilable(String)) }
-        attr_reader :sort_order
-
-        sig { params(sort_order: String).void }
-        attr_writer :sort_order
-
-        sig do
-          params(
-            tenant_id: String,
-            workspace_id: String,
-            cursor: String,
-            include_info: T::Boolean,
-            limit: Integer,
-            query: String,
-            sort_order: String,
-            request_options: Cadenya::RequestOptions::OrHash
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          tenant_id:,
-          workspace_id: nil,
-          # Pagination cursor from previous response.
-          cursor: nil,
-          # When true, the `info` field on each returned subject is populated.
-          include_info: nil,
-          # Maximum number of results to return.
-          limit: nil,
-          # Substring match against the subject's name and external_id.
-          query: nil,
-          # Sort order for results (asc or desc by creation time).
-          sort_order: nil,
-          request_options: {}
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              workspace_id: String,
-              tenant_id: String,
-              cursor: String,
-              include_info: T::Boolean,
-              limit: Integer,
-              query: String,
-              sort_order: String,
-              request_options: Cadenya::RequestOptions
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-    end
-  end
-end

data/rbi/cadenya/models/tool_approval_requested.rbi

@@ -1,32 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-# typed: strong
-
-module Cadenya
-  module Models
-    class ToolCalled < Cadenya::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias { T.any(Cadenya::ToolCalled, Cadenya::Internal::AnyHash) }
-
-      # The arguments passed to the tool.
-      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-      attr_reader :arguments
-
-      sig { params(arguments: T::Hash[Symbol, T.anything]).void }
-      attr_writer :arguments
-
-      # 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 { returns(T.nilable(Cadenya::ToolSets::ToolSpecConfig::Variants)) }
-      attr_reader :config
-
-      sig do
-        params(
-          config:
-            T.any(
-              Cadenya::ToolSets::ToolSpecConfigHTTP::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigMCP::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigOpenAPI::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigBare::OrHash
-            )
-        ).void
-      end
-      attr_writer :config
-
-      # CallableTool is a union that represents a tool that can be called by an agent.
-      # In Cadenya, a tool that is used within an agent objective might be a
-      # user-defined tool (IE: MCP, HTTP), another Agent (useful to separate context),
-      # or a Cadenya Tool (one Cadenya provides).
-      sig { returns(T.nilable(Cadenya::CallableTool::Variants)) }
-      attr_reader :tool
-
-      sig do
-        params(
-          tool:
-            T.any(
-              Cadenya::CallableToolTool::OrHash,
-              Cadenya::CallableToolAgent::OrHash,
-              Cadenya::CallableToolCadenyaProvidedTool::OrHash
-            )
-        ).void
-      end
-      attr_writer :tool
-
-      # 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 do
-        params(
-          arguments: T::Hash[Symbol, T.anything],
-          config:
-            T.any(
-              Cadenya::ToolSets::ToolSpecConfigHTTP::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigMCP::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigOpenAPI::OrHash,
-              Cadenya::ToolSets::ToolSpecConfigBare::OrHash
-            ),
-          tool:
-            T.any(
-              Cadenya::CallableToolTool::OrHash,
-              Cadenya::CallableToolAgent::OrHash,
-              Cadenya::CallableToolCadenyaProvidedTool::OrHash
-            ),
-          tool_call_id: String
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # The arguments passed to the tool.
-        arguments: nil,
-        # 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.
-        config: nil,
-        # CallableTool is a union that represents a tool that can be called by an agent.
-        # In Cadenya, a tool that is used within an agent objective might be a
-        # user-defined tool (IE: MCP, HTTP), another Agent (useful to separate context),
-        # or a Cadenya Tool (one Cadenya provides).
-        tool: nil,
-        # The ID of the objective tool call record that was executed.
-        tool_call_id: nil
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            arguments: T::Hash[Symbol, T.anything],
-            config: Cadenya::ToolSets::ToolSpecConfig::Variants,
-            tool: Cadenya::CallableTool::Variants,
-            tool_call_id: String
-          }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/cadenya/models/tool_denied.rbi

@@ -1,43 +0,0 @@
-# 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_error.rbi

@@ -1,39 +0,0 @@
-# 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_filter.rbi

@@ -1,66 +0,0 @@
-# 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_result.rbi

@@ -1,54 +0,0 @@
-# typed: strong
-
-module Cadenya
-  module Models
-    class ToolResult < Cadenya::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias { T.any(Cadenya::ToolResult, Cadenya::Internal::AnyHash) }
-
-      # ObjectiveToolCallResult is the content a tool returned after execution. Tools
-      # can return multiple content blocks, and blocks can be multi-modal (text, image,
-      # audio). Media blocks are stored by Cadenya and served as short-lived signed URLs
-      # rather than inline bytes.
-      sig { returns(Cadenya::Objectives::ObjectiveToolCallResult) }
-      attr_reader :result
-
-      sig do
-        params(
-          result: Cadenya::Objectives::ObjectiveToolCallResult::OrHash
-        ).void
-      end
-      attr_writer :result
-
-      sig { returns(String) }
-      attr_accessor :tool_call_id
-
-      sig do
-        params(
-          result: Cadenya::Objectives::ObjectiveToolCallResult::OrHash,
-          tool_call_id: String
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # ObjectiveToolCallResult is the content a tool returned after execution. Tools
-        # can return multiple content blocks, and blocks can be multi-modal (text, image,
-        # audio). Media blocks are stored by Cadenya and served as short-lived signed URLs
-        # rather than inline bytes.
-        result:,
-        tool_call_id:
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            result: Cadenya::Objectives::ObjectiveToolCallResult,
-            tool_call_id: String
-          }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/cadenya/models/tool_set.rbi

@@ -1,93 +0,0 @@
-# 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
-
-      # The current lifecycle state of the tool set. Output only. Tool sets are created
-      # STATE_ACTIVE; use the :archive and :unarchive actions to transition between
-      # states.
-      sig { returns(Cadenya::ToolSet::State::TaggedSymbol) }
-      attr_accessor :state
-
-      # 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,
-          state: Cadenya::ToolSet::State::OrSymbol,
-          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:,
-        # The current lifecycle state of the tool set. Output only. Tool sets are created
-        # STATE_ACTIVE; use the :archive and :unarchive actions to transition between
-        # states.
-        state:,
-        # Tool set information
-        info: nil
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            metadata: Cadenya::ResourceMetadata,
-            spec: Cadenya::ToolSetSpec,
-            state: Cadenya::ToolSet::State::TaggedSymbol,
-            info: Cadenya::ToolSetInfo
-          }
-        )
-      end
-      def to_hash
-      end
-
-      # The current lifecycle state of the tool set. Output only. Tool sets are created
-      # STATE_ACTIVE; use the :archive and :unarchive actions to transition between
-      # states.
-      module State
-        extend Cadenya::Internal::Type::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, Cadenya::ToolSet::State) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        STATE_UNSPECIFIED =
-          T.let(:STATE_UNSPECIFIED, Cadenya::ToolSet::State::TaggedSymbol)
-        STATE_ACTIVE =
-          T.let(:STATE_ACTIVE, Cadenya::ToolSet::State::TaggedSymbol)
-        STATE_ARCHIVED =
-          T.let(:STATE_ARCHIVED, Cadenya::ToolSet::State::TaggedSymbol)
-
-        sig do
-          override.returns(T::Array[Cadenya::ToolSet::State::TaggedSymbol])
-        end
-        def self.values
-        end
-      end
-    end
-  end
-end

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -1,23 +0,0 @@
-# typed: strong
-
-module Cadenya
-  module Models
-    module ToolSetAdapter
-      extend Cadenya::Internal::Type::Union
-
-      Variants =
-        T.type_alias do
-          T.any(
-            Cadenya::ToolSetAdapterMCPVariant,
-            Cadenya::ToolSetAdapterHTTPVariant,
-            Cadenya::ToolSetAdapterOpenAPIVariant,
-            Cadenya::ToolSetAdapterBareVariant
-          )
-        end
-
-      sig { override.returns(T::Array[Cadenya::ToolSetAdapter::Variants]) }
-      def self.variants
-      end
-    end
-  end
-end

data/rbi/cadenya/models/tool_set_adapter_bare.rbi

@@ -1,37 +0,0 @@
-# typed: strong
-
-module Cadenya
-  module Models
-    class ToolSetAdapterBare < Cadenya::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Cadenya::ToolSetAdapterBare, Cadenya::Internal::AnyHash)
-        end
-
-      # How long to wait for content to be set before the tool call errors. If unset,
-      # the call waits indefinitely.
-      sig { returns(T.nilable(Integer)) }
-      attr_reader :content_timeout
-
-      sig { params(content_timeout: Integer).void }
-      attr_writer :content_timeout
-
-      # Bare tool sets define tools without an execution adapter. A bare tool call
-      # doesn't fire anything: the objective's workflow pauses and waits for an external
-      # API consumer to set the tool call's content (e.g. human-in-the-loop tools, or a
-      # reverse harness that polls for pending tool calls, executes locally, and reports
-      # results back via SetToolCallContent).
-      sig { params(content_timeout: Integer).returns(T.attached_class) }
-      def self.new(
-        # How long to wait for content to be set before the tool call errors. If unset,
-        # the call waits indefinitely.
-        content_timeout: nil
-      )
-      end
-
-      sig { override.returns({ content_timeout: Integer }) }
-      def to_hash
-      end
-    end
-  end
-end