cadenya 0.2.0 → 0.4.0

data/rbi/cadenya/models/ai_provider_key_retrieve_params.rbi

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

data/rbi/cadenya/models/ai_provider_key_spec.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeySpec < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKeySpec, Cadenya::Internal::AnyHash)
+        end
+
+      # The provider credential. Accepted on create/update; never populated in responses
+      # (the server returns an empty value to avoid leaking it).
+      sig { returns(T.nilable(String)) }
+      attr_reader :api_key
+
+      sig { params(api_key: String).void }
+      attr_writer :api_key
+
+      # The AI provider this key authenticates against. Currently "openrouter".
+      sig { returns(T.nilable(String)) }
+      attr_reader :provider
+
+      sig { params(provider: String).void }
+      attr_writer :provider
+
+      # The provider region. "us" or "eu". Defaults to "us".
+      sig { returns(T.nilable(String)) }
+      attr_reader :region
+
+      sig { params(region: String).void }
+      attr_writer :region
+
+      sig do
+        params(api_key: String, provider: String, region: String).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # The provider credential. Accepted on create/update; never populated in responses
+        # (the server returns an empty value to avoid leaking it).
+        api_key: nil,
+        # The AI provider this key authenticates against. Currently "openrouter".
+        provider: nil,
+        # The provider region. "us" or "eu". Defaults to "us".
+        region: nil
+      )
+      end
+
+      sig do
+        override.returns({ api_key: String, provider: String, region: String })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/ai_provider_key_update_params.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AIProviderKeyUpdateParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AIProviderKeyUpdateParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_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::AIProviderKeySpec)) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::AIProviderKeySpec::OrHash).void }
+      attr_writer :spec
+
+      # Fields to update.
+      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,
+          id: String,
+          metadata: Cadenya::UpdateResourceMetadata::OrHash,
+          spec: Cadenya::AIProviderKeySpec::OrHash,
+          update_mask: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_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,
+        # Fields to update.
+        update_mask: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            metadata: Cadenya::UpdateResourceMetadata,
+            spec: Cadenya::AIProviderKeySpec,
+            update_mask: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/approval_requirement_filter.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ApprovalRequirementFilter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ApprovalRequirementFilter, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :always
+
+      sig { params(always: T::Boolean).void }
+      attr_writer :always
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :only
+
+      sig { params(only: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :only
+
+      # Approval filters that will automatically set the approval requirement on tools
+      # synced from an external source
+      sig do
+        params(always: T::Boolean, only: Cadenya::ToolFilter::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        always: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        only: nil
+      )
+      end
+
+      sig do
+        override.returns({ always: T::Boolean, only: Cadenya::ToolFilter })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/attribute_filter.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class AttributeFilter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::AttributeFilter, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::AttributeFilter::Attribute::OrSymbol) }
+      attr_accessor :attribute
+
+      # String matching operations
+      sig { returns(T.nilable(Cadenya::StringMatcher)) }
+      attr_reader :matcher
+
+      sig { params(matcher: Cadenya::StringMatcher::OrHash).void }
+      attr_writer :matcher
+
+      # Single attribute filter
+      sig do
+        params(
+          attribute: Cadenya::AttributeFilter::Attribute::OrSymbol,
+          matcher: Cadenya::StringMatcher::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        attribute:,
+        # String matching operations
+        matcher: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            attribute: Cadenya::AttributeFilter::Attribute::OrSymbol,
+            matcher: Cadenya::StringMatcher
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Attribute
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::AttributeFilter::Attribute) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ATTRIBUTE_UNSPECIFIED =
+          T.let(
+            :ATTRIBUTE_UNSPECIFIED,
+            Cadenya::AttributeFilter::Attribute::TaggedSymbol
+          )
+        ATTRIBUTE_NAME =
+          T.let(
+            :ATTRIBUTE_NAME,
+            Cadenya::AttributeFilter::Attribute::TaggedSymbol
+          )
+        ATTRIBUTE_TITLE =
+          T.let(
+            :ATTRIBUTE_TITLE,
+            Cadenya::AttributeFilter::Attribute::TaggedSymbol
+          )
+        ATTRIBUTE_DESCRIPTION =
+          T.let(
+            :ATTRIBUTE_DESCRIPTION,
+            Cadenya::AttributeFilter::Attribute::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::AttributeFilter::Attribute::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objective_data.rbi

@@ -64,6 +64,22 @@ module Cadenya
       sig { params(agent: Cadenya::Agent::OrHash).void }
       attr_writer :agent
 
+      # The output of the objective, populated when the objective completes. Will match
+      # the schema of output_json_schema or output_json_inferred.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :output
+
+      sig { params(output: T::Hash[Symbol, T.anything]).void }
+      attr_writer :output
+
+      # Snapshot of the agent spec's output_definition at objective creation time. When
+      # present, the objective will run an extraction step after the LLM finishes.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :output_definition
+
+      sig { params(output_definition: T::Hash[Symbol, T.anything]).void }
+      attr_writer :output_definition
+
       # A parent objective means the objective was spawned off using a separate agent to
       # complete an objective
       sig { returns(T.nilable(String)) }
@@ -101,6 +117,8 @@ module Cadenya
           data: T.anything,
           initial_message: String,
           memory_stack: T::Array[Cadenya::MemoryReference::OrHash],
+          output: T::Hash[Symbol, T.anything],
+          output_definition: T::Hash[Symbol, T.anything],
           parent_objective_id: String,
           secrets: T::Array[Cadenya::ObjectiveDataSecret::OrHash],
           source_schedule_id: String,
@@ -133,6 +151,12 @@ module Cadenya
         # - this field) must not exceed 10 entries. A request that would produce an
         #   effective stack larger than 10 is rejected with InvalidArgument.
         memory_stack: nil,
+        # The output of the objective, populated when the objective completes. Will match
+        # the schema of output_json_schema or output_json_inferred.
+        output: nil,
+        # Snapshot of the agent spec's output_definition at objective creation time. When
+        # present, the objective will run an extraction step after the LLM finishes.
+        output_definition: nil,
         # A parent objective means the objective was spawned off using a separate agent to
         # complete an objective
         parent_objective_id: nil,
@@ -157,6 +181,8 @@ module Cadenya
             data: T.anything,
             initial_message: String,
             memory_stack: T::Array[Cadenya::MemoryReference],
+            output: T::Hash[Symbol, T.anything],
+            output_definition: T::Hash[Symbol, T.anything],
             parent_objective_id: String,
             secrets: T::Array[Cadenya::ObjectiveDataSecret],
             source_schedule_id: String,

data/rbi/cadenya/models/objective_event_data.rbi

@@ -41,6 +41,17 @@ module Cadenya
       sig { params(error: Cadenya::ObjectiveError::OrHash).void }
       attr_writer :error
 
+      # ObjectiveFinalized is the terminal event written when an objective is finalized.
+      # After this event, the objective is super-terminal: no further iterations,
+      # compaction, or continuation are permitted.
+      sig { returns(T.nilable(Cadenya::ObjectiveEventData::Finalized)) }
+      attr_reader :finalized
+
+      sig do
+        params(finalized: Cadenya::ObjectiveEventData::Finalized::OrHash).void
+      end
+      attr_writer :finalized
+
       # MemoryRead is emitted each time the agent resolves a key against the memory
       # stack and loads an entry. Lookups that miss (key not found in any layer) do not
       # emit this event.
@@ -120,6 +131,7 @@ module Cadenya
           cancelled: Cadenya::ObjectiveEventData::Cancelled::OrHash,
           context_window_compacted: Cadenya::ContextWindowCompacted::OrHash,
           error: Cadenya::ObjectiveError::OrHash,
+          finalized: Cadenya::ObjectiveEventData::Finalized::OrHash,
           memory_read: Cadenya::MemoryRead::OrHash,
           sub_agent_spawned: Cadenya::SubAgentSpawned::OrHash,
           sub_agent_updated: Cadenya::SubAgentUpdated::OrHash,
@@ -141,6 +153,10 @@ module Cadenya
         cancelled: nil,
         context_window_compacted: nil,
         error: nil,
+        # ObjectiveFinalized is the terminal event written when an objective is finalized.
+        # After this event, the objective is super-terminal: no further iterations,
+        # compaction, or continuation are permitted.
+        finalized: nil,
         # MemoryRead is emitted each time the agent resolves a key against the memory
         # stack and loads an entry. Lookups that miss (key not found in any layer) do not
         # emit this event.
@@ -165,6 +181,7 @@ module Cadenya
             cancelled: Cadenya::ObjectiveEventData::Cancelled,
             context_window_compacted: Cadenya::ContextWindowCompacted,
             error: Cadenya::ObjectiveError,
+            finalized: Cadenya::ObjectiveEventData::Finalized,
             memory_read: Cadenya::MemoryRead,
             sub_agent_spawned: Cadenya::SubAgentSpawned,
             sub_agent_updated: Cadenya::SubAgentUpdated,
@@ -216,6 +233,41 @@ module Cadenya
         def to_hash
         end
       end
+
+      class Finalized < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::ObjectiveEventData::Finalized,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # If the objective was created with an output schema, and the agent successfully
+        # completed the objective, this field will contain the structured output of the
+        # objective.
+        sig { returns(T.nilable(T.anything)) }
+        attr_reader :output
+
+        sig { params(output: T.anything).void }
+        attr_writer :output
+
+        # ObjectiveFinalized is the terminal event written when an objective is finalized.
+        # After this event, the objective is super-terminal: no further iterations,
+        # compaction, or continuation are permitted.
+        sig { params(output: T.anything).returns(T.attached_class) }
+        def self.new(
+          # If the objective was created with an output schema, and the agent successfully
+          # completed the objective, this field will contain the structured output of the
+          # objective.
+          output: nil
+        )
+        end
+
+        sig { override.returns({ output: T.anything }) }
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/objective_list_params.rbi

@@ -159,9 +159,9 @@ module Cadenya
             :STATE_RUNNING,
             Cadenya::ObjectiveListParams::State::TaggedSymbol
           )
-        STATE_COMPLETED =
+        STATE_WAITING =
           T.let(
-            :STATE_COMPLETED,
+            :STATE_WAITING,
             Cadenya::ObjectiveListParams::State::TaggedSymbol
           )
         STATE_FAILED =
@@ -174,6 +174,11 @@ module Cadenya
             :STATE_CANCELLED,
             Cadenya::ObjectiveListParams::State::TaggedSymbol
           )
+        STATE_FINALIZED =
+          T.let(
+            :STATE_FINALIZED,
+            Cadenya::ObjectiveListParams::State::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/cadenya/models/objective_status.rbi

@@ -53,12 +53,14 @@ module Cadenya
           T.let(:STATE_PENDING, Cadenya::ObjectiveStatus::State::TaggedSymbol)
         STATE_RUNNING =
           T.let(:STATE_RUNNING, Cadenya::ObjectiveStatus::State::TaggedSymbol)
-        STATE_COMPLETED =
-          T.let(:STATE_COMPLETED, Cadenya::ObjectiveStatus::State::TaggedSymbol)
+        STATE_WAITING =
+          T.let(:STATE_WAITING, Cadenya::ObjectiveStatus::State::TaggedSymbol)
         STATE_FAILED =
           T.let(:STATE_FAILED, Cadenya::ObjectiveStatus::State::TaggedSymbol)
         STATE_CANCELLED =
           T.let(:STATE_CANCELLED, Cadenya::ObjectiveStatus::State::TaggedSymbol)
+        STATE_FINALIZED =
+          T.let(:STATE_FINALIZED, Cadenya::ObjectiveStatus::State::TaggedSymbol)
 
         sig do
           override.returns(

data/rbi/cadenya/models/profile_spec.rbi

@@ -64,6 +64,11 @@ module Cadenya
           T.type_alias { T.all(Symbol, Cadenya::ProfileSpec::Type) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
+        PROFILE_TYPE_UNSPECIFIED =
+          T.let(
+            :PROFILE_TYPE_UNSPECIFIED,
+            Cadenya::ProfileSpec::Type::TaggedSymbol
+          )
         PROFILE_TYPE_USER =
           T.let(:PROFILE_TYPE_USER, Cadenya::ProfileSpec::Type::TaggedSymbol)
         PROFILE_TYPE_API_KEY =

data/rbi/cadenya/models/string_matcher.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcher < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcher, 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

data/rbi/cadenya/models/tool_filter.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolFilter < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolFilter, Cadenya::Internal::AnyHash) }
+
+      sig { returns(Cadenya::ToolFilter::Operator::OrSymbol) }
+      attr_accessor :operator
+
+      sig { returns(T.nilable(T::Array[Cadenya::AttributeFilter])) }
+      attr_reader :filters
+
+      sig { params(filters: T::Array[Cadenya::AttributeFilter::OrHash]).void }
+      attr_writer :filters
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig do
+        params(
+          operator: Cadenya::ToolFilter::Operator::OrSymbol,
+          filters: T::Array[Cadenya::AttributeFilter::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(operator:, filters: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            operator: Cadenya::ToolFilter::Operator::OrSymbol,
+            filters: T::Array[Cadenya::AttributeFilter]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Operator
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::ToolFilter::Operator) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OPERATOR_UNSPECIFIED =
+          T.let(
+            :OPERATOR_UNSPECIFIED,
+            Cadenya::ToolFilter::Operator::TaggedSymbol
+          )
+        OPERATOR_AND =
+          T.let(:OPERATOR_AND, Cadenya::ToolFilter::Operator::TaggedSymbol)
+        OPERATOR_OR =
+          T.let(:OPERATOR_OR, Cadenya::ToolFilter::Operator::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolFilter::Operator::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -20,18 +20,29 @@ module Cadenya
       sig { params(mcp: Cadenya::ToolSetAdapterMcp::OrHash).void }
       attr_writer :mcp
 
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterOpenAPI)) }
+      attr_reader :openapi
+
+      sig { params(openapi: Cadenya::ToolSetAdapterOpenAPI::OrHash).void }
+      attr_writer :openapi
+
       sig do
         params(
           http: Cadenya::ToolSetAdapterHTTP::OrHash,
-          mcp: Cadenya::ToolSetAdapterMcp::OrHash
+          mcp: Cadenya::ToolSetAdapterMcp::OrHash,
+          openapi: Cadenya::ToolSetAdapterOpenAPI::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(http: nil, mcp: nil)
+      def self.new(http: nil, mcp: nil, openapi: nil)
       end
 
       sig do
         override.returns(
-          { http: Cadenya::ToolSetAdapterHTTP, mcp: Cadenya::ToolSetAdapterMcp }
+          {
+            http: Cadenya::ToolSetAdapterHTTP,
+            mcp: Cadenya::ToolSetAdapterMcp,
+            openapi: Cadenya::ToolSetAdapterOpenAPI
+          }
         )
       end
       def to_hash