cerca 0.1.0

data/rbi/cerca/models/message.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class Message < Cerca::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Cerca::Message, Cerca::Internal::AnyHash) }
+
+      sig { returns(T::Array[Cerca::ContentBlock::Variants]) }
+      attr_accessor :content
+
+      sig { returns(String) }
+      attr_accessor :created_at
+
+      sig { returns(Cerca::Message::Role::TaggedSymbol) }
+      attr_accessor :role
+
+      sig { returns(Float) }
+      attr_accessor :seq
+
+      sig do
+        params(
+          content:
+            T::Array[
+              T.any(
+                Cerca::ContentBlock::TextContentBlock::OrHash,
+                Cerca::ContentBlock::ToolUseContentBlock::OrHash,
+                Cerca::ContentBlock::ToolResultContentBlock::OrHash,
+                Cerca::ContentBlock::ServerToolUseContentBlock::OrHash,
+                Cerca::ContentBlock::WebSearchToolResultContentBlock::OrHash
+              )
+            ],
+          created_at: String,
+          role: Cerca::Message::Role::OrSymbol,
+          seq: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(content:, created_at:, role:, seq:)
+      end
+
+      sig do
+        override.returns(
+          {
+            content: T::Array[Cerca::ContentBlock::Variants],
+            created_at: String,
+            role: Cerca::Message::Role::TaggedSymbol,
+            seq: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Role
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Cerca::Message::Role) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USER = T.let(:user, Cerca::Message::Role::TaggedSymbol)
+        ASSISTANT = T.let(:assistant, Cerca::Message::Role::TaggedSymbol)
+
+        sig { override.returns(T::Array[Cerca::Message::Role::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/metadata.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module Cerca
+  module Models
+    Metadata =
+      T.let(
+        Cerca::Internal::Type::HashOf[String],
+        Cerca::Internal::Type::Converter
+      )
+  end
+end

data/rbi/cerca/models/model_descriptor.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ModelDescriptor < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::ModelDescriptor, Cerca::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T::Array[String]) }
+      attr_accessor :capabilities
+
+      sig { returns(Float) }
+      attr_accessor :context_window_tokens
+
+      sig { returns(Float) }
+      attr_accessor :default_max_output_tokens
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Cerca::ModelDescriptor::Provider::TaggedSymbol) }
+      attr_accessor :provider
+
+      sig { returns(Float) }
+      attr_accessor :request_headroom_tokens
+
+      sig do
+        params(
+          id: String,
+          capabilities: T::Array[String],
+          context_window_tokens: Float,
+          default_max_output_tokens: Float,
+          name: String,
+          provider: Cerca::ModelDescriptor::Provider::OrSymbol,
+          request_headroom_tokens: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        capabilities:,
+        context_window_tokens:,
+        default_max_output_tokens:,
+        name:,
+        provider:,
+        request_headroom_tokens:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            capabilities: T::Array[String],
+            context_window_tokens: Float,
+            default_max_output_tokens: Float,
+            name: String,
+            provider: Cerca::ModelDescriptor::Provider::TaggedSymbol,
+            request_headroom_tokens: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Provider
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Cerca::ModelDescriptor::Provider) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ANTHROPIC =
+          T.let(:anthropic, Cerca::ModelDescriptor::Provider::TaggedSymbol)
+        OPENAI = T.let(:openai, Cerca::ModelDescriptor::Provider::TaggedSymbol)
+        GOOGLE = T.let(:google, Cerca::ModelDescriptor::Provider::TaggedSymbol)
+        FIREWORKS =
+          T.let(:fireworks, Cerca::ModelDescriptor::Provider::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::ModelDescriptor::Provider::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/model_list_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ModelListParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias { T.any(Cerca::ModelListParams, Cerca::Internal::AnyHash) }
+
+      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/model_list_response.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ModelListResponse < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::Models::ModelListResponse, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[Cerca::ModelDescriptor]) }
+      attr_accessor :models
+
+      sig do
+        params(models: T::Array[Cerca::ModelDescriptor::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(models:)
+      end
+
+      sig { override.returns({ models: T::Array[Cerca::ModelDescriptor] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/no_tool_source_auth.rbi

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

data/rbi/cerca/models/oauth_connect_params.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class OAuthConnectParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::OAuthConnectParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :provider
+
+      # 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
+
+      # HTTP(S) origin that receives the OAuth completion message.
+      sig { returns(String) }
+      attr_accessor :return_origin
+
+      # Provider-specific OAuth scopes. Empty entries are ignored after trimming.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :scopes
+
+      sig { params(scopes: T::Array[String]).void }
+      attr_writer :scopes
+
+      sig do
+        params(
+          provider: String,
+          owner:
+            T.any(
+              Cerca::ConnectionOwner::OrganizationConnectionOwner::OrHash,
+              Cerca::ConnectionOwner::FleetConnectionOwner::OrHash
+            ),
+          return_origin: String,
+          scopes: T::Array[String],
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        provider:,
+        # Public owner for a reusable connection. Organization owners use the
+        # authenticated organization; fleet owners add a fleetId.
+        owner:,
+        # HTTP(S) origin that receives the OAuth completion message.
+        return_origin:,
+        # Provider-specific OAuth scopes. Empty entries are ignored after trimming.
+        scopes: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            provider: String,
+            owner:
+              T.any(
+                Cerca::ConnectionOwner::OrganizationConnectionOwner,
+                Cerca::ConnectionOwner::FleetConnectionOwner
+              ),
+            return_origin: String,
+            scopes: T::Array[String],
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/oauth_connect_response.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class OAuthConnectResponse < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::OAuthConnectResponse, Cerca::Internal::AnyHash)
+        end
+
+      # Provider authorization URL that the client should open.
+      sig { returns(String) }
+      attr_accessor :authorization_url
+
+      # Origin hosting the OAuth callback endpoint.
+      sig { returns(String) }
+      attr_accessor :callback_origin
+
+      # OAuth state expiration timestamp, when returned.
+      sig { returns(T.nilable(String)) }
+      attr_reader :expires_at
+
+      sig { params(expires_at: String).void }
+      attr_writer :expires_at
+
+      # OAuth state nonce, when returned.
+      sig { returns(T.nilable(String)) }
+      attr_reader :state_nonce
+
+      sig { params(state_nonce: String).void }
+      attr_writer :state_nonce
+
+      sig do
+        params(
+          authorization_url: String,
+          callback_origin: String,
+          expires_at: String,
+          state_nonce: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Provider authorization URL that the client should open.
+        authorization_url:,
+        # Origin hosting the OAuth callback endpoint.
+        callback_origin:,
+        # OAuth state expiration timestamp, when returned.
+        expires_at: nil,
+        # OAuth state nonce, when returned.
+        state_nonce: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            authorization_url: String,
+            callback_origin: String,
+            expires_at: String,
+            state_nonce: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/oauth_connection_tool_source_auth.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class OAuthConnectionToolSourceAuth < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::OAuthConnectionToolSourceAuth, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(Symbol) }
+      attr_accessor :kind
+
+      sig { returns(String) }
+      attr_accessor :provider
+
+      # Where an API key or OAuth access token should be injected into outgoing
+      # tool-source requests.
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Cerca::AuthInjection::HeaderAuthInjection,
+              Cerca::AuthInjection::QueryAuthInjection
+            )
+          )
+        )
+      end
+      attr_reader :inject
+
+      sig do
+        params(
+          inject:
+            T.any(
+              Cerca::AuthInjection::HeaderAuthInjection::OrHash,
+              Cerca::AuthInjection::QueryAuthInjection::OrHash
+            )
+        ).void
+      end
+      attr_writer :inject
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :required_scopes
+
+      sig { params(required_scopes: T::Array[String]).void }
+      attr_writer :required_scopes
+
+      sig do
+        params(
+          provider: String,
+          inject:
+            T.any(
+              Cerca::AuthInjection::HeaderAuthInjection::OrHash,
+              Cerca::AuthInjection::QueryAuthInjection::OrHash
+            ),
+          required_scopes: T::Array[String],
+          kind: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        provider:,
+        # Where an API key or OAuth access token should be injected into outgoing
+        # tool-source requests.
+        inject: nil,
+        required_scopes: nil,
+        kind: :oauth_connection
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            kind: Symbol,
+            provider: String,
+            inject:
+              T.any(
+                Cerca::AuthInjection::HeaderAuthInjection,
+                Cerca::AuthInjection::QueryAuthInjection
+              ),
+            required_scopes: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cerca/models/oauth_exchange_config.rbi

@@ -0,0 +1,185 @@
+# typed: strong
+
+module Cerca
+  module Models
+    # Source-owned OAuth exchange configuration. Public schemas use connection IDs for
+    # stored client secrets and assertions.
+    module OAuthExchangeConfig
+      extend Cerca::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Cerca::OAuthExchangeConfig::ClientCredentialsOAuthExchange,
+            Cerca::OAuthExchangeConfig::JwtBearerOAuthExchange
+          )
+        end
+
+      class ClientCredentialsOAuthExchange < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::OAuthExchangeConfig::ClientCredentialsOAuthExchange,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :client_id
+
+        sig { returns(String) }
+        attr_accessor :client_secret_connection_id
+
+        sig { returns(Symbol) }
+        attr_accessor :grant_type
+
+        sig { returns(String) }
+        attr_accessor :token_url
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :audience
+
+        sig { params(audience: String).void }
+        attr_writer :audience
+
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :extra_params
+
+        sig { params(extra_params: T::Hash[Symbol, String]).void }
+        attr_writer :extra_params
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :scopes
+
+        sig { params(scopes: T::Array[String]).void }
+        attr_writer :scopes
+
+        sig do
+          params(
+            client_id: String,
+            client_secret_connection_id: String,
+            token_url: String,
+            audience: String,
+            extra_params: T::Hash[Symbol, String],
+            scopes: T::Array[String],
+            grant_type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          client_id:,
+          client_secret_connection_id:,
+          token_url:,
+          audience: nil,
+          extra_params: nil,
+          scopes: nil,
+          grant_type: :client_credentials
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              client_id: String,
+              client_secret_connection_id: String,
+              grant_type: Symbol,
+              token_url: String,
+              audience: String,
+              extra_params: T::Hash[Symbol, String],
+              scopes: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class JwtBearerOAuthExchange < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::OAuthExchangeConfig::JwtBearerOAuthExchange,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :assertion_connection_id
+
+        sig { returns(String) }
+        attr_accessor :audience
+
+        sig { returns(Symbol) }
+        attr_accessor :grant_type
+
+        sig { returns(String) }
+        attr_accessor :issuer
+
+        sig { returns(String) }
+        attr_accessor :token_url
+
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :extra_params
+
+        sig { params(extra_params: T::Hash[Symbol, String]).void }
+        attr_writer :extra_params
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :scopes
+
+        sig { params(scopes: T::Array[String]).void }
+        attr_writer :scopes
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :subject
+
+        sig { params(subject: String).void }
+        attr_writer :subject
+
+        sig do
+          params(
+            assertion_connection_id: String,
+            audience: String,
+            issuer: String,
+            token_url: String,
+            extra_params: T::Hash[Symbol, String],
+            scopes: T::Array[String],
+            subject: String,
+            grant_type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          assertion_connection_id:,
+          audience:,
+          issuer:,
+          token_url:,
+          extra_params: nil,
+          scopes: nil,
+          subject: nil,
+          grant_type: :jwt_bearer
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              assertion_connection_id: String,
+              audience: String,
+              grant_type: Symbol,
+              issuer: String,
+              token_url: String,
+              extra_params: T::Hash[Symbol, String],
+              scopes: T::Array[String],
+              subject: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      sig { override.returns(T::Array[Cerca::OAuthExchangeConfig::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end