cadenya 0.29.0 → 0.30.0

data/rbi/cadenya/models/objectives/set_tool_call_content_request_content_block.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class SetToolCallContentRequestContentBlock < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::SetToolCallContentRequestContentBlock,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(Cadenya::Objectives::SetToolCallContentRequestAudioBlock)
+          )
+        end
+        attr_reader :audio
+
+        sig do
+          params(
+            audio:
+              Cadenya::Objectives::SetToolCallContentRequestAudioBlock::OrHash
+          ).void
+        end
+        attr_writer :audio
+
+        sig do
+          returns(
+            T.nilable(Cadenya::Objectives::SetToolCallContentRequestImageBlock)
+          )
+        end
+        attr_reader :image
+
+        sig do
+          params(
+            image:
+              Cadenya::Objectives::SetToolCallContentRequestImageBlock::OrHash
+          ).void
+        end
+        attr_writer :image
+
+        sig do
+          returns(
+            T.nilable(Cadenya::Objectives::SetToolCallContentRequestTextBlock)
+          )
+        end
+        attr_reader :text
+
+        sig do
+          params(
+            text:
+              Cadenya::Objectives::SetToolCallContentRequestTextBlock::OrHash
+          ).void
+        end
+        attr_writer :text
+
+        # ContentBlock is a single block of tool call content supplied on input. Exactly
+        # one of the variants is set.
+        sig do
+          params(
+            audio:
+              Cadenya::Objectives::SetToolCallContentRequestAudioBlock::OrHash,
+            image:
+              Cadenya::Objectives::SetToolCallContentRequestImageBlock::OrHash,
+            text:
+              Cadenya::Objectives::SetToolCallContentRequestTextBlock::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(audio: nil, image: nil, text: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              audio: Cadenya::Objectives::SetToolCallContentRequestAudioBlock,
+              image: Cadenya::Objectives::SetToolCallContentRequestImageBlock,
+              text: Cadenya::Objectives::SetToolCallContentRequestTextBlock
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/set_tool_call_content_request_image_block.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class SetToolCallContentRequestImageBlock < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::SetToolCallContentRequestImageBlock,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        # Base64-encoded image bytes.
+        sig { returns(String) }
+        attr_accessor :data
+
+        # IANA media type of the image, e.g. image/png.
+        sig { returns(String) }
+        attr_accessor :mime_type
+
+        sig do
+          params(data: String, mime_type: String).returns(T.attached_class)
+        end
+        def self.new(
+          # Base64-encoded image bytes.
+          data:,
+          # IANA media type of the image, e.g. image/png.
+          mime_type:
+        )
+        end
+
+        sig { override.returns({ data: String, mime_type: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/set_tool_call_content_request_text_block.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class SetToolCallContentRequestTextBlock < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::SetToolCallContentRequestTextBlock,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :text
+
+        sig { params(text: String).returns(T.attached_class) }
+        def self.new(text:)
+        end
+
+        sig { override.returns({ text: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/objectives/tool_call_list_params.rbi

@@ -28,6 +28,26 @@ module Cadenya
         sig { params(cursor: String).void }
         attr_writer :cursor
 
+        # Filter by tool call execution status. Useful for reverse-harness polling of bare
+        # tool calls waiting for externally supplied content
+        # (TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT).
+        sig do
+          returns(
+            T.nilable(
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::OrSymbol
+            )
+          )
+        end
+        attr_reader :execution_status
+
+        sig do
+          params(
+            execution_status:
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::OrSymbol
+          ).void
+        end
+        attr_writer :execution_status
+
         # When set to true you may use more of your alloted API rate-limit
         sig { returns(T.nilable(T::Boolean)) }
         attr_reader :include_info
@@ -62,6 +82,8 @@ module Cadenya
             workspace_id: String,
             objective_id: String,
             cursor: String,
+            execution_status:
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::OrSymbol,
             include_info: T::Boolean,
             limit: Integer,
             status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol,
@@ -73,6 +95,10 @@ module Cadenya
           objective_id:,
           # Pagination cursor from previous response
           cursor: nil,
+          # Filter by tool call execution status. Useful for reverse-harness polling of bare
+          # tool calls waiting for externally supplied content
+          # (TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT).
+          execution_status: nil,
           # When set to true you may use more of your alloted API rate-limit
           include_info: nil,
           # Maximum number of results to return
@@ -89,6 +115,8 @@ module Cadenya
               workspace_id: String,
               objective_id: String,
               cursor: String,
+              execution_status:
+                Cadenya::Objectives::ToolCallListParams::ExecutionStatus::OrSymbol,
               include_info: T::Boolean,
               limit: Integer,
               status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol,
@@ -99,6 +127,63 @@ module Cadenya
         def to_hash
         end
 
+        # Filter by tool call execution status. Useful for reverse-harness polling of bare
+        # tool calls waiting for externally supplied content
+        # (TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT).
+        module ExecutionStatus
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cadenya::Objectives::ToolCallListParams::ExecutionStatus
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL_EXECUTION_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_UNSPECIFIED,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_PENDING =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_PENDING,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_RUNNING =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_RUNNING,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_COMPLETED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_COMPLETED,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_ERRORED =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_ERRORED,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+          TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT =
+            T.let(
+              :TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT,
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::Objectives::ToolCallListParams::ExecutionStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         # Filter by tool call status
         module Status
           extend Cadenya::Internal::Type::Enum

data/rbi/cadenya/models/objectives/tool_call_set_content_params.rbi

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module Objectives
+      class ToolCallSetContentParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::Objectives::ToolCallSetContentParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :objective_id
+
+        sig { returns(String) }
+        attr_accessor :tool_call_id
+
+        # The content to set on the tool call. Mirrors
+        # ObjectiveToolCallResult.ContentBlock but writable: media blocks carry raw data
+        # on input where the result-side carries a signed url on output.
+        sig do
+          returns(
+            T::Array[Cadenya::Objectives::SetToolCallContentRequestContentBlock]
+          )
+        end
+        attr_accessor :content
+
+        sig do
+          params(
+            workspace_id: String,
+            objective_id: String,
+            tool_call_id: String,
+            content:
+              T::Array[
+                Cadenya::Objectives::SetToolCallContentRequestContentBlock::OrHash
+              ],
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          objective_id:,
+          tool_call_id:,
+          # The content to set on the tool call. Mirrors
+          # ObjectiveToolCallResult.ContentBlock but writable: media blocks carry raw data
+          # on input where the result-side carries a signed url on output.
+          content:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              objective_id: String,
+              tool_call_id: String,
+              content:
+                T::Array[
+                  Cadenya::Objectives::SetToolCallContentRequestContentBlock
+                ],
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_called.rbi

@@ -6,6 +6,32 @@ module Cadenya
       OrHash =
         T.type_alias { T.any(Cadenya::ToolCalled, Cadenya::Internal::AnyHash) }
 
+      # The arguments passed to the tool.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :arguments
+
+      sig { params(arguments: T::Hash[Symbol, T.anything]).void }
+      attr_writer :arguments
+
+      # 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(T.nilable(Cadenya::ToolSets::ToolSpecConfig)) }
+      attr_reader :config
+
+      sig { params(config: Cadenya::ToolSets::ToolSpecConfig::OrHash).void }
+      attr_writer :config
+
+      # 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 { returns(T.nilable(Cadenya::CallableTool)) }
+      attr_reader :tool
+
+      sig { params(tool: Cadenya::CallableTool::OrHash).void }
+      attr_writer :tool
+
       # The ID of the objective tool call record that was executed.
       sig { returns(T.nilable(String)) }
       attr_reader :tool_call_id
@@ -13,14 +39,41 @@ module Cadenya
       sig { params(tool_call_id: String).void }
       attr_writer :tool_call_id
 
-      sig { params(tool_call_id: String).returns(T.attached_class) }
+      sig do
+        params(
+          arguments: T::Hash[Symbol, T.anything],
+          config: Cadenya::ToolSets::ToolSpecConfig::OrHash,
+          tool: Cadenya::CallableTool::OrHash,
+          tool_call_id: String
+        ).returns(T.attached_class)
+      end
       def self.new(
+        # The arguments passed to the tool.
+        arguments: nil,
+        # 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: nil,
+        # 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).
+        tool: nil,
         # The ID of the objective tool call record that was executed.
         tool_call_id: nil
       )
       end
 
-      sig { override.returns({ tool_call_id: String }) }
+      sig do
+        override.returns(
+          {
+            arguments: T::Hash[Symbol, T.anything],
+            config: Cadenya::ToolSets::ToolSpecConfig,
+            tool: Cadenya::CallableTool,
+            tool_call_id: String
+          }
+        )
+      end
       def to_hash
       end
     end

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -8,6 +8,17 @@ module Cadenya
           T.any(Cadenya::ToolSetAdapter, Cadenya::Internal::AnyHash)
         end
 
+      # Bare tool sets define tools without an execution adapter. A bare tool call
+      # doesn't fire anything: the objective's workflow pauses and waits for an external
+      # API consumer to set the tool call's content (e.g. human-in-the-loop tools, or a
+      # reverse harness that polls for pending tool calls, executes locally, and reports
+      # results back via SetToolCallContent).
+      sig { returns(T.nilable(Cadenya::ToolSetAdapterBare)) }
+      attr_reader :bare
+
+      sig { params(bare: Cadenya::ToolSetAdapterBare::OrHash).void }
+      attr_writer :bare
+
       sig { returns(T.nilable(Cadenya::ToolSetAdapterHTTP)) }
       attr_reader :http
 
@@ -28,17 +39,29 @@ module Cadenya
 
       sig do
         params(
+          bare: Cadenya::ToolSetAdapterBare::OrHash,
           http: Cadenya::ToolSetAdapterHTTP::OrHash,
           mcp: Cadenya::ToolSetAdapterMcp::OrHash,
           openapi: Cadenya::ToolSetAdapterOpenAPI::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(http: nil, mcp: nil, openapi: nil)
+      def self.new(
+        # Bare tool sets define tools without an execution adapter. A bare tool call
+        # doesn't fire anything: the objective's workflow pauses and waits for an external
+        # API consumer to set the tool call's content (e.g. human-in-the-loop tools, or a
+        # reverse harness that polls for pending tool calls, executes locally, and reports
+        # results back via SetToolCallContent).
+        bare: nil,
+        http: nil,
+        mcp: nil,
+        openapi: nil
+      )
       end
 
       sig do
         override.returns(
           {
+            bare: Cadenya::ToolSetAdapterBare,
             http: Cadenya::ToolSetAdapterHTTP,
             mcp: Cadenya::ToolSetAdapterMcp,
             openapi: Cadenya::ToolSetAdapterOpenAPI

data/rbi/cadenya/models/tool_set_adapter_bare.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterBare < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterBare, Cadenya::Internal::AnyHash)
+        end
+
+      # How long to wait for content to be set before the tool call errors. If unset,
+      # the call waits indefinitely.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :content_timeout
+
+      sig { params(content_timeout: Integer).void }
+      attr_writer :content_timeout
+
+      # Bare tool sets define tools without an execution adapter. A bare tool call
+      # doesn't fire anything: the objective's workflow pauses and waits for an external
+      # API consumer to set the tool call's content (e.g. human-in-the-loop tools, or a
+      # reverse harness that polls for pending tool calls, executes locally, and reports
+      # results back via SetToolCallContent).
+      sig { params(content_timeout: Integer).returns(T.attached_class) }
+      def self.new(
+        # How long to wait for content to be set before the tool call errors. If unset,
+        # the call waits indefinitely.
+        content_timeout: nil
+      )
+      end
+
+      sig { override.returns({ content_timeout: Integer }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/config_bare.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ConfigBare < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ConfigBare, Cadenya::Internal::AnyHash)
+          end
+
+        # Marks the tool as bare: it has no execution adapter of its own and relies on the
+        # parent tool set being a Bare tool set. Present so a webhook consumer can tell a
+        # tool is bare from the tool data alone, without cross-referencing the tool set.
+        sig { returns(T.attached_class) }
+        def self.new
+        end
+
+        sig { override.returns({}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,15 @@ module Cadenya
             T.any(Cadenya::ToolSets::ToolSpecConfig, Cadenya::Internal::AnyHash)
           end
 
+        # Marks the tool as bare: it has no execution adapter of its own and relies on the
+        # parent tool set being a Bare tool set. Present so a webhook consumer can tell a
+        # tool is bare from the tool data alone, without cross-referencing the tool set.
+        sig { returns(T.nilable(Cadenya::ToolSets::ConfigBare)) }
+        attr_reader :bare
+
+        sig { params(bare: Cadenya::ToolSets::ConfigBare::OrHash).void }
+        attr_writer :bare
+
         sig { returns(T.nilable(Cadenya::ToolSets::ConfigHTTP)) }
         attr_reader :http
 
@@ -32,17 +41,27 @@ module Cadenya
         # be Http. If the tool is an inline tool, the adapter will be Inline.
         sig do
           params(
+            bare: Cadenya::ToolSets::ConfigBare::OrHash,
             http: Cadenya::ToolSets::ConfigHTTP::OrHash,
             mcp: Cadenya::ToolSets::ConfigMcp::OrHash,
             openapi: Cadenya::ToolSets::ConfigOpenAPI::OrHash
           ).returns(T.attached_class)
         end
-        def self.new(http: nil, mcp: nil, openapi: nil)
+        def self.new(
+          # Marks the tool as bare: it has no execution adapter of its own and relies on the
+          # parent tool set being a Bare tool set. Present so a webhook consumer can tell a
+          # tool is bare from the tool data alone, without cross-referencing the tool set.
+          bare: nil,
+          http: nil,
+          mcp: nil,
+          openapi: nil
+        )
         end
 
         sig do
           override.returns(
             {
+              bare: Cadenya::ToolSets::ConfigBare,
               http: Cadenya::ToolSets::ConfigHTTP,
               mcp: Cadenya::ToolSets::ConfigMcp,
               openapi: Cadenya::ToolSets::ConfigOpenAPI

data/rbi/cadenya/models.rbi

@@ -231,6 +231,8 @@ module Cadenya
 
   ToolSetAdapter = Cadenya::Models::ToolSetAdapter
 
+  ToolSetAdapterBare = Cadenya::Models::ToolSetAdapterBare
+
   ToolSetAdapterHTTP = Cadenya::Models::ToolSetAdapterHTTP
 
   ToolSetAdapterMcp = Cadenya::Models::ToolSetAdapterMcp

data/rbi/cadenya/resources/objectives/tool_calls.rbi

@@ -30,6 +30,8 @@ module Cadenya
             objective_id: String,
             workspace_id: String,
             cursor: String,
+            execution_status:
+              Cadenya::Objectives::ToolCallListParams::ExecutionStatus::OrSymbol,
             include_info: T::Boolean,
             limit: Integer,
             status: Cadenya::Objectives::ToolCallListParams::Status::OrSymbol,
@@ -47,6 +49,10 @@ module Cadenya
           workspace_id:,
           # Query param: Pagination cursor from previous response
           cursor: nil,
+          # Query param: Filter by tool call execution status. Useful for reverse-harness
+          # polling of bare tool calls waiting for externally supplied content
+          # (TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT).
+          execution_status: nil,
           # Query param: When set to true you may use more of your alloted API rate-limit
           include_info: nil,
           # Query param: Maximum number of results to return
@@ -104,6 +110,37 @@ module Cadenya
         )
         end
 
+        # For bare tool calls (tool sets with no execution adapter), sets the content an
+        # external API consumer supplies for the call — used for human-in-the-loop tools
+        # and reverse harnesses that execute tools locally and report results back.
+        sig do
+          params(
+            tool_call_id: String,
+            workspace_id: String,
+            objective_id: String,
+            content:
+              T::Array[
+                Cadenya::Objectives::SetToolCallContentRequestContentBlock::OrHash
+              ],
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(Cadenya::Objectives::ObjectiveToolCall)
+        end
+        def set_content(
+          # Path param: The ID of the tool call to set content for
+          tool_call_id,
+          # Path param
+          workspace_id:,
+          # Path param: The ID of the objective. Supports "external_id:" prefix for external
+          # IDs.
+          objective_id:,
+          # Body param: The content to set on the tool call. Mirrors
+          # ObjectiveToolCallResult.ContentBlock but writable: media blocks carry raw data
+          # on input where the result-side carries a signed url on output.
+          content:,
+          request_options: {}
+        )
+        end
+
         # @api private
         sig { params(client: Cadenya::Client).returns(T.attached_class) }
         def self.new(client:)

data/sig/cadenya/models/objectives/objective_tool_call.rbs

@@ -49,6 +49,7 @@ module Cadenya
           | :TOOL_CALL_EXECUTION_STATUS_RUNNING
           | :TOOL_CALL_EXECUTION_STATUS_COMPLETED
           | :TOOL_CALL_EXECUTION_STATUS_ERRORED
+          | :TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT
 
         module ExecutionStatus
           extend Cadenya::Internal::Type::Enum
@@ -58,6 +59,7 @@ module Cadenya
           TOOL_CALL_EXECUTION_STATUS_RUNNING: :TOOL_CALL_EXECUTION_STATUS_RUNNING
           TOOL_CALL_EXECUTION_STATUS_COMPLETED: :TOOL_CALL_EXECUTION_STATUS_COMPLETED
           TOOL_CALL_EXECUTION_STATUS_ERRORED: :TOOL_CALL_EXECUTION_STATUS_ERRORED
+          TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT: :TOOL_CALL_EXECUTION_STATUS_WAITING_FOR_CONTENT
 
           def self?.values: -> ::Array[Cadenya::Models::Objectives::ObjectiveToolCall::execution_status]
         end