cadenya 0.1.0

data/rbi/cadenya/models/objectives/objective_tool_call_data.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveToolCallData = Objectives::ObjectiveToolCallData
+
+    module Objectives
+      class ObjectiveToolCallData < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveToolCallData,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # 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(Cadenya::CallableTool) }
+        attr_reader :callable
+
+        sig { params(callable: Cadenya::CallableTool::OrHash).void }
+        attr_writer :callable
+
+        # 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
+
+        # A memo supplied by the reviewer when denying the tool call
+        sig { returns(T.nilable(String)) }
+        attr_reader :memo
+
+        sig { params(memo: String).void }
+        attr_writer :memo
+
+        # The result content returned by the tool after execution
+        sig { returns(T.nilable(String)) }
+        attr_reader :result
+
+        sig { params(result: String).void }
+        attr_writer :result
+
+        # A profile identifies a user or non-human principal (such as an API key) at the
+        # account level. Profiles are account-scoped and can be granted access to multiple
+        # workspaces.
+        sig { returns(T.nilable(Cadenya::Profile)) }
+        attr_reader :status_changed_by
+
+        sig { params(status_changed_by: Cadenya::Profile::OrHash).void }
+        attr_writer :status_changed_by
+
+        sig do
+          params(
+            callable: Cadenya::CallableTool::OrHash,
+            arguments: T::Hash[Symbol, T.anything],
+            memo: String,
+            result: String,
+            status_changed_by: Cadenya::Profile::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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).
+          callable:,
+          # The arguments passed to the tool
+          arguments: nil,
+          # A memo supplied by the reviewer when denying the tool call
+          memo: nil,
+          # The result content returned by the tool after execution
+          result: nil,
+          # A profile identifies a user or non-human principal (such as an API key) at the
+          # account level. Profiles are account-scoped and can be granted access to multiple
+          # workspaces.
+          status_changed_by: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              callable: Cadenya::CallableTool,
+              arguments: T::Hash[Symbol, T.anything],
+              memo: String,
+              result: String,
+              status_changed_by: Cadenya::Profile
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_tool_call_info.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveToolCallInfo = Objectives::ObjectiveToolCallInfo
+
+    module Objectives
+      class ObjectiveToolCallInfo < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveToolCallInfo,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # A profile identifies a user or non-human principal (such as an API key) at the
+        # account level. Profiles are account-scoped and can be granted access to multiple
+        # workspaces.
+        sig { returns(T.nilable(Cadenya::Profile)) }
+        attr_reader :created_by
+
+        sig { params(created_by: Cadenya::Profile::OrHash).void }
+        attr_writer :created_by
+
+        # 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 do
+          params(
+            created_by: Cadenya::Profile::OrHash,
+            objective: Cadenya::OperationMetadata::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A profile identifies a user or non-human principal (such as an API key) at the
+          # account level. Profiles are account-scoped and can be granted access to multiple
+          # workspaces.
+          created_by: nil,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          objective: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              created_by: Cadenya::Profile,
+              objective: Cadenya::OperationMetadata
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/task_list_params.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class TaskListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::TaskListParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :objective_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
+
+        # Sort order for results
+        sig { returns(T.nilable(String)) }
+        attr_reader :sort_order
+
+        sig { params(sort_order: String).void }
+        attr_writer :sort_order
+
+        sig do
+          params(
+            workspace_id: String,
+            objective_id: String,
+            cursor: String,
+            limit: Integer,
+            sort_order: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          objective_id:,
+          # Pagination cursor from previous response
+          cursor: nil,
+          # Maximum number of results to return
+          limit: nil,
+          # Sort order for results
+          sort_order: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              objective_id: String,
+              cursor: String,
+              limit: Integer,
+              sort_order: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/task_retrieve_params.rbi

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

data/rbi/cadenya/models/objectives/tool_call_approve_params.rbi

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

data/rbi/cadenya/models/objectives/tool_call_deny_params.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class ToolCallDenyParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ToolCallDenyParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :objective_id
+
+        sig { returns(String) }
+        attr_accessor :tool_call_id
+
+        # A memo to associate to the tool call denial. Use a memo to steer the LLM to a
+        # different decision or usage of the tool.
+        sig { returns(T.nilable(String)) }
+        attr_reader :memo
+
+        sig { params(memo: String).void }
+        attr_writer :memo
+
+        sig do
+          params(
+            workspace_id: String,
+            objective_id: String,
+            tool_call_id: String,
+            memo: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          objective_id:,
+          tool_call_id:,
+          # A memo to associate to the tool call denial. Use a memo to steer the LLM to a
+          # different decision or usage of the tool.
+          memo: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              objective_id: String,
+              tool_call_id: String,
+              memo: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/tool_call_list_params.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class ToolCallListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ToolCallListParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :objective_id
+
+        # Pagination cursor from previous response
+        sig { returns(T.nilable(String)) }
+        attr_reader :cursor
+
+        sig { params(cursor: String).void }
+        attr_writer :cursor
+
+        # When set to true you may use more of your alloted API rate-limit
+        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
+
+        # Filter by tool call status
+        sig do
+          returns(
+            T.nilable(Cadenya::Objectives::ToolCallListParams::Status::OrSymbol)
+          )
+        end
+        attr_reader :status
+
+        sig do
+          params(
+            status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol
+          ).void
+        end
+        attr_writer :status
+
+        sig do
+          params(
+            workspace_id: String,
+            objective_id: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          objective_id:,
+          # Pagination cursor from previous response
+          cursor: nil,
+          # When set to true you may use more of your alloted API rate-limit
+          include_info: nil,
+          # Maximum number of results to return
+          limit: nil,
+          # Filter by tool call status
+          status: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              objective_id: String,
+              cursor: String,
+              include_info: T::Boolean,
+              limit: Integer,
+              status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Filter by tool call status
+        module Status
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Cadenya::Objectives::ToolCallListParams::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_CALL_STATUS_UNSPECIFIED,
+              Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_AUTO_APPROVED =
+            T.let(
+              :TOOL_CALL_STATUS_AUTO_APPROVED,
+              Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_WAITING_FOR_APPROVAL =
+            T.let(
+              :TOOL_CALL_STATUS_WAITING_FOR_APPROVAL,
+              Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_APPROVED =
+            T.let(
+              :TOOL_CALL_STATUS_APPROVED,
+              Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_DENIED =
+            T.let(
+              :TOOL_CALL_STATUS_DENIED,
+              Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::Objectives::ToolCallListParams::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/tool_list_params.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class ToolListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ToolListParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :objective_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,
+            objective_id: String,
+            cursor: String,
+            limit: Integer,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          objective_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,
+              objective_id: String,
+              cursor: String,
+              limit: Integer,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end