cerca 0.1.0

data/rbi/cerca/models/credential_type.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Cerca
+  module Models
+    module CredentialType
+      extend Cerca::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Cerca::CredentialType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      OAUTH = T.let(:oauth, Cerca::CredentialType::TaggedSymbol)
+      API_KEY = T.let(:api_key, Cerca::CredentialType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Cerca::CredentialType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/cerca/models/discovered_tool.rbi

@@ -0,0 +1,156 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class DiscoveredTool < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::DiscoveredTool, Cerca::Internal::AnyHash) }
+
+      sig { returns(Cerca::DiscoveredTool::Approval::TaggedSymbol) }
+      attr_accessor :approval
+
+      sig { returns(Symbol) }
+      attr_accessor :category
+
+      sig { returns(String) }
+      attr_accessor :description
+
+      # JSON Schema object describing tool input parameters.
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :input_schema
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Cerca::DiscoveredTool::Origin::TaggedSymbol) }
+      attr_accessor :origin
+
+      sig { returns(String) }
+      attr_accessor :source
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :account_label
+
+      sig { params(account_label: String).void }
+      attr_writer :account_label
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :connection_id
+
+      sig { params(connection_id: String).void }
+      attr_writer :connection_id
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :connection_metadata
+
+      sig { params(connection_metadata: T::Hash[Symbol, String]).void }
+      attr_writer :connection_metadata
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :source_id
+
+      sig { params(source_id: String).void }
+      attr_writer :source_id
+
+      sig { returns(T.nilable(Float)) }
+      attr_reader :source_version
+
+      sig { params(source_version: Float).void }
+      attr_writer :source_version
+
+      # An external provider or tool-source tool currently available to the agent.
+      sig do
+        params(
+          approval: Cerca::DiscoveredTool::Approval::OrSymbol,
+          description: String,
+          input_schema: T::Hash[Symbol, T.anything],
+          name: String,
+          origin: Cerca::DiscoveredTool::Origin::OrSymbol,
+          source: String,
+          account_label: String,
+          connection_id: String,
+          connection_metadata: T::Hash[Symbol, String],
+          source_id: String,
+          source_version: Float,
+          category: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        approval:,
+        description:,
+        # JSON Schema object describing tool input parameters.
+        input_schema:,
+        name:,
+        origin:,
+        source:,
+        account_label: nil,
+        connection_id: nil,
+        connection_metadata: nil,
+        source_id: nil,
+        source_version: nil,
+        category: :external
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            approval: Cerca::DiscoveredTool::Approval::TaggedSymbol,
+            category: Symbol,
+            description: String,
+            input_schema: T::Hash[Symbol, T.anything],
+            name: String,
+            origin: Cerca::DiscoveredTool::Origin::TaggedSymbol,
+            source: String,
+            account_label: String,
+            connection_id: String,
+            connection_metadata: T::Hash[Symbol, String],
+            source_id: String,
+            source_version: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Approval
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::DiscoveredTool::Approval) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ALWAYS = T.let(:always, Cerca::DiscoveredTool::Approval::TaggedSymbol)
+        NEVER = T.let(:never, Cerca::DiscoveredTool::Approval::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::DiscoveredTool::Approval::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Origin
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::DiscoveredTool::Origin) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        BUILTIN = T.let(:builtin, Cerca::DiscoveredTool::Origin::TaggedSymbol)
+        TOOL_SOURCE =
+          T.let(:tool_source, Cerca::DiscoveredTool::Origin::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::DiscoveredTool::Origin::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/effective_configuration.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EffectiveConfiguration < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EffectiveConfiguration, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(Cerca::EffectiveConfiguration::Approvals) }
+      attr_reader :approvals
+
+      sig do
+        params(approvals: Cerca::EffectiveConfiguration::Approvals::OrHash).void
+      end
+      attr_writer :approvals
+
+      sig { returns(T::Boolean) }
+      attr_accessor :approvals_writable_by_agent
+
+      sig { returns(String) }
+      attr_accessor :default_model
+
+      sig { returns(T::Array[Cerca::ConfigurationFieldName::TaggedSymbol]) }
+      attr_accessor :locked_by_fleet
+
+      sig { returns(T::Array[Cerca::ConfigurationFieldName::TaggedSymbol]) }
+      attr_accessor :resolved_from_fleet
+
+      # Effective internal runtime tools after applying fleet defaults, fleet locks, and
+      # the agent allowlist.
+      sig { returns(T::Array[Cerca::ToolName::TaggedSymbol]) }
+      attr_accessor :tools
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :instructions
+
+      sig { params(instructions: String).void }
+      attr_writer :instructions
+
+      sig do
+        params(
+          approvals: Cerca::EffectiveConfiguration::Approvals::OrHash,
+          approvals_writable_by_agent: T::Boolean,
+          default_model: String,
+          locked_by_fleet: T::Array[Cerca::ConfigurationFieldName::OrSymbol],
+          resolved_from_fleet:
+            T::Array[Cerca::ConfigurationFieldName::OrSymbol],
+          tools: T::Array[Cerca::ToolName::OrSymbol],
+          instructions: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        approvals:,
+        approvals_writable_by_agent:,
+        default_model:,
+        locked_by_fleet:,
+        resolved_from_fleet:,
+        # Effective internal runtime tools after applying fleet defaults, fleet locks, and
+        # the agent allowlist.
+        tools:,
+        instructions: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            approvals: Cerca::EffectiveConfiguration::Approvals,
+            approvals_writable_by_agent: T::Boolean,
+            default_model: String,
+            locked_by_fleet:
+              T::Array[Cerca::ConfigurationFieldName::TaggedSymbol],
+            resolved_from_fleet:
+              T::Array[Cerca::ConfigurationFieldName::TaggedSymbol],
+            tools: T::Array[Cerca::ToolName::TaggedSymbol],
+            instructions: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Approvals < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::EffectiveConfiguration::Approvals,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :timeout_ms
+
+        sig { returns(T::Hash[Symbol, Cerca::ApprovalMode::TaggedSymbol]) }
+        attr_accessor :tools
+
+        sig do
+          params(
+            timeout_ms: Float,
+            tools: T::Hash[Symbol, Cerca::ApprovalMode::OrSymbol]
+          ).returns(T.attached_class)
+        end
+        def self.new(timeout_ms:, tools:)
+        end
+
+        sig do
+          override.returns(
+            {
+              timeout_ms: Float,
+              tools: T::Hash[Symbol, Cerca::ApprovalMode::TaggedSymbol]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/entry.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class Entry < Cerca::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Cerca::Entry, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :content
+
+      sig { returns(String) }
+      attr_accessor :key
+
+      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(
+          content: String,
+          key: String,
+          updated_at: String,
+          version: Float,
+          mime_type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(content:, key:, updated_at:, version:, mime_type: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            content: String,
+            key: String,
+            updated_at: String,
+            version: Float,
+            mime_type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/entry_summary.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EntrySummary < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::EntrySummary, Cerca::Internal::AnyHash) }
+
+      sig { returns(Float) }
+      attr_accessor :byte_length
+
+      sig { returns(String) }
+      attr_accessor :key
+
+      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,
+          updated_at: String,
+          version: Float,
+          mime_type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(byte_length:, key:, updated_at:, version:, mime_type: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            byte_length: Float,
+            key: String,
+            updated_at: String,
+            version: Float,
+            mime_type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/error_response.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ErrorResponse < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::ErrorResponse, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :error
+
+      # Stable machine-readable error code when the API can provide one.
+      sig { returns(T.nilable(String)) }
+      attr_reader :code
+
+      sig { params(code: String).void }
+      attr_writer :code
+
+      sig { params(error: String, code: String).returns(T.attached_class) }
+      def self.new(
+        error:,
+        # Stable machine-readable error code when the API can provide one.
+        code: nil
+      )
+      end
+
+      sig { override.returns({ error: String, code: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_list_for_agent_params.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventListForAgentParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EventListForAgentParams, 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
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(T.nilable(Cerca::EventListForAgentParams::History::OrSymbol))
+      end
+      attr_reader :history
+
+      sig do
+        params(history: Cerca::EventListForAgentParams::History::OrSymbol).void
+      end
+      attr_writer :history
+
+      # 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
+
+      sig do
+        params(
+          agent_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventListForAgentParams::History::OrSymbol,
+          limit: String,
+          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,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Maximum number of items to return. Defaults to 20 and preserves parseInt
+        # semantics.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventListForAgentParams::History::OrSymbol,
+            limit: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventListForAgentParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(:true, Cerca::EventListForAgentParams::History::TaggedSymbol)
+        FALSE =
+          T.let(:false, Cerca::EventListForAgentParams::History::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::EventListForAgentParams::History::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_list_for_fleet_params.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventListForFleetParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EventListForFleetParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :fleet_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
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(T.nilable(Cerca::EventListForFleetParams::History::OrSymbol))
+      end
+      attr_reader :history
+
+      sig do
+        params(history: Cerca::EventListForFleetParams::History::OrSymbol).void
+      end
+      attr_writer :history
+
+      # 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
+
+      sig do
+        params(
+          fleet_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventListForFleetParams::History::OrSymbol,
+          limit: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        fleet_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Maximum number of items to return. Defaults to 20 and preserves parseInt
+        # semantics.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            fleet_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventListForFleetParams::History::OrSymbol,
+            limit: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventListForFleetParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(:true, Cerca::EventListForFleetParams::History::TaggedSymbol)
+        FALSE =
+          T.let(:false, Cerca::EventListForFleetParams::History::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::EventListForFleetParams::History::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end