cadenya 0.49.0 → 0.50.0

data/rbi/cadenya/models/string_matcher_contains.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcherContains < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcherContains, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :contains
+
+      sig { returns(Cadenya::StringMatcherContains::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig do
+        params(
+          contains: String,
+          type: Cadenya::StringMatcherContains::Type::OrSymbol,
+          case_sensitive: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(contains:, type:, case_sensitive: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            contains: String,
+            type: Cadenya::StringMatcherContains::Type::OrSymbol,
+            case_sensitive: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::StringMatcherContains::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CONTAINS =
+          T.let(:contains, Cadenya::StringMatcherContains::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::StringMatcherContains::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/string_matcher_ends_with.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcherEndsWith < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcherEndsWith, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :ends_with
+
+      sig { returns(Cadenya::StringMatcherEndsWith::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig do
+        params(
+          ends_with: String,
+          type: Cadenya::StringMatcherEndsWith::Type::OrSymbol,
+          case_sensitive: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(ends_with:, type:, case_sensitive: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            ends_with: String,
+            type: Cadenya::StringMatcherEndsWith::Type::OrSymbol,
+            case_sensitive: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::StringMatcherEndsWith::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ENDS_WITH =
+          T.let(:endsWith, Cadenya::StringMatcherEndsWith::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::StringMatcherEndsWith::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/string_matcher_exact.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcherExact < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcherExact, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :exact
+
+      sig { returns(Cadenya::StringMatcherExact::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig do
+        params(
+          exact: String,
+          type: Cadenya::StringMatcherExact::Type::OrSymbol,
+          case_sensitive: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(exact:, type:, case_sensitive: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            exact: String,
+            type: Cadenya::StringMatcherExact::Type::OrSymbol,
+            case_sensitive: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::StringMatcherExact::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EXACT = T.let(:exact, Cadenya::StringMatcherExact::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::StringMatcherExact::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/string_matcher_regex.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcherRegex < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcherRegex, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :regex
+
+      sig { returns(Cadenya::StringMatcherRegex::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig do
+        params(
+          regex: String,
+          type: Cadenya::StringMatcherRegex::Type::OrSymbol,
+          case_sensitive: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(regex:, type:, case_sensitive: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            regex: String,
+            type: Cadenya::StringMatcherRegex::Type::OrSymbol,
+            case_sensitive: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::StringMatcherRegex::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        REGEX = T.let(:regex, Cadenya::StringMatcherRegex::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::StringMatcherRegex::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/string_matcher_starts_with.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class StringMatcherStartsWith < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::StringMatcherStartsWith, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :starts_with
+
+      sig { returns(Cadenya::StringMatcherStartsWith::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :case_sensitive
+
+      sig { params(case_sensitive: T::Boolean).void }
+      attr_writer :case_sensitive
+
+      sig do
+        params(
+          starts_with: String,
+          type: Cadenya::StringMatcherStartsWith::Type::OrSymbol,
+          case_sensitive: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(starts_with:, type:, case_sensitive: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            starts_with: String,
+            type: Cadenya::StringMatcherStartsWith::Type::OrSymbol,
+            case_sensitive: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cadenya::StringMatcherStartsWith::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STARTS_WITH =
+          T.let(
+            :startsWith,
+            Cadenya::StringMatcherStartsWith::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::StringMatcherStartsWith::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_called.rbi

@@ -16,20 +16,39 @@ module Cadenya
       # 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)) }
+      sig { returns(T.nilable(Cadenya::ToolSets::ToolSpecConfig::Variants)) }
       attr_reader :config
 
-      sig { params(config: Cadenya::ToolSets::ToolSpecConfig::OrHash).void }
+      sig do
+        params(
+          config:
+            T.any(
+              Cadenya::ToolSets::ToolSpecConfigHTTP::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigMCP::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigOpenAPI::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigBare::OrHash
+            )
+        ).void
+      end
       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)) }
+      sig { returns(T.nilable(Cadenya::CallableTool::Variants)) }
       attr_reader :tool
 
-      sig { params(tool: Cadenya::CallableTool::OrHash).void }
+      sig do
+        params(
+          tool:
+            T.any(
+              Cadenya::CallableToolTool::OrHash,
+              Cadenya::CallableToolAgent::OrHash,
+              Cadenya::CallableToolCadenyaProvidedTool::OrHash
+            )
+        ).void
+      end
       attr_writer :tool
 
       # The ID of the objective tool call record that was executed.
@@ -42,8 +61,19 @@ module Cadenya
       sig do
         params(
           arguments: T::Hash[Symbol, T.anything],
-          config: Cadenya::ToolSets::ToolSpecConfig::OrHash,
-          tool: Cadenya::CallableTool::OrHash,
+          config:
+            T.any(
+              Cadenya::ToolSets::ToolSpecConfigHTTP::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigMCP::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigOpenAPI::OrHash,
+              Cadenya::ToolSets::ToolSpecConfigBare::OrHash
+            ),
+          tool:
+            T.any(
+              Cadenya::CallableToolTool::OrHash,
+              Cadenya::CallableToolAgent::OrHash,
+              Cadenya::CallableToolCadenyaProvidedTool::OrHash
+            ),
           tool_call_id: String
         ).returns(T.attached_class)
       end
@@ -68,8 +98,8 @@ module Cadenya
         override.returns(
           {
             arguments: T::Hash[Symbol, T.anything],
-            config: Cadenya::ToolSets::ToolSpecConfig,
-            tool: Cadenya::CallableTool,
+            config: Cadenya::ToolSets::ToolSpecConfig::Variants,
+            tool: Cadenya::CallableTool::Variants,
             tool_call_id: String
           }
         )

data/rbi/cadenya/models/tool_set_adapter.rbi

@@ -2,73 +2,21 @@
 
 module Cadenya
   module Models
-    class ToolSetAdapter < Cadenya::Internal::Type::BaseModel
-      OrHash =
+    module ToolSetAdapter
+      extend Cadenya::Internal::Type::Union
+
+      Variants =
         T.type_alias do
-          T.any(Cadenya::ToolSetAdapter, Cadenya::Internal::AnyHash)
+          T.any(
+            Cadenya::ToolSetAdapterMCPVariant,
+            Cadenya::ToolSetAdapterHTTPVariant,
+            Cadenya::ToolSetAdapterOpenAPIVariant,
+            Cadenya::ToolSetAdapterBareVariant
+          )
         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
-
-      sig { params(http: Cadenya::ToolSetAdapterHTTP::OrHash).void }
-      attr_writer :http
-
-      sig { returns(T.nilable(Cadenya::ToolSetAdapterMcp)) }
-      attr_reader :mcp
-
-      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(
-          bare: Cadenya::ToolSetAdapterBare::OrHash,
-          http: Cadenya::ToolSetAdapterHTTP::OrHash,
-          mcp: Cadenya::ToolSetAdapterMcp::OrHash,
-          openapi: Cadenya::ToolSetAdapterOpenAPI::OrHash
-        ).returns(T.attached_class)
-      end
-      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
-          }
-        )
-      end
-      def to_hash
+      sig { override.returns(T::Array[Cadenya::ToolSetAdapter::Variants]) }
+      def self.variants
       end
     end
   end

data/rbi/cadenya/models/tool_set_adapter_bare_variant.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterBareVariant < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterBareVariant, 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(Cadenya::ToolSetAdapterBare) }
+      attr_reader :bare
+
+      sig { params(bare: Cadenya::ToolSetAdapterBare::OrHash).void }
+      attr_writer :bare
+
+      sig { returns(Cadenya::ToolSetAdapterBareVariant::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          bare: Cadenya::ToolSetAdapterBare::OrHash,
+          type: Cadenya::ToolSetAdapterBareVariant::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      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:,
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bare: Cadenya::ToolSetAdapterBare,
+            type: Cadenya::ToolSetAdapterBareVariant::Type::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterBareVariant::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        BARE =
+          T.let(:bare, Cadenya::ToolSetAdapterBareVariant::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterBareVariant::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_adapter_http_variant.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetAdapterHTTPVariant < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetAdapterHTTPVariant, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(Cadenya::ToolSetAdapterHTTP) }
+      attr_reader :http
+
+      sig { params(http: Cadenya::ToolSetAdapterHTTP::OrHash).void }
+      attr_writer :http
+
+      sig { returns(Cadenya::ToolSetAdapterHTTPVariant::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          http: Cadenya::ToolSetAdapterHTTP::OrHash,
+          type: Cadenya::ToolSetAdapterHTTPVariant::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(http:, type:)
+      end
+
+      sig do
+        override.returns(
+          {
+            http: Cadenya::ToolSetAdapterHTTP,
+            type: Cadenya::ToolSetAdapterHTTPVariant::Type::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cadenya::ToolSetAdapterHTTPVariant::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HTTP =
+          T.let(:http, Cadenya::ToolSetAdapterHTTPVariant::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cadenya::ToolSetAdapterHTTPVariant::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end