cerca 0.1.0

data/rbi/cerca/models/thread.rbi

@@ -0,0 +1,218 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class Thread < Cerca::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Cerca::Thread, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(T.nilable(Cerca::CompiledContext)) }
+      attr_reader :compiled_context
+
+      sig do
+        params(compiled_context: T.nilable(Cerca::CompiledContext::OrHash)).void
+      end
+      attr_writer :compiled_context
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :completed_at
+
+      sig { returns(String) }
+      attr_accessor :created_at
+
+      sig { returns(Float) }
+      attr_accessor :depth
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :error
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :instructions
+
+      sig { returns(T.nilable(Cerca::Thread::LastTurnStatus::TaggedSymbol)) }
+      attr_accessor :last_turn_status
+
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { returns(T::Array[Cerca::Message]) }
+      attr_accessor :messages
+
+      sig { returns(String) }
+      attr_accessor :model
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :parent_thread_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :result
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :schedule_id
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :schedule_seq
+
+      # `idle` threads can accept a new turn or be closed. `running` threads have an
+      # active turn. `awaiting` threads are paused on external input such as approvals.
+      # `closed` threads are terminal.
+      sig { returns(Cerca::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(T::Array[Cerca::SubThreadSummary]) }
+      attr_accessor :sub_threads
+
+      sig { returns(T::Array[Cerca::ToolName::TaggedSymbol]) }
+      attr_accessor :tools
+
+      sig { returns(T::Array[Cerca::Turn]) }
+      attr_accessor :turns
+
+      sig { returns(String) }
+      attr_accessor :updated_at
+
+      sig do
+        returns(T.nilable(Cerca::Thread::ExternalToolNamespaces::Variants))
+      end
+      attr_reader :external_tool_namespaces
+
+      sig do
+        params(external_tool_namespaces: T.any(Symbol, T::Array[String])).void
+      end
+      attr_writer :external_tool_namespaces
+
+      sig do
+        params(
+          id: String,
+          agent_id: String,
+          compiled_context: T.nilable(Cerca::CompiledContext::OrHash),
+          completed_at: T.nilable(String),
+          created_at: String,
+          depth: Float,
+          error: T.nilable(String),
+          instructions: T.nilable(String),
+          last_turn_status: T.nilable(Cerca::Thread::LastTurnStatus::OrSymbol),
+          message: String,
+          messages: T::Array[Cerca::Message::OrHash],
+          model: String,
+          parent_thread_id: T.nilable(String),
+          result: T.nilable(String),
+          schedule_id: T.nilable(String),
+          schedule_seq: T.nilable(Float),
+          status: Cerca::Status::OrSymbol,
+          sub_threads: T::Array[Cerca::SubThreadSummary::OrHash],
+          tools: T::Array[Cerca::ToolName::OrSymbol],
+          turns: T::Array[Cerca::Turn::OrHash],
+          updated_at: String,
+          external_tool_namespaces: T.any(Symbol, T::Array[String])
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        agent_id:,
+        compiled_context:,
+        completed_at:,
+        created_at:,
+        depth:,
+        error:,
+        instructions:,
+        last_turn_status:,
+        message:,
+        messages:,
+        model:,
+        parent_thread_id:,
+        result:,
+        schedule_id:,
+        schedule_seq:,
+        # `idle` threads can accept a new turn or be closed. `running` threads have an
+        # active turn. `awaiting` threads are paused on external input such as approvals.
+        # `closed` threads are terminal.
+        status:,
+        sub_threads:,
+        tools:,
+        turns:,
+        updated_at:,
+        external_tool_namespaces: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            agent_id: String,
+            compiled_context: T.nilable(Cerca::CompiledContext),
+            completed_at: T.nilable(String),
+            created_at: String,
+            depth: Float,
+            error: T.nilable(String),
+            instructions: T.nilable(String),
+            last_turn_status:
+              T.nilable(Cerca::Thread::LastTurnStatus::TaggedSymbol),
+            message: String,
+            messages: T::Array[Cerca::Message],
+            model: String,
+            parent_thread_id: T.nilable(String),
+            result: T.nilable(String),
+            schedule_id: T.nilable(String),
+            schedule_seq: T.nilable(Float),
+            status: Cerca::Status::TaggedSymbol,
+            sub_threads: T::Array[Cerca::SubThreadSummary],
+            tools: T::Array[Cerca::ToolName::TaggedSymbol],
+            turns: T::Array[Cerca::Turn],
+            updated_at: String,
+            external_tool_namespaces:
+              Cerca::Thread::ExternalToolNamespaces::Variants
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module LastTurnStatus
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::Thread::LastTurnStatus) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COMPLETED =
+          T.let(:completed, Cerca::Thread::LastTurnStatus::TaggedSymbol)
+        FAILED = T.let(:failed, Cerca::Thread::LastTurnStatus::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::Thread::LastTurnStatus::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module ExternalToolNamespaces
+        extend Cerca::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(Symbol, T::Array[String]) }
+
+        sig do
+          override.returns(
+            T::Array[Cerca::Thread::ExternalToolNamespaces::Variants]
+          )
+        end
+        def self.variants
+        end
+
+        StringArray =
+          T.let(
+            Cerca::Internal::Type::ArrayOf[String],
+            Cerca::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/cerca/models/thread_cancel_params.rbi

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

data/rbi/cerca/models/thread_close_params.rbi

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

data/rbi/cerca/models/thread_compact_params.rbi

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

data/rbi/cerca/models/thread_create_params.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ThreadCreateParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ThreadCreateParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :instructions
+
+      sig { params(instructions: String).void }
+      attr_writer :instructions
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :model
+
+      sig { params(model: String).void }
+      attr_writer :model
+
+      # Deprecated alias for `instructions`; accepted for backwards compatibility.
+      sig { returns(T.nilable(String)) }
+      attr_reader :system_prompt
+
+      sig { params(system_prompt: String).void }
+      attr_writer :system_prompt
+
+      # Per-thread tool subset. Omit to inherit the agent's full effective tools; pass
+      # [] to run with no configurable tools. Provided entries can only narrow the
+      # agent's effective tools.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :tools
+
+      sig { params(tools: T::Array[String]).void }
+      attr_writer :tools
+
+      sig do
+        params(
+          agent_id: String,
+          instructions: String,
+          message: String,
+          model: String,
+          system_prompt: String,
+          tools: T::Array[String],
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        instructions: nil,
+        message: nil,
+        model: nil,
+        # Deprecated alias for `instructions`; accepted for backwards compatibility.
+        system_prompt: nil,
+        # Per-thread tool subset. Omit to inherit the agent's full effective tools; pass
+        # [] to run with no configurable tools. Provided entries can only narrow the
+        # agent's effective tools.
+        tools: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            instructions: String,
+            message: String,
+            model: String,
+            system_prompt: String,
+            tools: T::Array[String],
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/thread_list_params.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ThreadListParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ThreadListParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      # Opaque pagination cursor returned by a previous request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Maximum number of items to return. Defaults to 20 and preserves parseInt
+      # semantics.
+      sig { returns(T.nilable(String)) }
+      attr_reader :limit
+
+      sig { params(limit: String).void }
+      attr_writer :limit
+
+      # Optional schedule id filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :schedule_id
+
+      sig { params(schedule_id: String).void }
+      attr_writer :schedule_id
+
+      # Optional thread status filter.
+      sig { returns(T.nilable(Cerca::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Cerca::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          agent_id: String,
+          cursor: String,
+          limit: String,
+          schedule_id: String,
+          status: Cerca::Status::OrSymbol,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Maximum number of items to return. Defaults to 20 and preserves parseInt
+        # semantics.
+        limit: nil,
+        # Optional schedule id filter.
+        schedule_id: nil,
+        # Optional thread status filter.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            cursor: String,
+            limit: String,
+            schedule_id: String,
+            status: Cerca::Status::OrSymbol,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/thread_retrieve_params.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ThreadRetrieveParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ThreadRetrieveParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(String) }
+      attr_accessor :thread_id
+
+      # When true, includes debug-only compiled context fields.
+      sig { returns(T.nilable(Cerca::ThreadRetrieveParams::Debug::OrSymbol)) }
+      attr_reader :debug
+
+      sig { params(debug: Cerca::ThreadRetrieveParams::Debug::OrSymbol).void }
+      attr_writer :debug
+
+      # When true, includes message content in the thread detail.
+      sig do
+        returns(
+          T.nilable(Cerca::ThreadRetrieveParams::IncludeMessages::OrSymbol)
+        )
+      end
+      attr_reader :include_messages
+
+      sig do
+        params(
+          include_messages:
+            Cerca::ThreadRetrieveParams::IncludeMessages::OrSymbol
+        ).void
+      end
+      attr_writer :include_messages
+
+      sig do
+        params(
+          agent_id: String,
+          thread_id: String,
+          debug: Cerca::ThreadRetrieveParams::Debug::OrSymbol,
+          include_messages:
+            Cerca::ThreadRetrieveParams::IncludeMessages::OrSymbol,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        thread_id:,
+        # When true, includes debug-only compiled context fields.
+        debug: nil,
+        # When true, includes message content in the thread detail.
+        include_messages: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            thread_id: String,
+            debug: Cerca::ThreadRetrieveParams::Debug::OrSymbol,
+            include_messages:
+              Cerca::ThreadRetrieveParams::IncludeMessages::OrSymbol,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, includes debug-only compiled context fields.
+      module Debug
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::ThreadRetrieveParams::Debug) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE = T.let(:true, Cerca::ThreadRetrieveParams::Debug::TaggedSymbol)
+        FALSE = T.let(:false, Cerca::ThreadRetrieveParams::Debug::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::ThreadRetrieveParams::Debug::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # When true, includes message content in the thread detail.
+      module IncludeMessages
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::ThreadRetrieveParams::IncludeMessages)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(
+            :true,
+            Cerca::ThreadRetrieveParams::IncludeMessages::TaggedSymbol
+          )
+        FALSE =
+          T.let(
+            :false,
+            Cerca::ThreadRetrieveParams::IncludeMessages::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Cerca::ThreadRetrieveParams::IncludeMessages::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end