cadenya 0.2.0 → 0.3.0

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

data/rbi/cadenya/models/tool_set_adapter_mcp.rbi

@@ -9,10 +9,10 @@ module Cadenya
         end
 
       # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::McpToolFilter)) }
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
       attr_reader :exclude_tools
 
-      sig { params(exclude_tools: Cadenya::McpToolFilter::OrHash).void }
+      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
       attr_writer :exclude_tools
 
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
@@ -22,21 +22,19 @@ module Cadenya
       attr_writer :headers
 
       # Top-level filter with simple boolean logic (no nesting)
-      sig { returns(T.nilable(Cadenya::McpToolFilter)) }
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
       attr_reader :include_tools
 
-      sig { params(include_tools: Cadenya::McpToolFilter::OrHash).void }
+      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
       attr_writer :include_tools
 
-      # Approval filters that will automatically set the approval requirement on the
-      # tools synced from the MCP server
-      sig { returns(T.nilable(Cadenya::ToolSetAdapterMcp::ToolApprovals)) }
+      # Approval filters that will automatically set the approval requirement on tools
+      # synced from an external source
+      sig { returns(T.nilable(Cadenya::ApprovalRequirementFilter)) }
       attr_reader :tool_approvals
 
       sig do
-        params(
-          tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals::OrHash
-        ).void
+        params(tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash).void
       end
       attr_writer :tool_approvals
 
@@ -48,10 +46,10 @@ module Cadenya
 
       sig do
         params(
-          exclude_tools: Cadenya::McpToolFilter::OrHash,
+          exclude_tools: Cadenya::ToolFilter::OrHash,
           headers: T::Hash[Symbol, String],
-          include_tools: Cadenya::McpToolFilter::OrHash,
-          tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals::OrHash,
+          include_tools: Cadenya::ToolFilter::OrHash,
+          tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash,
           url: String
         ).returns(T.attached_class)
       end
@@ -61,8 +59,8 @@ module Cadenya
         headers: nil,
         # Top-level filter with simple boolean logic (no nesting)
         include_tools: nil,
-        # Approval filters that will automatically set the approval requirement on the
-        # tools synced from the MCP server
+        # Approval filters that will automatically set the approval requirement on tools
+        # synced from an external source
         tool_approvals: nil,
         url: nil
       )
@@ -71,60 +69,16 @@ module Cadenya
       sig do
         override.returns(
           {
-            exclude_tools: Cadenya::McpToolFilter,
+            exclude_tools: Cadenya::ToolFilter,
             headers: T::Hash[Symbol, String],
-            include_tools: Cadenya::McpToolFilter,
-            tool_approvals: Cadenya::ToolSetAdapterMcp::ToolApprovals,
+            include_tools: Cadenya::ToolFilter,
+            tool_approvals: Cadenya::ApprovalRequirementFilter,
             url: String
           }
         )
       end
       def to_hash
       end
-
-      class ToolApprovals < Cadenya::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Cadenya::ToolSetAdapterMcp::ToolApprovals,
-              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::McpToolFilter)) }
-        attr_reader :only
-
-        sig { params(only: Cadenya::McpToolFilter::OrHash).void }
-        attr_writer :only
-
-        # Approval filters that will automatically set the approval requirement on the
-        # tools synced from the MCP server
-        sig do
-          params(
-            always: T::Boolean,
-            only: Cadenya::McpToolFilter::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::McpToolFilter })
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/cadenya/models/tool_set_adapter_openapi.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterOpenAPI < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterOpenAPI, Cadenya::Internal::AnyHash)
+        end
+
+      # Base URL for dispatching tool calls. If set, overrides the server resolved from
+      # the spec's servers array.
+      sig { returns(T.nilable(String)) }
+      attr_reader :base_url
+
+      sig { params(base_url: String).void }
+      attr_writer :base_url
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :exclude_tools
+
+      sig { params(exclude_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :exclude_tools
+
+      # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      # Top-level filter with simple boolean logic (no nesting)
+      sig { returns(T.nilable(Cadenya::ToolFilter)) }
+      attr_reader :include_tools
+
+      sig { params(include_tools: Cadenya::ToolFilter::OrHash).void }
+      attr_writer :include_tools
+
+      # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+      # field). Used to select which server URL to dispatch to when base_url is not set.
+      # If unset, the first server is used. Ignored when base_url is set.
+      sig { returns(T.nilable(String)) }
+      attr_reader :server_name
+
+      sig { params(server_name: String).void }
+      attr_writer :server_name
+
+      # Approval filters that will automatically set the approval requirement on tools
+      # synced from an external source
+      sig { returns(T.nilable(Cadenya::ApprovalRequirementFilter)) }
+      attr_reader :tool_approvals
+
+      sig do
+        params(tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash).void
+      end
+      attr_writer :tool_approvals
+
+      # ID of a COMPLETE Upload containing the OpenAPI spec document.
+      sig { returns(T.nilable(String)) }
+      attr_reader :upload_id
+
+      sig { params(upload_id: String).void }
+      attr_writer :upload_id
+
+      # URL to fetch the OpenAPI spec from. Synced automatically every hour.
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+
+      sig { params(url: String).void }
+      attr_writer :url
+
+      sig do
+        params(
+          base_url: String,
+          exclude_tools: Cadenya::ToolFilter::OrHash,
+          headers: T::Hash[Symbol, String],
+          include_tools: Cadenya::ToolFilter::OrHash,
+          server_name: String,
+          tool_approvals: Cadenya::ApprovalRequirementFilter::OrHash,
+          upload_id: String,
+          url: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Base URL for dispatching tool calls. If set, overrides the server resolved from
+        # the spec's servers array.
+        base_url: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        exclude_tools: nil,
+        # Headers sent when fetching the spec from a URL and when dispatching tool calls.
+        headers: nil,
+        # Top-level filter with simple boolean logic (no nesting)
+        include_tools: nil,
+        # Name of the server entry in the spec's servers array (OpenAPI 3.2 server.name
+        # field). Used to select which server URL to dispatch to when base_url is not set.
+        # If unset, the first server is used. Ignored when base_url is set.
+        server_name: nil,
+        # Approval filters that will automatically set the approval requirement on tools
+        # synced from an external source
+        tool_approvals: nil,
+        # ID of a COMPLETE Upload containing the OpenAPI spec document.
+        upload_id: nil,
+        # URL to fetch the OpenAPI spec from. Synced automatically every hour.
+        url: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            base_url: String,
+            exclude_tools: Cadenya::ToolFilter,
+            headers: T::Hash[Symbol, String],
+            include_tools: Cadenya::ToolFilter,
+            server_name: String,
+            tool_approvals: Cadenya::ApprovalRequirementFilter,
+            upload_id: String,
+            url: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_get_openapi_spec_params.rbi

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