cadenya 0.1.0

data/rbi/cadenya/models/bulk_workspace_resources/result_list_params.rbi

@@ -0,0 +1,175 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module BulkWorkspaceResources
+      class ResultListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::BulkWorkspaceResources::ResultListParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :bulk_workspace_apply_id
+
+        # Filter by action.
+        sig do
+          returns(
+            T.nilable(
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::OrSymbol
+            )
+          )
+        end
+        attr_reader :action
+
+        sig do
+          params(
+            action:
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::OrSymbol
+          ).void
+        end
+        attr_writer :action
+
+        # 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 (asc or desc by creation time)
+        sig { returns(T.nilable(String)) }
+        attr_reader :sort_order
+
+        sig { params(sort_order: String).void }
+        attr_writer :sort_order
+
+        # Filter by data.type discriminator (e.g., "toolSet", "memoryEntry").
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { params(type: String).void }
+        attr_writer :type
+
+        sig do
+          params(
+            workspace_id: String,
+            bulk_workspace_apply_id: String,
+            action:
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::OrSymbol,
+            cursor: String,
+            limit: Integer,
+            sort_order: String,
+            type: String,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          bulk_workspace_apply_id:,
+          # Filter by action.
+          action: nil,
+          # Pagination cursor from previous response
+          cursor: nil,
+          # Maximum number of results to return
+          limit: nil,
+          # Sort order for results (asc or desc by creation time)
+          sort_order: nil,
+          # Filter by data.type discriminator (e.g., "toolSet", "memoryEntry").
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              bulk_workspace_apply_id: String,
+              action:
+                Cadenya::BulkWorkspaceResources::ResultListParams::Action::OrSymbol,
+              cursor: String,
+              limit: Integer,
+              sort_order: String,
+              type: String,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Filter by action.
+        module Action
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cadenya::BulkWorkspaceResources::ResultListParams::Action
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACTION_UNSPECIFIED =
+            T.let(
+              :ACTION_UNSPECIFIED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+          ACTION_CREATED =
+            T.let(
+              :ACTION_CREATED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+          ACTION_UPDATED =
+            T.let(
+              :ACTION_UPDATED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+          ACTION_UNCHANGED =
+            T.let(
+              :ACTION_UNCHANGED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+          ACTION_DELETED =
+            T.let(
+              :ACTION_DELETED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+          ACTION_FAILED =
+            T.let(
+              :ACTION_FAILED,
+              Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::BulkWorkspaceResources::ResultListParams::Action::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/callable_tool.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class CallableTool < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::CallableTool, Cadenya::Internal::AnyHash)
+        end
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(T.nilable(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(T.nilable(Cadenya::ResourceMetadata)) }
+      attr_reader :cadenya_provided_tool
+
+      sig do
+        params(cadenya_provided_tool: Cadenya::ResourceMetadata::OrHash).void
+      end
+      attr_writer :cadenya_provided_tool
+
+      # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+      sig { returns(T.nilable(Cadenya::ResourceMetadata)) }
+      attr_reader :tool
+
+      sig { params(tool: Cadenya::ResourceMetadata::OrHash).void }
+      attr_writer :tool
+
+      # 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 do
+        params(
+          agent: Cadenya::ResourceMetadata::OrHash,
+          cadenya_provided_tool: Cadenya::ResourceMetadata::OrHash,
+          tool: Cadenya::ResourceMetadata::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        agent: nil,
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        cadenya_provided_tool: nil,
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        tool: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent: Cadenya::ResourceMetadata,
+            cadenya_provided_tool: Cadenya::ResourceMetadata,
+            tool: Cadenya::ResourceMetadata
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/context_window_compacted.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ContextWindowCompacted < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ContextWindowCompacted, Cadenya::Internal::AnyHash)
+        end
+
+      # Number of messages that were compacted
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :messages_compacted
+
+      sig { params(messages_compacted: Integer).void }
+      attr_writer :messages_compacted
+
+      # The new context window created by this compaction
+      sig { returns(T.nilable(Cadenya::ObjectiveContextWindowData)) }
+      attr_reader :new_context_window
+
+      sig do
+        params(
+          new_context_window: Cadenya::ObjectiveContextWindowData::OrHash
+        ).void
+      end
+      attr_writer :new_context_window
+
+      # The strategies that were applied during this compaction
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :strategies
+
+      sig { params(strategies: T::Array[String]).void }
+      attr_writer :strategies
+
+      # The summary generated by the summarization strategy, if used.
+      sig { returns(T.nilable(String)) }
+      attr_reader :summary
+
+      sig { params(summary: String).void }
+      attr_writer :summary
+
+      sig do
+        params(
+          messages_compacted: Integer,
+          new_context_window: Cadenya::ObjectiveContextWindowData::OrHash,
+          strategies: T::Array[String],
+          summary: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Number of messages that were compacted
+        messages_compacted: nil,
+        # The new context window created by this compaction
+        new_context_window: nil,
+        # The strategies that were applied during this compaction
+        strategies: nil,
+        # The summary generated by the summarization strategy, if used.
+        summary: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            messages_compacted: Integer,
+            new_context_window: Cadenya::ObjectiveContextWindowData,
+            strategies: T::Array[String],
+            summary: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/create_operation_metadata.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class CreateOperationMetadata < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::CreateOperationMetadata, Cadenya::Internal::AnyHash)
+        end
+
+      # External ID for the operation (e.g., a workflow ID from an external system)
+      sig { returns(T.nilable(String)) }
+      attr_reader :external_id
+
+      sig { params(external_id: String).void }
+      attr_writer :external_id
+
+      # Arbitrary key-value pairs for categorization and filtering Examples:
+      # {"priority": "high", "source": "api", "workflow": "onboarding"}
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      # CreateOperationMetadata contains the user-provided fields for creating an
+      # operation. Read-only fields (id, account_id, workspace_id, created_at,
+      # profile_id) are excluded since they are set by the server.
+      sig do
+        params(external_id: String, labels: T::Hash[Symbol, String]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # External ID for the operation (e.g., a workflow ID from an external system)
+        external_id: nil,
+        # Arbitrary key-value pairs for categorization and filtering Examples:
+        # {"priority": "high", "source": "api", "workflow": "onboarding"}
+        labels: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { external_id: String, labels: T::Hash[Symbol, String] }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/create_resource_metadata.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class CreateResourceMetadata < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::CreateResourceMetadata, Cadenya::Internal::AnyHash)
+        end
+
+      # Human-readable name for the resource (e.g., "Customer Support Agent", "Email
+      # Tool")
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Optional bundle ownership key. See ResourceMetadata.bundle_key.
+      sig { returns(T.nilable(String)) }
+      attr_reader :bundle_key
+
+      sig { params(bundle_key: String).void }
+      attr_writer :bundle_key
+
+      # External ID for the resource (e.g., a workflow ID from an external system)
+      sig { returns(T.nilable(String)) }
+      attr_reader :external_id
+
+      sig { params(external_id: String).void }
+      attr_writer :external_id
+
+      # Arbitrary key-value pairs for categorization and filtering Examples:
+      # {"environment": "production", "team": "platform", "version": "v2"}
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      # CreateResourceMetadata contains the user-provided fields for creating 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 do
+        params(
+          name: String,
+          bundle_key: String,
+          external_id: String,
+          labels: T::Hash[Symbol, String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Human-readable name for the resource (e.g., "Customer Support Agent", "Email
+        # Tool")
+        name:,
+        # Optional bundle ownership key. See ResourceMetadata.bundle_key.
+        bundle_key: nil,
+        # External ID for the resource (e.g., a workflow ID from an external system)
+        external_id: nil,
+        # Arbitrary key-value pairs for categorization and filtering Examples:
+        # {"environment": "production", "team": "platform", "version": "v2"}
+        labels: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            bundle_key: String,
+            external_id: String,
+            labels: T::Hash[Symbol, String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/mcp_tool_filter.rbi

@@ -0,0 +1,235 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class McpToolFilter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::McpToolFilter, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::McpToolFilter::Operator::OrSymbol) }
+      attr_accessor :operator
+
+      sig { returns(T.nilable(T::Array[Cadenya::McpToolFilter::Filter])) }
+      attr_reader :filters
+
+      sig do
+        params(filters: T::Array[Cadenya::McpToolFilter::Filter::OrHash]).void
+      end
+      attr_writer :filters
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig do
+        params(
+          operator: Cadenya::McpToolFilter::Operator::OrSymbol,
+          filters: T::Array[Cadenya::McpToolFilter::Filter::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(operator:, filters: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            operator: Cadenya::McpToolFilter::Operator::OrSymbol,
+            filters: T::Array[Cadenya::McpToolFilter::Filter]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Operator
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::McpToolFilter::Operator) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OPERATOR_UNSPECIFIED =
+          T.let(
+            :OPERATOR_UNSPECIFIED,
+            Cadenya::McpToolFilter::Operator::TaggedSymbol
+          )
+        OPERATOR_AND =
+          T.let(:OPERATOR_AND, Cadenya::McpToolFilter::Operator::TaggedSymbol)
+        OPERATOR_OR =
+          T.let(:OPERATOR_OR, Cadenya::McpToolFilter::Operator::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::McpToolFilter::Operator::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Filter < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::McpToolFilter::Filter, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(Cadenya::McpToolFilter::Filter::Attribute::OrSymbol) }
+        attr_accessor :attribute
+
+        # String matching operations
+        sig { returns(T.nilable(Cadenya::McpToolFilter::Filter::Matcher)) }
+        attr_reader :matcher
+
+        sig do
+          params(matcher: Cadenya::McpToolFilter::Filter::Matcher::OrHash).void
+        end
+        attr_writer :matcher
+
+        # Single attribute filter
+        sig do
+          params(
+            attribute: Cadenya::McpToolFilter::Filter::Attribute::OrSymbol,
+            matcher: Cadenya::McpToolFilter::Filter::Matcher::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          attribute:,
+          # String matching operations
+          matcher: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              attribute: Cadenya::McpToolFilter::Filter::Attribute::OrSymbol,
+              matcher: Cadenya::McpToolFilter::Filter::Matcher
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Attribute
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Cadenya::McpToolFilter::Filter::Attribute)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ATTRIBUTE_UNSPECIFIED =
+            T.let(
+              :ATTRIBUTE_UNSPECIFIED,
+              Cadenya::McpToolFilter::Filter::Attribute::TaggedSymbol
+            )
+          ATTRIBUTE_NAME =
+            T.let(
+              :ATTRIBUTE_NAME,
+              Cadenya::McpToolFilter::Filter::Attribute::TaggedSymbol
+            )
+          ATTRIBUTE_TITLE =
+            T.let(
+              :ATTRIBUTE_TITLE,
+              Cadenya::McpToolFilter::Filter::Attribute::TaggedSymbol
+            )
+          ATTRIBUTE_DESCRIPTION =
+            T.let(
+              :ATTRIBUTE_DESCRIPTION,
+              Cadenya::McpToolFilter::Filter::Attribute::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Cadenya::McpToolFilter::Filter::Attribute::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Matcher < Cadenya::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cadenya::McpToolFilter::Filter::Matcher,
+                Cadenya::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :case_sensitive
+
+          sig { params(case_sensitive: T::Boolean).void }
+          attr_writer :case_sensitive
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :contains
+
+          sig { params(contains: String).void }
+          attr_writer :contains
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :ends_with
+
+          sig { params(ends_with: String).void }
+          attr_writer :ends_with
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :exact
+
+          sig { params(exact: String).void }
+          attr_writer :exact
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :regex
+
+          sig { params(regex: String).void }
+          attr_writer :regex
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :starts_with
+
+          sig { params(starts_with: String).void }
+          attr_writer :starts_with
+
+          # String matching operations
+          sig do
+            params(
+              case_sensitive: T::Boolean,
+              contains: String,
+              ends_with: String,
+              exact: String,
+              regex: String,
+              starts_with: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            case_sensitive: nil,
+            contains: nil,
+            ends_with: nil,
+            exact: nil,
+            regex: nil,
+            starts_with: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                case_sensitive: T::Boolean,
+                contains: String,
+                ends_with: String,
+                exact: String,
+                regex: String,
+                starts_with: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end