Class: Prescient::Configuration

Inherits:
Object
  • Object
show all
Defined in:
lib/prescient.rb

Overview

Configuration class for managing Prescient settings and providers

Handles global settings like timeouts and retry behavior, as well as provider registration and instantiation.

Constant Summary collapse

DEFAULT_SENSITIVE_KEYS =

Returns Built-in provider option keys removed from output.

Returns:

  • (Array<Symbol>) —

    Built-in provider option keys removed from output

[:api_key, :password, :token, :secret].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Configuration

Initialize configuration with default values



136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/prescient.rb', line 136

def initialize
  @default_provider = :ollama
  @timeout = 30
  @retry_attempts = 3
  @retry_delay = 1.0
  @fallback_providers = []
  @sensitive_keys = []
  @providers = {}
  @provider_instances = {} # : Hash[Symbol, untyped]
  @tools = {}
  @tool_instances = {} # : Hash[Symbol, untyped]
end

Instance Attribute Details

#default_provider ⇒ Symbol

Returns The default provider to use when none specified.

Returns:

  • (Symbol) —

    The default provider to use when none specified



112
113
114
 
# File 'lib/prescient.rb', line 112

def default_provider
  @default_provider
end

#fallback_providers ⇒ Array<Symbol>

Returns List of fallback providers to try when primary fails.

Returns:

  • (Array<Symbol>) —

    List of fallback providers to try when primary fails



124
125
126
 
# File 'lib/prescient.rb', line 124

def fallback_providers
  @fallback_providers
end

#providers ⇒ Hash (readonly)

Returns Registered providers configuration.

Returns:

  • (Hash) —

    Registered providers configuration



130
131
132
 
# File 'lib/prescient.rb', line 130

def providers
  @providers
end

#retry_attempts ⇒ Integer

Returns Number of retry attempts for failed requests.

Returns:

  • (Integer) —

    Number of retry attempts for failed requests



118
119
120
 
# File 'lib/prescient.rb', line 118

def retry_attempts
  @retry_attempts
end

#retry_delay ⇒ Float

Returns Delay between retry attempts in seconds.

Returns:

  • (Float) —

    Delay between retry attempts in seconds



121
122
123
 
# File 'lib/prescient.rb', line 121

def retry_delay
  @retry_delay
end

#sensitive_keys ⇒ Array<Symbol>

Returns Additional keys removed from provider information.

Returns:

  • (Array<Symbol>) —

    Additional keys removed from provider information



127
128
129
 
# File 'lib/prescient.rb', line 127

def sensitive_keys
  @sensitive_keys
end

#timeout ⇒ Integer

Returns Default timeout in seconds for API requests.

Returns:

  • (Integer) —

    Default timeout in seconds for API requests



115
116
117
 
# File 'lib/prescient.rb', line 115

def timeout
  @timeout
end

#tools ⇒ Hash (readonly)

Returns Registered tools configuration.

Returns:

  • (Hash) —

    Registered tools configuration



133
134
135
 
# File 'lib/prescient.rb', line 133

def tools
  @tools
end

Instance Method Details

#add_provider(name, provider_class, **options) ⇒ void

This method returns an undefined value.

Register a new AI provider

Examples:

Add OpenAI provider

config.add_provider(:openai, Prescient::Provider::OpenAI,
                    api_key: 'sk-...',
                    chat_model: 'gpt-4.1-mini')

Parameters:

  • name (Symbol) —

    Unique identifier for the provider

  • provider_class (Class) —

    Provider class that inherits from Base

  • options (Hash) —

    Configuration options for the provider

Options Hash (**options):

  • :api_key (String) —

    API key for authenticated providers

  • :url (String) —

    Base URL for self-hosted providers

  • :model, (String) —

    :chat_model Model name for text generation

  • :embedding_model (String) —

    Model name for embeddings



173
174
175
176
177
178
179
180
 
# File 'lib/prescient.rb', line 173

def add_provider(name, provider_class, **options)
  provider_name = name.to_sym
  @providers[provider_name] = {
    class:   provider_class,
    options: options,
  }
  @provider_instances.delete(provider_name)
end

#add_tool(name, tool_class, **options) ⇒ void

This method returns an undefined value.

Register an external tool.

Parameters:

  • name (Symbol) —

    Unique identifier for the tool

  • tool_class (Class) —

    Tool adapter class

  • options (Hash) —

    Tool-specific configuration options



200
201
202
203
204
205
206
207
 
# File 'lib/prescient.rb', line 200

def add_tool(name, tool_class, **options)
  tool_name = name.to_sym
  @tools[tool_name] = {
    class:   tool_class,
    options: options,
  }
  @tool_instances.delete(tool_name)
end

#add_tool_group(name, adapters) ⇒ void

This method returns an undefined value.

Register ordered implementations for one logical external tool.

Parameters:

  • name (Symbol) —

    Unique logical capability identifier

  • adapters (Array<Hash>) —

    Adapter class and option configurations



213
214
215
216
217
 
# File 'lib/prescient.rb', line 213

def add_tool_group(name, adapters)
  tool_name = name.to_sym
  @tools[tool_name] = { adapters: adapters }
  @tool_instances.delete(tool_name)
end

#available_providers ⇒ Array<Symbol>

Get list of providers that currently pass Base#available?.

Providers are included when their health check reports reachable: true, or, for legacy adapters, status == "healthy".

Returns:

  • (Array<Symbol>) —

    List of reachable provider names



247
248
249
250
251
252
253
 
# File 'lib/prescient.rb', line 247

def available_providers
  @providers.keys.select do |name|
    provider(name)&.available?
  rescue StandardError
    false
  end
end

#provider(name) ⇒ Base?

Instantiate a provider by name

Parameters:

  • name (Symbol) —

    The provider name

Returns:

  • (Base, nil) —

    Provider instance or nil if not found



186
187
188
189
190
191
192
193
 
# File 'lib/prescient.rb', line 186

def provider(name)
  provider_name = name.to_sym
  provider_config = @providers[provider_name]
  return nil unless provider_config

  provider_options = provider_config[:options] # : Hash[Symbol, untyped]
  @provider_instances[provider_name] ||= provider_config[:class].new(**provider_options)
end

#tool(name) ⇒ Prescient::Tool::Base?

Instantiate a tool by name.

Parameters:

  • name (Symbol, String) —

    Tool name

Returns:



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/prescient.rb', line 222

def tool(name)
  tool_name = name.to_sym
  tool_config = @tools[tool_name]
  return nil unless tool_config

  if tool_config[:adapters]
    @tool_instances[tool_name] ||= Prescient::Tool::Group.new(
      adapters: tool_config[:adapters].map do |adapter|
        adapter_options = adapter[:options] # : Hash[Symbol, untyped]
        adapter[:class].new(**adapter_options)
      end,
    )
    return @tool_instances[tool_name]
  end

  tool_options = tool_config[:options] # : Hash[Symbol, untyped]
  @tool_instances[tool_name] ||= tool_config[:class].new(**tool_options)
end