cerca 0.1.0

data/rbi/cerca/models/attached_connection.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class AttachedConnection < Cerca::Models::Connection
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::AttachedConnection, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :attached_at
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      sig do
+        params(attached_at: String, metadata: T::Hash[Symbol, String]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(attached_at:, metadata: nil)
+      end
+
+      sig do
+        override.returns(
+          { attached_at: String, metadata: T::Hash[Symbol, String] }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/auth_context_params.rbi

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

data/rbi/cerca/models/auth_context_response.rbi

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

data/rbi/cerca/models/auth_fleets_response.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class AuthFleetsResponse < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::AuthFleetsResponse, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :cursor
+
+      sig { returns(T::Array[Cerca::Fleet]) }
+      attr_accessor :fleets
+
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      sig do
+        params(
+          cursor: T.nilable(String),
+          fleets: T::Array[Cerca::Fleet::OrHash],
+          has_more: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(cursor:, fleets:, has_more:)
+      end
+
+      sig do
+        override.returns(
+          {
+            cursor: T.nilable(String),
+            fleets: T::Array[Cerca::Fleet],
+            has_more: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/auth_injection.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Cerca
+  module Models
+    # Where an API key or OAuth access token should be injected into outgoing
+    # tool-source requests.
+    module AuthInjection
+      extend Cerca::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Cerca::AuthInjection::HeaderAuthInjection,
+            Cerca::AuthInjection::QueryAuthInjection
+          )
+        end
+
+      class HeaderAuthInjection < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::AuthInjection::HeaderAuthInjection,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :location
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Optional value template. For OAuth connection auth, use values such as
+        # `Bearer ${token}`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :value
+
+        sig { params(value: String).void }
+        attr_writer :value
+
+        sig do
+          params(name: String, value: String, location: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          name:,
+          # Optional value template. For OAuth connection auth, use values such as
+          # `Bearer ${token}`.
+          value: nil,
+          location: :header
+        )
+        end
+
+        sig do
+          override.returns({ location: Symbol, name: String, value: String })
+        end
+        def to_hash
+        end
+      end
+
+      class QueryAuthInjection < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::AuthInjection::QueryAuthInjection,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :location
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { params(name: String, location: Symbol).returns(T.attached_class) }
+        def self.new(name:, location: :query)
+        end
+
+        sig { override.returns({ location: Symbol, name: String }) }
+        def to_hash
+        end
+      end
+
+      sig { override.returns(T::Array[Cerca::AuthInjection::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/cerca/models/auth_list_fleets_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class AuthListFleetsParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::AuthListFleetsParams, Cerca::Internal::AnyHash)
+        end
+
+      # 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
+
+      sig do
+        params(
+          cursor: String,
+          limit: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            cursor: String,
+            limit: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/compiled_context.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class CompiledContext < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::CompiledContext, Cerca::Internal::AnyHash) }
+
+      sig { returns(T.nilable(T::Array[Cerca::ToolName::TaggedSymbol])) }
+      attr_accessor :enabled_tools
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :system_prompt
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :turn_id
+
+      sig do
+        params(
+          enabled_tools: T.nilable(T::Array[Cerca::ToolName::OrSymbol]),
+          system_prompt: T.nilable(String),
+          turn_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(enabled_tools:, system_prompt:, turn_id:)
+      end
+
+      sig do
+        override.returns(
+          {
+            enabled_tools: T.nilable(T::Array[Cerca::ToolName::TaggedSymbol]),
+            system_prompt: T.nilable(String),
+            turn_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/configuration.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class Configuration < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::Configuration, Cerca::Internal::AnyHash) }
+
+      sig { returns(T.nilable(Cerca::ApprovalPolicy)) }
+      attr_reader :approvals
+
+      sig { params(approvals: Cerca::ApprovalPolicy::OrHash).void }
+      attr_writer :approvals
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :default_model
+
+      sig { params(default_model: String).void }
+      attr_writer :default_model
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :instructions
+
+      sig { params(instructions: String).void }
+      attr_writer :instructions
+
+      # Agent tool allowlist. These tools are subject to fleet defaults and locks, and
+      # thread or turn requests may only narrow the resulting 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(
+          approvals: Cerca::ApprovalPolicy::OrHash,
+          default_model: String,
+          instructions: String,
+          tools: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        approvals: nil,
+        default_model: nil,
+        instructions: nil,
+        # Agent tool allowlist. These tools are subject to fleet defaults and locks, and
+        # thread or turn requests may only narrow the resulting effective tools.
+        tools: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            approvals: Cerca::ApprovalPolicy,
+            default_model: String,
+            instructions: String,
+            tools: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/configuration_field_name.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Cerca
+  module Models
+    module ConfigurationFieldName
+      extend Cerca::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Cerca::ConfigurationFieldName) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      DEFAULT_MODEL =
+        T.let(:defaultModel, Cerca::ConfigurationFieldName::TaggedSymbol)
+      INSTRUCTIONS =
+        T.let(:instructions, Cerca::ConfigurationFieldName::TaggedSymbol)
+      TOOLS = T.let(:tools, Cerca::ConfigurationFieldName::TaggedSymbol)
+      APPROVALS = T.let(:approvals, Cerca::ConfigurationFieldName::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Cerca::ConfigurationFieldName::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/cerca/models/connection.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class Connection < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::Connection, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :account_label
+
+      sig { returns(String) }
+      attr_accessor :created_at
+
+      # Public owner for a reusable connection. Organization owners use the
+      # authenticated organization; fleet owners add a fleetId.
+      sig { returns(Cerca::ConnectionOwner::Variants) }
+      attr_accessor :owner
+
+      sig { returns(Cerca::CredentialProvider::TaggedSymbol) }
+      attr_accessor :provider
+
+      sig { returns(T::Array[String]) }
+      attr_accessor :scopes
+
+      sig { returns(Cerca::CredentialType::TaggedSymbol) }
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          id: String,
+          account_label: T.nilable(String),
+          created_at: String,
+          owner:
+            T.any(
+              Cerca::ConnectionOwner::OrganizationConnectionOwner::OrHash,
+              Cerca::ConnectionOwner::FleetConnectionOwner::OrHash
+            ),
+          provider: Cerca::CredentialProvider::OrSymbol,
+          scopes: T::Array[String],
+          type: Cerca::CredentialType::OrSymbol,
+          updated_at: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        account_label:,
+        created_at:,
+        # Public owner for a reusable connection. Organization owners use the
+        # authenticated organization; fleet owners add a fleetId.
+        owner:,
+        provider:,
+        scopes:,
+        type:,
+        updated_at:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            account_label: T.nilable(String),
+            created_at: String,
+            owner: Cerca::ConnectionOwner::Variants,
+            provider: Cerca::CredentialProvider::TaggedSymbol,
+            scopes: T::Array[String],
+            type: Cerca::CredentialType::TaggedSymbol,
+            updated_at: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/connection_attach_params.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ConnectionAttachParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ConnectionAttachParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(String) }
+      attr_accessor :connection_id
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      sig do
+        params(
+          agent_id: String,
+          connection_id: String,
+          metadata: T::Hash[Symbol, String],
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        connection_id:,
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            connection_id: String,
+            metadata: T::Hash[Symbol, String],
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/connection_create_params.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ConnectionCreateParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::ConnectionCreateParams, Cerca::Internal::AnyHash)
+        end
+
+      # API key secret. It is stored securely and is not returned.
+      sig { returns(String) }
+      attr_accessor :api_key
+
+      # Public owner for a reusable connection. Organization owners use the
+      # authenticated organization; fleet owners add a fleetId.
+      sig do
+        returns(
+          T.any(
+            Cerca::ConnectionOwner::OrganizationConnectionOwner,
+            Cerca::ConnectionOwner::FleetConnectionOwner
+          )
+        )
+      end
+      attr_accessor :owner
+
+      # Credential provider to store an API key for.
+      sig { returns(String) }
+      attr_accessor :provider
+
+      # Optional human-readable account label.
+      sig { returns(T.nilable(String)) }
+      attr_reader :account_label
+
+      sig { params(account_label: String).void }
+      attr_writer :account_label
+
+      sig do
+        params(
+          api_key: String,
+          owner:
+            T.any(
+              Cerca::ConnectionOwner::OrganizationConnectionOwner::OrHash,
+              Cerca::ConnectionOwner::FleetConnectionOwner::OrHash
+            ),
+          provider: String,
+          account_label: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # API key secret. It is stored securely and is not returned.
+        api_key:,
+        # Public owner for a reusable connection. Organization owners use the
+        # authenticated organization; fleet owners add a fleetId.
+        owner:,
+        # Credential provider to store an API key for.
+        provider:,
+        # Optional human-readable account label.
+        account_label: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            api_key: String,
+            owner:
+              T.any(
+                Cerca::ConnectionOwner::OrganizationConnectionOwner,
+                Cerca::ConnectionOwner::FleetConnectionOwner
+              ),
+            provider: String,
+            account_label: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end