cerca 0.1.0

data/rbi/cerca/models/schedule_update_params.rbi

@@ -0,0 +1,132 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ScheduleUpdateParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ScheduleUpdateParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(String) }
+      attr_accessor :schedule_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :cron
+
+      sig { params(cron: String).void }
+      attr_writer :cron
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :enabled
+
+      sig { params(enabled: T::Boolean).void }
+      attr_writer :enabled
+
+      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
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :run_at
+
+      sig { params(run_at: Time).void }
+      attr_writer :run_at
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :timezone
+
+      sig { params(timezone: String).void }
+      attr_writer :timezone
+
+      # Per-schedule tool subset. When updated, these tools can only narrow the agent's
+      # effective tools for future scheduled threads.
+      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,
+          schedule_id: String,
+          cron: String,
+          enabled: T::Boolean,
+          instructions: String,
+          message: String,
+          model: String,
+          name: String,
+          run_at: Time,
+          timezone: String,
+          tools: T::Array[String],
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        schedule_id:,
+        cron: nil,
+        enabled: nil,
+        instructions: nil,
+        message: nil,
+        model: nil,
+        name: nil,
+        run_at: nil,
+        timezone: nil,
+        # Per-schedule tool subset. When updated, these tools can only narrow the agent's
+        # effective tools for future scheduled threads.
+        tools: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            schedule_id: String,
+            cron: String,
+            enabled: T::Boolean,
+            instructions: String,
+            message: String,
+            model: String,
+            name: String,
+            run_at: Time,
+            timezone: String,
+            tools: T::Array[String],
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/search_result.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class SearchResult < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::SearchResult, Cerca::Internal::AnyHash) }
+
+      sig { returns(Float) }
+      attr_accessor :byte_length
+
+      sig { returns(String) }
+      attr_accessor :key
+
+      sig { returns(Float) }
+      attr_accessor :score
+
+      sig { returns(String) }
+      attr_accessor :snippet
+
+      sig { returns(String) }
+      attr_accessor :updated_at
+
+      sig { returns(Float) }
+      attr_accessor :version
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :mime_type
+
+      sig { params(mime_type: String).void }
+      attr_writer :mime_type
+
+      sig do
+        params(
+          byte_length: Float,
+          key: String,
+          score: Float,
+          snippet: String,
+          updated_at: String,
+          version: Float,
+          mime_type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        byte_length:,
+        key:,
+        score:,
+        snippet:,
+        updated_at:,
+        version:,
+        mime_type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            byte_length: Float,
+            key: String,
+            score: Float,
+            snippet: String,
+            updated_at: String,
+            version: Float,
+            mime_type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/source_warning.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class SourceWarning < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::SourceWarning, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { returns(String) }
+      attr_accessor :source
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :source_id
+
+      sig { params(source_id: String).void }
+      attr_writer :source_id
+
+      sig do
+        params(message: String, source: String, source_id: String).returns(
+          T.attached_class
+        )
+      end
+      def self.new(message:, source:, source_id: nil)
+      end
+
+      sig do
+        override.returns({ message: String, source: String, source_id: String })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/status.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Cerca
+  module Models
+    # `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.
+    module Status
+      extend Cerca::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Cerca::Status) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      IDLE = T.let(:idle, Cerca::Status::TaggedSymbol)
+      RUNNING = T.let(:running, Cerca::Status::TaggedSymbol)
+      AWAITING = T.let(:awaiting, Cerca::Status::TaggedSymbol)
+      CLOSED = T.let(:closed, Cerca::Status::TaggedSymbol)
+
+      sig { override.returns(T::Array[Cerca::Status::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/cerca/models/steer_result.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class SteerResult < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::SteerResult, Cerca::Internal::AnyHash) }
+
+      sig { returns(Cerca::SteerResult::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # `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 :thread_status
+
+      sig { returns(String) }
+      attr_accessor :turn_id
+
+      sig do
+        params(
+          status: Cerca::SteerResult::Status::OrSymbol,
+          thread_status: Cerca::Status::OrSymbol,
+          turn_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        status:,
+        # `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.
+        thread_status:,
+        turn_id:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            status: Cerca::SteerResult::Status::TaggedSymbol,
+            thread_status: Cerca::Status::TaggedSymbol,
+            turn_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::SteerResult::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ENQUEUED = T.let(:enqueued, Cerca::SteerResult::Status::TaggedSymbol)
+        TURN_STARTED =
+          T.let(:turn_started, Cerca::SteerResult::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Cerca::SteerResult::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/sub_thread_summary.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class SubThreadSummary < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::SubThreadSummary, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :completed_at
+
+      sig { returns(String) }
+      attr_accessor :created_at
+
+      sig { returns(Float) }
+      attr_accessor :message_count
+
+      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
+
+      # `pending` means the parent thread is still waiting on this sub-thread. Other
+      # values are the child thread lifecycle state.
+      sig { returns(Cerca::SubThreadSummary::State::TaggedSymbol) }
+      attr_accessor :state
+
+      sig { returns(Float) }
+      attr_accessor :step_count
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tool_use_id
+
+      sig do
+        params(
+          id: String,
+          completed_at: T.nilable(String),
+          created_at: String,
+          message_count: Float,
+          model: String,
+          parent_thread_id: T.nilable(String),
+          result: T.nilable(String),
+          schedule_id: T.nilable(String),
+          schedule_seq: T.nilable(Float),
+          state: Cerca::SubThreadSummary::State::OrSymbol,
+          step_count: Float,
+          tool_use_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        completed_at:,
+        created_at:,
+        message_count:,
+        model:,
+        parent_thread_id:,
+        result:,
+        schedule_id:,
+        schedule_seq:,
+        # `pending` means the parent thread is still waiting on this sub-thread. Other
+        # values are the child thread lifecycle state.
+        state:,
+        step_count:,
+        tool_use_id:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            completed_at: T.nilable(String),
+            created_at: String,
+            message_count: Float,
+            model: String,
+            parent_thread_id: T.nilable(String),
+            result: T.nilable(String),
+            schedule_id: T.nilable(String),
+            schedule_seq: T.nilable(Float),
+            state: Cerca::SubThreadSummary::State::TaggedSymbol,
+            step_count: Float,
+            tool_use_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # `pending` means the parent thread is still waiting on this sub-thread. Other
+      # values are the child thread lifecycle state.
+      module State
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::SubThreadSummary::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:pending, Cerca::SubThreadSummary::State::TaggedSymbol)
+        IDLE = T.let(:idle, Cerca::SubThreadSummary::State::TaggedSymbol)
+        RUNNING = T.let(:running, Cerca::SubThreadSummary::State::TaggedSymbol)
+        AWAITING =
+          T.let(:awaiting, Cerca::SubThreadSummary::State::TaggedSymbol)
+        CLOSED = T.let(:closed, Cerca::SubThreadSummary::State::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::SubThreadSummary::State::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/subscription_event.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class SubscriptionEvent < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::SubscriptionEvent, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(Cerca::RuntimeWebhookEvent::Variants) }
+      attr_accessor :event
+
+      sig { returns(Float) }
+      attr_accessor :seq
+
+      sig do
+        params(
+          event:
+            T.any(
+              Cerca::RuntimeWebhookEvent::AgentCreatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::AgentUpdatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::AgentDeletedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ThreadCreatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ThreadStatusChangedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ThreadCompletedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ThreadFailedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::TurnCreatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::TurnCompletedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::TurnFailedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::MessageCreatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ApprovalRequestedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ApprovalResolvedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ApprovalGrantedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ScheduleCreatedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ScheduleDeletedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ScheduleTriggeredWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ConnectionAttachedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::ConnectionDetachedWebhookEvent::OrHash,
+              Cerca::RuntimeWebhookEvent::WebhookTestWebhookEvent::OrHash
+            ),
+          seq: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(event:, seq:)
+      end
+
+      sig do
+        override.returns(
+          { event: Cerca::RuntimeWebhookEvent::Variants, seq: Float }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end