cadenya 0.1.0

data/lib/cadenya/resources/objectives/feedback.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class Objectives
+      class Feedback
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::Objectives::FeedbackCreateParams} for more details.
+        #
+        # Submits feedback for an objective's execution. Feedback scores are used by the
+        # agent variation scoring system to evaluate and rank variation performance.
+        #
+        # @overload create(objective_id, workspace_id:, data:, metadata:, request_options: {})
+        #
+        # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param data [Cadenya::Models::Objectives::ObjectiveFeedbackData] Body param
+        #
+        # @param metadata [Cadenya::Models::CreateOperationMetadata] Body param: CreateOperationMetadata contains the user-provided fields for creati
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::Objectives::ObjectiveFeedback]
+        #
+        # @see Cadenya::Models::Objectives::FeedbackCreateParams
+        def create(objective_id, params)
+          parsed, options = Cadenya::Objectives::FeedbackCreateParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :post,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/feedback", workspace_id, objective_id],
+            body: parsed,
+            model: Cadenya::Objectives::ObjectiveFeedback,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::Objectives::FeedbackListParams} for more details.
+        #
+        # Lists all feedback submitted for an objective
+        #
+        # @overload list(objective_id, workspace_id:, cursor: nil, limit: nil, request_options: {})
+        #
+        # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param cursor [String] Query param: Pagination cursor from previous response
+        #
+        # @param limit [Integer] Query param: Maximum number of results to return
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Objectives::ObjectiveFeedback>]
+        #
+        # @see Cadenya::Models::Objectives::FeedbackListParams
+        def list(objective_id, params)
+          parsed, options = Cadenya::Objectives::FeedbackListParams.dump_request(params)
+          query = Cadenya::Internal::Util.encode_query_params(parsed)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/feedback", workspace_id, objective_id],
+            query: query,
+            page: Cadenya::Internal::CursorPagination,
+            model: Cadenya::Objectives::ObjectiveFeedback,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Cadenya::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/cadenya/resources/objectives/tasks.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class Objectives
+      class Tasks
+        # Retrieves a task by ID from an objective
+        #
+        # @overload retrieve(id, workspace_id:, objective_id:, request_options: {})
+        #
+        # @param id [String] Task ID
+        #
+        # @param workspace_id [String]
+        #
+        # @param objective_id [String] The ID of the objective. Supports "external_id:" prefix for external IDs.
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::Objectives::ObjectiveTask]
+        #
+        # @see Cadenya::Models::Objectives::TaskRetrieveParams
+        def retrieve(id, params)
+          parsed, options = Cadenya::Objectives::TaskRetrieveParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          objective_id =
+            parsed.delete(:objective_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/tasks/%3$s", workspace_id, objective_id, id],
+            model: Cadenya::Objectives::ObjectiveTask,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::Objectives::TaskListParams} for more details.
+        #
+        # Lists all tasks for an objective
+        #
+        # @overload list(objective_id, workspace_id:, cursor: nil, limit: nil, sort_order: nil, request_options: {})
+        #
+        # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param cursor [String] Query param: Pagination cursor from previous response
+        #
+        # @param limit [Integer] Query param: Maximum number of results to return
+        #
+        # @param sort_order [String] Query param: Sort order for results
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Objectives::ObjectiveTask>]
+        #
+        # @see Cadenya::Models::Objectives::TaskListParams
+        def list(objective_id, params)
+          parsed, options = Cadenya::Objectives::TaskListParams.dump_request(params)
+          query = Cadenya::Internal::Util.encode_query_params(parsed)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/tasks", workspace_id, objective_id],
+            query: query.transform_keys(sort_order: "sortOrder"),
+            page: Cadenya::Internal::CursorPagination,
+            model: Cadenya::Objectives::ObjectiveTask,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Cadenya::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/cadenya/resources/objectives/tool_calls.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class Objectives
+      class ToolCalls
+        # Lists all tool calls for an objective
+        #
+        # @overload list(objective_id, workspace_id:, cursor: nil, include_info: nil, limit: nil, status: nil, request_options: {})
+        #
+        # @param objective_id [String] Path param: The objective ID to return tool calls for
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param cursor [String] Query param: Pagination cursor from previous response
+        #
+        # @param include_info [Boolean] Query param: When set to true you may use more of your alloted API rate-limit
+        #
+        # @param limit [Integer] Query param: Maximum number of results to return
+        #
+        # @param status [Symbol, Cadenya::Models::Objectives::ToolCallListParams::Status] Query param: Filter by tool call status
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Objectives::ObjectiveToolCall>]
+        #
+        # @see Cadenya::Models::Objectives::ToolCallListParams
+        def list(objective_id, params)
+          parsed, options = Cadenya::Objectives::ToolCallListParams.dump_request(params)
+          query = Cadenya::Internal::Util.encode_query_params(parsed)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/tool_calls", workspace_id, objective_id],
+            query: query.transform_keys(include_info: "includeInfo"),
+            page: Cadenya::Internal::CursorPagination,
+            model: Cadenya::Objectives::ObjectiveToolCall,
+            options: options
+          )
+        end
+
+        # When an agent attempts to use a tool that requires approval, use this endpoint
+        # to mark it as approved.
+        #
+        # @overload approve(tool_call_id, workspace_id:, objective_id:, request_options: {})
+        #
+        # @param tool_call_id [String] The ID of the tool call to approve
+        #
+        # @param workspace_id [String]
+        #
+        # @param objective_id [String] The ID of the objective. Supports "external_id:" prefix for external IDs.
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::Objectives::ObjectiveToolCall]
+        #
+        # @see Cadenya::Models::Objectives::ToolCallApproveParams
+        def approve(tool_call_id, params)
+          parsed, options = Cadenya::Objectives::ToolCallApproveParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          objective_id =
+            parsed.delete(:objective_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :put,
+            path: [
+              "v1/workspaces/%1$s/objectives/%2$s/tool_calls/%3$s/approve",
+              workspace_id,
+              objective_id,
+              tool_call_id
+            ],
+            model: Cadenya::Objectives::ObjectiveToolCall,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::Objectives::ToolCallDenyParams} for more details.
+        #
+        # When an agent attempts to use a tool that requires approval, use this endpoint
+        # to mark it as denied. Use a memo to steer the LLM to a different decision or
+        # usage of the tool.
+        #
+        # @overload deny(tool_call_id, workspace_id:, objective_id:, memo: nil, request_options: {})
+        #
+        # @param tool_call_id [String] Path param: The ID of the tool call to deny
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+        #
+        # @param memo [String] Body param: A memo to associate to the tool call denial. Use a memo to steer the
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::Objectives::ObjectiveToolCall]
+        #
+        # @see Cadenya::Models::Objectives::ToolCallDenyParams
+        def deny(tool_call_id, params)
+          parsed, options = Cadenya::Objectives::ToolCallDenyParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          objective_id =
+            parsed.delete(:objective_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :put,
+            path: [
+              "v1/workspaces/%1$s/objectives/%2$s/tool_calls/%3$s/deny",
+              workspace_id,
+              objective_id,
+              tool_call_id
+            ],
+            body: parsed,
+            model: Cadenya::Objectives::ObjectiveToolCall,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Cadenya::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/cadenya/resources/objectives/tools.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class Objectives
+      class Tools
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::Objectives::ToolListParams} for more details.
+        #
+        # Lists all tools that were assigned to an objective
+        #
+        # @overload list(objective_id, workspace_id:, cursor: nil, limit: nil, request_options: {})
+        #
+        # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param cursor [String] Query param: Pagination cursor from previous response
+        #
+        # @param limit [Integer] Query param: Maximum number of results to return
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Objectives::ObjectiveTool>]
+        #
+        # @see Cadenya::Models::Objectives::ToolListParams
+        def list(objective_id, params)
+          parsed, options = Cadenya::Objectives::ToolListParams.dump_request(params)
+          query = Cadenya::Internal::Util.encode_query_params(parsed)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/objectives/%2$s/tools", workspace_id, objective_id],
+            query: query,
+            page: Cadenya::Internal::CursorPagination,
+            model: Cadenya::Objectives::ObjectiveTool,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Cadenya::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/cadenya/resources/objectives.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class Objectives
+      # @return [Cadenya::Resources::Objectives::Tools]
+      attr_reader :tools
+
+      # @return [Cadenya::Resources::Objectives::ToolCalls]
+      attr_reader :tool_calls
+
+      # @return [Cadenya::Resources::Objectives::Tasks]
+      attr_reader :tasks
+
+      # @return [Cadenya::Resources::Objectives::Feedback]
+      attr_reader :feedback
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ObjectiveCreateParams} for more details.
+      #
+      # Creates a new objective in the workspace
+      #
+      # @overload create(workspace_id, agent_id:, data:, metadata:, variation_id: nil, request_options: {})
+      #
+      # @param workspace_id [String]
+      #
+      # @param agent_id [String]
+      #
+      # @param data [Cadenya::Models::ObjectiveData]
+      #
+      # @param metadata [Cadenya::Models::CreateOperationMetadata] CreateOperationMetadata contains the user-provided fields for creating
+      #
+      # @param variation_id [String] Optional explicit variation selection. Overrides the agent's variation_selection
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::Objective]
+      #
+      # @see Cadenya::Models::ObjectiveCreateParams
+      def create(workspace_id, params)
+        parsed, options = Cadenya::ObjectiveCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/objectives", workspace_id],
+          body: parsed,
+          model: Cadenya::Objective,
+          options: options
+        )
+      end
+
+      # Retrieves an objective by ID from the workspace
+      #
+      # @overload retrieve(id, workspace_id:, request_options: {})
+      #
+      # @param id [String]
+      # @param workspace_id [String]
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::Objective]
+      #
+      # @see Cadenya::Models::ObjectiveRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Cadenya::ObjectiveRetrieveParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/objectives/%2$s", workspace_id, id],
+          model: Cadenya::Objective,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ObjectiveListParams} for more details.
+      #
+      # Lists all objectives in the workspace
+      #
+      # @overload list(workspace_id, agent_id: nil, agent_schedule_id: nil, cursor: nil, include_info: nil, limit: nil, parent_objective_id: nil, profile_id: nil, sort_order: nil, state: nil, request_options: {})
+      #
+      # @param workspace_id [String]
+      #
+      # @param agent_id [String] Agent ID for filtering
+      #
+      # @param agent_schedule_id [String] Filter to objectives produced by a specific AgentSchedule. Accepts
+      #
+      # @param cursor [String] Pagination cursor from previous response
+      #
+      # @param include_info [Boolean] When set to true you may use more of your alloted API rate-limit
+      #
+      # @param limit [Integer] Maximum number of results to return
+      #
+      # @param parent_objective_id [String] Optional filters
+      #
+      # @param profile_id [String]
+      #
+      # @param sort_order [String] Sort order for results (asc or desc by creation time)
+      #
+      # @param state [Symbol, Cadenya::Models::ObjectiveListParams::State] Filter by state
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Objective>]
+      #
+      # @see Cadenya::Models::ObjectiveListParams
+      def list(workspace_id, params = {})
+        parsed, options = Cadenya::ObjectiveListParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/objectives", workspace_id],
+          query: query.transform_keys(
+            agent_id: "agentId",
+            agent_schedule_id: "agentScheduleId",
+            include_info: "includeInfo",
+            parent_objective_id: "parentObjectiveId",
+            profile_id: "profileId",
+            sort_order: "sortOrder"
+          ),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::Objective,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ObjectiveCancelParams} for more details.
+      #
+      # Cancels a running or pending objective. The objective's state will be set to
+      # STATE_CANCELLED.
+      #
+      # @overload cancel(objective_id, workspace_id:, reason: nil, request_options: {})
+      #
+      # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param reason [String] Body param: Optional reason for cancellation
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::Objective]
+      #
+      # @see Cadenya::Models::ObjectiveCancelParams
+      def cancel(objective_id, params)
+        parsed, options = Cadenya::ObjectiveCancelParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/cancel", workspace_id, objective_id],
+          body: parsed,
+          model: Cadenya::Objective,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ObjectiveCompactParams} for more details.
+      #
+      # Triggers compaction on a running objective. Optionally override the variation's
+      # compaction config.
+      #
+      # @overload compact(objective_id, workspace_id:, compaction_config: nil, request_options: {})
+      #
+      # @param objective_id [String] Path param: The ID of the objective. Supports "external_id:" prefix for external
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param compaction_config [Cadenya::Models::Agents::AgentVariationSpecCompactionConfig] Body param: CompactionConfig defines how context window compaction behaves for o
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::ObjectiveCompactResponse]
+      #
+      # @see Cadenya::Models::ObjectiveCompactParams
+      def compact(objective_id, params)
+        parsed, options = Cadenya::ObjectiveCompactParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/compact", workspace_id, objective_id],
+          body: parsed,
+          model: Cadenya::Models::ObjectiveCompactResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::ObjectiveContinueParams} for more details.
+      #
+      # Continues an objective that has completed
+      #
+      # @overload continue(objective_id, workspace_id:, enqueue: nil, message: nil, secrets: nil, request_options: {})
+      #
+      # @param objective_id [String] Path param: The ID of the objective. If you have assigned an external ID to the
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param enqueue [Boolean] Body param: When set to true, the message will be enqueued for when the agent lo
+      #
+      # @param message [String] Body param: The message to continue an objective that has completed (or you are
+      #
+      # @param secrets [Array<Cadenya::Models::ObjectiveContinueParams::Secret>] Body param: Secrets that should be included with the message. Helpful for when y
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::ObjectiveContinueResponse]
+      #
+      # @see Cadenya::Models::ObjectiveContinueParams
+      def continue(objective_id, params)
+        parsed, options = Cadenya::ObjectiveContinueParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/continue", workspace_id, objective_id],
+          body: parsed,
+          model: Cadenya::Models::ObjectiveContinueResponse,
+          options: options
+        )
+      end
+
+      # Read-only list of the last five windows of execution for this objective, ordered
+      # by most recent first
+      #
+      # @overload list_context_windows(objective_id, workspace_id:, cursor: nil, include_info: nil, limit: nil, request_options: {})
+      #
+      # @param objective_id [String] Path param: The objective ID to return windows for
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param cursor [String] Query param: Pagination cursor from previous response
+      #
+      # @param include_info [Boolean] Query param: When set to true you may use more of your alloted API rate-limit
+      #
+      # @param limit [Integer] Query param: Maximum number of results to return
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::ObjectiveContextWindow>]
+      #
+      # @see Cadenya::Models::ObjectiveListContextWindowsParams
+      def list_context_windows(objective_id, params)
+        parsed, options = Cadenya::ObjectiveListContextWindowsParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/context_windows", workspace_id, objective_id],
+          query: query.transform_keys(include_info: "includeInfo"),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::ObjectiveContextWindow,
+          options: options
+        )
+      end
+
+      # Lists all events for an objective
+      #
+      # @overload list_events(objective_id, workspace_id:, cursor: nil, include_info: nil, limit: nil, sort_order: nil, window_id: nil, request_options: {})
+      #
+      # @param objective_id [String] Path param: Objective ID for filtering
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param cursor [String] Query param: Pagination cursor from previous response
+      #
+      # @param include_info [Boolean] Query param: When set to true you may use more of your alloted API rate-limit
+      #
+      # @param limit [Integer] Query param: Maximum number of results to return
+      #
+      # @param sort_order [String] Query param: Sort order for results (asc or desc by creation time)
+      #
+      # @param window_id [String] Query param: Optional context window ID to filter events by
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::ObjectiveListEventsResponse>]
+      #
+      # @see Cadenya::Models::ObjectiveListEventsParams
+      def list_events(objective_id, params)
+        parsed, options = Cadenya::ObjectiveListEventsParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/objectives/%2$s/events", workspace_id, objective_id],
+          query: query.transform_keys(
+            include_info: "includeInfo",
+            sort_order: "sortOrder",
+            window_id: "windowId"
+          ),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::Models::ObjectiveListEventsResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+        @tools = Cadenya::Resources::Objectives::Tools.new(client: client)
+        @tool_calls = Cadenya::Resources::Objectives::ToolCalls.new(client: client)
+        @tasks = Cadenya::Resources::Objectives::Tasks.new(client: client)
+        @feedback = Cadenya::Resources::Objectives::Feedback.new(client: client)
+      end
+    end
+  end
+end