cadenya 0.1.0

data/rbi/cadenya/models/tool_sets/tool_retrieve_params.rbi

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

data/rbi/cadenya/models/tool_sets/tool_spec.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolSpec < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ToolSpec, Cadenya::Internal::AnyHash)
+          end
+
+        # 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(Cadenya::ToolSets::ToolSpecConfig) }
+        attr_reader :config
+
+        sig { params(config: Cadenya::ToolSets::ToolSpecConfig::OrHash).void }
+        attr_writer :config
+
+        sig { returns(String) }
+        attr_accessor :description
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :parameters
+
+        sig { returns(Cadenya::ToolSets::ToolSpec::Status::OrSymbol) }
+        attr_accessor :status
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :requires_approval
+
+        sig { params(requires_approval: T::Boolean).void }
+        attr_writer :requires_approval
+
+        sig do
+          params(
+            config: Cadenya::ToolSets::ToolSpecConfig::OrHash,
+            description: String,
+            parameters: T::Hash[Symbol, T.anything],
+            status: Cadenya::ToolSets::ToolSpec::Status::OrSymbol,
+            requires_approval: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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:,
+          description:,
+          parameters:,
+          status:,
+          requires_approval: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              config: Cadenya::ToolSets::ToolSpecConfig,
+              description: String,
+              parameters: T::Hash[Symbol, T.anything],
+              status: Cadenya::ToolSets::ToolSpec::Status::OrSymbol,
+              requires_approval: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Status
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Cadenya::ToolSets::ToolSpec::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_STATUS_UNSPECIFIED,
+              Cadenya::ToolSets::ToolSpec::Status::TaggedSymbol
+            )
+          TOOL_STATUS_AVAILABLE =
+            T.let(
+              :TOOL_STATUS_AVAILABLE,
+              Cadenya::ToolSets::ToolSpec::Status::TaggedSymbol
+            )
+          TOOL_STATUS_OMITTED =
+            T.let(
+              :TOOL_STATUS_OMITTED,
+              Cadenya::ToolSets::ToolSpec::Status::TaggedSymbol
+            )
+          TOOL_STATUS_ARCHIVED =
+            T.let(
+              :TOOL_STATUS_ARCHIVED,
+              Cadenya::ToolSets::ToolSpec::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Cadenya::ToolSets::ToolSpec::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_spec_config.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolSpecConfig < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ToolSpecConfig, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(Cadenya::ToolSets::ConfigHTTP)) }
+        attr_reader :http
+
+        sig { params(http: Cadenya::ToolSets::ConfigHTTP::OrHash).void }
+        attr_writer :http
+
+        sig { returns(T.nilable(Cadenya::ToolSets::ConfigMcp)) }
+        attr_reader :mcp
+
+        sig { params(mcp: Cadenya::ToolSets::ConfigMcp::OrHash).void }
+        attr_writer :mcp
+
+        # 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 do
+          params(
+            http: Cadenya::ToolSets::ConfigHTTP::OrHash,
+            mcp: Cadenya::ToolSets::ConfigMcp::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(http: nil, mcp: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              http: Cadenya::ToolSets::ConfigHTTP,
+              mcp: Cadenya::ToolSets::ConfigMcp
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_update_params.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolUpdateParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::ToolSets::ToolUpdateParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :tool_set_id
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        # UpdateResourceMetadata contains the user-provided fields for updating 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(T.nilable(Cadenya::UpdateResourceMetadata)) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::UpdateResourceMetadata::OrHash).void }
+        attr_writer :metadata
+
+        sig { returns(T.nilable(Cadenya::ToolSets::ToolSpec)) }
+        attr_reader :spec
+
+        sig { params(spec: Cadenya::ToolSets::ToolSpec::OrHash).void }
+        attr_writer :spec
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :update_mask
+
+        sig { params(update_mask: String).void }
+        attr_writer :update_mask
+
+        sig do
+          params(
+            workspace_id: String,
+            tool_set_id: String,
+            id: String,
+            metadata: Cadenya::UpdateResourceMetadata::OrHash,
+            spec: Cadenya::ToolSets::ToolSpec::OrHash,
+            update_mask: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          tool_set_id:,
+          id:,
+          # UpdateResourceMetadata contains the user-provided fields for updating 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: nil,
+          spec: nil,
+          update_mask: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              tool_set_id: String,
+              id: String,
+              metadata: Cadenya::UpdateResourceMetadata,
+              spec: Cadenya::ToolSets::ToolSpec,
+              update_mask: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/unsafe_unwrap_webhook_event.rbi

@@ -0,0 +1,207 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class UnsafeUnwrapWebhookEvent < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::UnsafeUnwrapWebhookEvent, Cadenya::Internal::AnyHash)
+        end
+
+      # The webhook data payload with flat top-level keys for agent, variation,
+      # objective, and event.
+      sig { returns(Cadenya::UnsafeUnwrapWebhookEvent::Data) }
+      attr_reader :data
+
+      sig { params(data: Cadenya::UnsafeUnwrapWebhookEvent::Data::OrHash).void }
+      attr_writer :data
+
+      sig { returns(Time) }
+      attr_accessor :timestamp
+
+      # The event type, prefixed with objective_event. (e.g.,
+      # objective_event.tool_result)
+      sig { returns(String) }
+      attr_accessor :type
+
+      # The envelope for an objective event webhook delivery. Contains timestamp, event
+      # type, and the webhook data payload.
+      sig do
+        params(
+          data: Cadenya::UnsafeUnwrapWebhookEvent::Data::OrHash,
+          timestamp: Time,
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The webhook data payload with flat top-level keys for agent, variation,
+        # objective, and event.
+        data:,
+        timestamp:,
+        # The event type, prefixed with objective_event. (e.g.,
+        # objective_event.tool_result)
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Cadenya::UnsafeUnwrapWebhookEvent::Data,
+            timestamp: Time,
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::UnsafeUnwrapWebhookEvent::Data,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :agent
+
+        sig { params(agent: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :agent
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :agent_variation
+
+        sig { params(agent_variation: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :agent_variation
+
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        sig { returns(Cadenya::OperationMetadata) }
+        attr_reader :objective
+
+        sig { params(objective: Cadenya::OperationMetadata::OrHash).void }
+        attr_writer :objective
+
+        sig { returns(Cadenya::UnsafeUnwrapWebhookEvent::Data::ObjectiveEvent) }
+        attr_reader :objective_event
+
+        sig do
+          params(
+            objective_event:
+              Cadenya::UnsafeUnwrapWebhookEvent::Data::ObjectiveEvent::OrHash
+          ).void
+        end
+        attr_writer :objective_event
+
+        # The webhook data payload with flat top-level keys for agent, variation,
+        # objective, and event.
+        sig do
+          params(
+            agent: Cadenya::ResourceMetadata::OrHash,
+            agent_variation: Cadenya::ResourceMetadata::OrHash,
+            objective: Cadenya::OperationMetadata::OrHash,
+            objective_event:
+              Cadenya::UnsafeUnwrapWebhookEvent::Data::ObjectiveEvent::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          agent:,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          agent_variation:,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          objective:,
+          objective_event:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              agent: Cadenya::ResourceMetadata,
+              agent_variation: Cadenya::ResourceMetadata,
+              objective: Cadenya::OperationMetadata,
+              objective_event:
+                Cadenya::UnsafeUnwrapWebhookEvent::Data::ObjectiveEvent
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ObjectiveEvent < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::UnsafeUnwrapWebhookEvent::Data::ObjectiveEvent,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Cadenya::ObjectiveEventData) }
+          attr_reader :data
+
+          sig { params(data: Cadenya::ObjectiveEventData::OrHash).void }
+          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(String)) }
+          attr_reader :context_window_id
+
+          sig { params(context_window_id: String).void }
+          attr_writer :context_window_id
+
+          sig { returns(T.nilable(Cadenya::ObjectiveEventInfo)) }
+          attr_reader :info
+
+          sig { params(info: Cadenya::ObjectiveEventInfo::OrHash).void }
+          attr_writer :info
+
+          sig do
+            params(
+              data: Cadenya::ObjectiveEventData::OrHash,
+              metadata: Cadenya::OperationMetadata::OrHash,
+              context_window_id: String,
+              info: Cadenya::ObjectiveEventInfo::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            data:,
+            # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+            # runs)
+            metadata:,
+            context_window_id: nil,
+            info: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                data: Cadenya::ObjectiveEventData,
+                metadata: Cadenya::OperationMetadata,
+                context_window_id: String,
+                info: Cadenya::ObjectiveEventInfo
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/unwrap_webhook_event.rbi

@@ -0,0 +1,203 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class UnwrapWebhookEvent < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::UnwrapWebhookEvent, Cadenya::Internal::AnyHash)
+        end
+
+      # The webhook data payload with flat top-level keys for agent, variation,
+      # objective, and event.
+      sig { returns(Cadenya::UnwrapWebhookEvent::Data) }
+      attr_reader :data
+
+      sig { params(data: Cadenya::UnwrapWebhookEvent::Data::OrHash).void }
+      attr_writer :data
+
+      sig { returns(Time) }
+      attr_accessor :timestamp
+
+      # The event type, prefixed with objective_event. (e.g.,
+      # objective_event.tool_result)
+      sig { returns(String) }
+      attr_accessor :type
+
+      # The envelope for an objective event webhook delivery. Contains timestamp, event
+      # type, and the webhook data payload.
+      sig do
+        params(
+          data: Cadenya::UnwrapWebhookEvent::Data::OrHash,
+          timestamp: Time,
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The webhook data payload with flat top-level keys for agent, variation,
+        # objective, and event.
+        data:,
+        timestamp:,
+        # The event type, prefixed with objective_event. (e.g.,
+        # objective_event.tool_result)
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Cadenya::UnwrapWebhookEvent::Data,
+            timestamp: Time,
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::UnwrapWebhookEvent::Data, Cadenya::Internal::AnyHash)
+          end
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :agent
+
+        sig { params(agent: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :agent
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :agent_variation
+
+        sig { params(agent_variation: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :agent_variation
+
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        sig { returns(Cadenya::OperationMetadata) }
+        attr_reader :objective
+
+        sig { params(objective: Cadenya::OperationMetadata::OrHash).void }
+        attr_writer :objective
+
+        sig { returns(Cadenya::UnwrapWebhookEvent::Data::ObjectiveEvent) }
+        attr_reader :objective_event
+
+        sig do
+          params(
+            objective_event:
+              Cadenya::UnwrapWebhookEvent::Data::ObjectiveEvent::OrHash
+          ).void
+        end
+        attr_writer :objective_event
+
+        # The webhook data payload with flat top-level keys for agent, variation,
+        # objective, and event.
+        sig do
+          params(
+            agent: Cadenya::ResourceMetadata::OrHash,
+            agent_variation: Cadenya::ResourceMetadata::OrHash,
+            objective: Cadenya::OperationMetadata::OrHash,
+            objective_event:
+              Cadenya::UnwrapWebhookEvent::Data::ObjectiveEvent::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          agent:,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          agent_variation:,
+          # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+          # runs)
+          objective:,
+          objective_event:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              agent: Cadenya::ResourceMetadata,
+              agent_variation: Cadenya::ResourceMetadata,
+              objective: Cadenya::OperationMetadata,
+              objective_event: Cadenya::UnwrapWebhookEvent::Data::ObjectiveEvent
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ObjectiveEvent < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::UnwrapWebhookEvent::Data::ObjectiveEvent,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Cadenya::ObjectiveEventData) }
+          attr_reader :data
+
+          sig { params(data: Cadenya::ObjectiveEventData::OrHash).void }
+          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(String)) }
+          attr_reader :context_window_id
+
+          sig { params(context_window_id: String).void }
+          attr_writer :context_window_id
+
+          sig { returns(T.nilable(Cadenya::ObjectiveEventInfo)) }
+          attr_reader :info
+
+          sig { params(info: Cadenya::ObjectiveEventInfo::OrHash).void }
+          attr_writer :info
+
+          sig do
+            params(
+              data: Cadenya::ObjectiveEventData::OrHash,
+              metadata: Cadenya::OperationMetadata::OrHash,
+              context_window_id: String,
+              info: Cadenya::ObjectiveEventInfo::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            data:,
+            # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+            # runs)
+            metadata:,
+            context_window_id: nil,
+            info: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                data: Cadenya::ObjectiveEventData,
+                metadata: Cadenya::OperationMetadata,
+                context_window_id: String,
+                info: Cadenya::ObjectiveEventInfo
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end