cadenya 0.1.0

data/rbi/cadenya/models/objectives/objective_feedback.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveFeedback = Objectives::ObjectiveFeedback
+
+    module Objectives
+      class ObjectiveFeedback < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveFeedback,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Cadenya::Objectives::ObjectiveFeedbackData) }
+        attr_reader :data
+
+        sig do
+          params(data: Cadenya::Objectives::ObjectiveFeedbackData::OrHash).void
+        end
+        attr_writer :data
+
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        sig { returns(Cadenya::OperationMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::OperationMetadata::OrHash).void }
+        attr_writer :metadata
+
+        sig { returns(T.nilable(Cadenya::Objectives::ObjectiveFeedbackInfo)) }
+        attr_reader :info
+
+        sig do
+          params(info: Cadenya::Objectives::ObjectiveFeedbackInfo::OrHash).void
+        end
+        attr_writer :info
+
+        # ObjectiveFeedback represents feedback submitted for an objective's execution.
+        # Feedback is used to score agent variations and improve agent performance over
+        # time.
+        sig do
+          params(
+            data: Cadenya::Objectives::ObjectiveFeedbackData::OrHash,
+            metadata: Cadenya::OperationMetadata::OrHash,
+            info: Cadenya::Objectives::ObjectiveFeedbackInfo::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          data:,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          metadata:,
+          info: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Cadenya::Objectives::ObjectiveFeedbackData,
+              metadata: Cadenya::OperationMetadata,
+              info: Cadenya::Objectives::ObjectiveFeedbackInfo
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_feedback_data.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveFeedbackData = Objectives::ObjectiveFeedbackData
+
+    module Objectives
+      class ObjectiveFeedbackData < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveFeedbackData,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # Optional human-readable comment explaining the feedback
+        sig { returns(T.nilable(String)) }
+        attr_reader :comment
+
+        sig { params(comment: String).void }
+        attr_writer :comment
+
+        # A score between -1.0 and 1.0 representing the quality of the objective's
+        # execution. -1.0 is the worst possible score, 0.0 is neutral, and 1.0 is the
+        # best.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :score
+
+        sig { params(score: Float).void }
+        attr_writer :score
+
+        sig { params(comment: String, score: Float).returns(T.attached_class) }
+        def self.new(
+          # Optional human-readable comment explaining the feedback
+          comment: nil,
+          # A score between -1.0 and 1.0 representing the quality of the objective's
+          # execution. -1.0 is the worst possible score, 0.0 is neutral, and 1.0 is the
+          # best.
+          score: nil
+        )
+        end
+
+        sig { override.returns({ comment: String, score: Float }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_feedback_info.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveFeedbackInfo = Objectives::ObjectiveFeedbackInfo
+
+    module Objectives
+      class ObjectiveFeedbackInfo < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveFeedbackInfo,
+              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_variation
+
+        sig { params(agent_variation: Cadenya::BareMetadata::OrHash).void }
+        attr_writer :agent_variation
+
+        # 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
+
+        # 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 :submitted_by
+
+        sig { params(submitted_by: Cadenya::Profile::OrHash).void }
+        attr_writer :submitted_by
+
+        sig do
+          params(
+            agent_variation: Cadenya::BareMetadata::OrHash,
+            objective: Cadenya::BareMetadata::OrHash,
+            submitted_by: Cadenya::Profile::OrHash
+          ).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_variation: 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,
+          # 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.
+          submitted_by: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              agent_variation: Cadenya::BareMetadata,
+              objective: Cadenya::BareMetadata,
+              submitted_by: Cadenya::Profile
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_task.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveTask = Objectives::ObjectiveTask
+
+    module Objectives
+      class ObjectiveTask < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveTask,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Cadenya::Objectives::ObjectiveTaskData) }
+        attr_reader :data
+
+        sig do
+          params(data: Cadenya::Objectives::ObjectiveTaskData::OrHash).void
+        end
+        attr_writer :data
+
+        # 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(Cadenya::BareMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::BareMetadata::OrHash).void }
+        attr_writer :metadata
+
+        # ObjectiveTask represents a task within an objective, typically created and
+        # managed by an AI agent to track progress toward completing the objective.
+        sig do
+          params(
+            data: Cadenya::Objectives::ObjectiveTaskData::OrHash,
+            metadata: Cadenya::BareMetadata::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          data:,
+          # 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.
+          metadata:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Cadenya::Objectives::ObjectiveTaskData,
+              metadata: Cadenya::BareMetadata
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_task_data.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveTaskData = Objectives::ObjectiveTaskData
+
+    module Objectives
+      class ObjectiveTaskData < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveTaskData,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # Whether the task has been completed
+        sig { returns(T::Boolean) }
+        attr_accessor :completed
+
+        # Description of the task to be completed
+        sig { returns(String) }
+        attr_accessor :task
+
+        # The sequential number of this task within the objective (auto-assigned, 1-based)
+        sig { returns(Integer) }
+        attr_accessor :number
+
+        # Timestamp when the task was marked as completed
+        sig { returns(T.nilable(Time)) }
+        attr_reader :completed_at
+
+        sig { params(completed_at: Time).void }
+        attr_writer :completed_at
+
+        sig do
+          params(
+            completed: T::Boolean,
+            number: Integer,
+            task: String,
+            completed_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Whether the task has been completed
+          completed:,
+          # The sequential number of this task within the objective (auto-assigned, 1-based)
+          number:,
+          # Description of the task to be completed
+          task:,
+          # Timestamp when the task was marked as completed
+          completed_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              completed: T::Boolean,
+              number: Integer,
+              task: String,
+              completed_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_tool.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveTool = Objectives::ObjectiveTool
+
+    module Objectives
+      class ObjectiveTool < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveTool,
+              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(Cadenya::BareMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::BareMetadata::OrHash).void }
+        attr_writer :metadata
+
+        # Snapshot of the tool at the time it was assigned to the objective. Because tools
+        # can change over time, snapshots are used to ensure tools don't change
+        # unexpectedly during an objective's lifecycle.
+        sig { returns(T.nilable(Cadenya::ToolSets::Tool)) }
+        attr_reader :snapshot
+
+        sig { params(snapshot: Cadenya::ToolSets::Tool::OrHash).void }
+        attr_writer :snapshot
+
+        # ObjectiveTool represents a tool that was assigned to an objective.
+        sig do
+          params(
+            metadata: Cadenya::BareMetadata::OrHash,
+            snapshot: Cadenya::ToolSets::Tool::OrHash
+          ).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.
+          metadata:,
+          # Snapshot of the tool at the time it was assigned to the objective. Because tools
+          # can change over time, snapshots are used to ensure tools don't change
+          # unexpectedly during an objective's lifecycle.
+          snapshot: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              metadata: Cadenya::BareMetadata,
+              snapshot: Cadenya::ToolSets::Tool
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/objective_tool_call.rbi

@@ -0,0 +1,203 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    ObjectiveToolCall = Objectives::ObjectiveToolCall
+
+    module Objectives
+      class ObjectiveToolCall < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ObjectiveToolCall,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Cadenya::Objectives::ObjectiveToolCallData) }
+        attr_reader :data
+
+        sig do
+          params(data: Cadenya::Objectives::ObjectiveToolCallData::OrHash).void
+        end
+        attr_writer :data
+
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        sig { returns(Cadenya::OperationMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::OperationMetadata::OrHash).void }
+        attr_writer :metadata
+
+        # Current status of the tool call
+        sig do
+          returns(Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol)
+        end
+        attr_accessor :status
+
+        sig { returns(T.nilable(Cadenya::Objectives::ObjectiveToolCallInfo)) }
+        attr_reader :info
+
+        sig do
+          params(info: Cadenya::Objectives::ObjectiveToolCallInfo::OrHash).void
+        end
+        attr_writer :info
+
+        sig do
+          returns(
+            T.nilable(
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :execution_status
+
+        sig do
+          params(
+            execution_status:
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::OrSymbol
+          ).void
+        end
+        attr_writer :execution_status
+
+        # ObjectiveToolCall is a record of a tool call made during an objective's
+        # execution. Tool calls are mutable — their status changes as they are approved,
+        # denied, or executed.
+        sig do
+          params(
+            data: Cadenya::Objectives::ObjectiveToolCallData::OrHash,
+            metadata: Cadenya::OperationMetadata::OrHash,
+            status: Cadenya::Objectives::ObjectiveToolCall::Status::OrSymbol,
+            execution_status:
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::OrSymbol,
+            info: Cadenya::Objectives::ObjectiveToolCallInfo::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          data:,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          metadata:,
+          # Current status of the tool call
+          status:,
+          execution_status: nil,
+          info: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Cadenya::Objectives::ObjectiveToolCallData,
+              metadata: Cadenya::OperationMetadata,
+              status:
+                Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol,
+              execution_status:
+                Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol,
+              info: Cadenya::Objectives::ObjectiveToolCallInfo
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Current status of the tool call
+        module Status
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Cadenya::Objectives::ObjectiveToolCall::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_CALL_STATUS_UNSPECIFIED,
+              Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_AUTO_APPROVED =
+            T.let(
+              :TOOL_CALL_STATUS_AUTO_APPROVED,
+              Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_WAITING_FOR_APPROVAL =
+            T.let(
+              :TOOL_CALL_STATUS_WAITING_FOR_APPROVAL,
+              Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_APPROVED =
+            T.let(
+              :TOOL_CALL_STATUS_APPROVED,
+              Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+            )
+          TOOL_CALL_STATUS_DENIED =
+            T.let(
+              :TOOL_CALL_STATUS_DENIED,
+              Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::Objectives::ObjectiveToolCall::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module ExecutionStatus
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL_EXECUTION_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_UNSPECIFIED,
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_PENDING =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_PENDING,
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_RUNNING =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_RUNNING,
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_COMPLETED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_COMPLETED,
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_ERRORED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_ERRORED,
+              Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::Objectives::ObjectiveToolCall::ExecutionStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end