Module: Riffer

Extended by:

Riffer, Agent::Run, Agent::Serializer, Agent::Session::Repair, Evals::EvaluatorRunner, Helpers::Boolean, Helpers::CallOrValue, Helpers::ClassNameConverter, Helpers::Dependencies, Mcp, Mcp::AuthenticatedTool, Mcp::Registry, Mcp::ToolFactory, Providers::Repository, Tracing, Tracing::Capture, Tracing::NoOp

Included in:

Riffer

Defined in:

lib/riffer/version.rb,
lib/riffer.rb,
sig/manual/riffer.rbs,
sig/generated/riffer.rbs,
sig/manual/riffer/mcp.rbs,
sig/generated/riffer/mcp.rbs,
sig/manual/riffer/tracing.rbs,
sig/generated/riffer/evals.rbs,
sig/generated/riffer/tools.rbs,
sig/generated/riffer/skills.rbs,
sig/manual/riffer/agent/run.rbs,
sig/manual/riffer/providers.rbs,
sig/generated/riffer/helpers.rbs,
sig/generated/riffer/tracing.rbs,
sig/generated/riffer/version.rbs,
sig/generated/riffer/messages.rbs,
sig/generated/riffer/agent/run.rbs,
sig/generated/riffer/providers.rbs,
sig/manual/riffer/mcp/registry.rbs,
sig/generated/riffer/guardrails.rbs,
sig/manual/riffer/tracing/no_op.rbs,
sig/generated/riffer/mcp/registry.rbs,
sig/manual/riffer/helpers/boolean.rbs,
sig/manual/riffer/tracing/capture.rbs,
sig/generated/riffer/stream_events.rbs,
sig/generated/riffer/tracing/no_op.rbs,
sig/manual/riffer/agent/serializer.rbs,
sig/manual/riffer/mcp/tool_factory.rbs,
sig/generated/riffer/params/boolean.rbs,
sig/generated/riffer/tools/toolable.rbs,
sig/generated/riffer/helpers/boolean.rbs,
sig/generated/riffer/tracing/capture.rbs,
sig/generated/riffer/agent/serializer.rbs,
sig/generated/riffer/mcp/tool_factory.rbs,
sig/manual/riffer/agent/session/repair.rbs,
sig/manual/riffer/helpers/dependencies.rbs,
sig/manual/riffer/providers/repository.rbs,
sig/manual/riffer/helpers/call_or_value.rbs,
sig/manual/riffer/evals/evaluator_runner.rbs,
sig/manual/riffer/mcp/authenticated_tool.rbs,
sig/generated/riffer/agent/session/repair.rbs,
sig/generated/riffer/helpers/dependencies.rbs,
sig/generated/riffer/providers/repository.rbs,
sig/generated/riffer/helpers/call_or_value.rbs,
sig/generated/riffer/evals/evaluator_runner.rbs,
sig/generated/riffer/mcp/authenticated_tool.rbs,
sig/manual/riffer/helpers/class_name_converter.rbs,
sig/generated/riffer/helpers/class_name_converter.rbs

Overview

Helper module for converting class names.

Defined Under Namespace

Modules: Evals, Guardrails, Helpers, Mcp, Messages, Providers, Skills, StreamEvents, Tools, Tracing Classes: Agent, ArgumentError, Config, CredentialsDeniedError, Error, Guardrail, LoadError, Params, Runner, Span, TimeoutError, Tool, ToolExecutionError, ValidationError, VersionError

Constant Summary

VERSION =

Signature:

• String

Returns:

• (String)

"0.39.0"

MUTEX =

Returns:

• (Mutex)

SCHEMA_URL =

The Ruby API cannot attach a schema URL to a tracer, so the semconv pin lives here as the documented contract version.

Returns:

• (String)

PHASES =

Returns:

• (Array[Symbol])

SPAN =

Returns:

• (Riffer::Tracing::NoOp::Span)

DEFAULT_TIMEOUT =

Returns:

• (Integer)

SCHEMA_VERSION =

The wire format version, bumped only on an incompatible change to the hash shape; from_h refuses any other version.

Returns:

• (Integer)

DEFAULT_TOOL_RESOLVER =

The default tool_resolver: synthesizes a body-less tool shell from a descriptor. Its #call raises — route shells through a remote runtime.

Returns:

• (^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool))

ORPHAN_PLACEHOLDER =

Placeholder response filled in for an orphaned tool_use on interrupt.

Returns:

• (^(Riffer::Messages::Assistant::ToolCall) -> Riffer::Tools::Response)

REPO =

Returns:

• (Hash[Symbol, ^() -> singleton(Riffer::Providers::Base)])

DEFAULT_SEPARATOR =

Returns:

• (String)

Class Method Summary

• .all ⇒ Array[Module]

  Returns all classes that have extended Toolable.

• .extended ⇒ void

  Tracks all classes that extend Toolable.

Instance Method Summary

• #accumulate_streamed_response ⇒ Riffer::Messages::Assistant

  -- : (Riffer::Agent, Enumerator::Yielder, ?Hash[String, String]) -> Riffer::Messages::Assistant.

• #append_user_message ⇒ void

  Raises when files are supplied without a prompt — the provider needs text to anchor the attachments.

• #assistant_parts ⇒ Array[Hash[Symbol, untyped]]

  -- : (String?, Array) -> Array[Hash[Symbol, untyped]].

• #backend ⇒ Object

  -- : () -> untyped.

• #build ⇒ Array[singleton(Riffer::Mcp::Tool)]

  Builds one Riffer::Mcp::Tool subclass per tool definition, prefixing names with the manifest name to avoid cross-server collisions (e.g. jira__search); the server-side name stays on .mcp_server_tool_name.

• #build_key_index ⇒ Hash[singleton(Riffer::Providers::Base), Symbol]

  -- : () -> Hash[singleton(Riffer::Providers::Base), Symbol].

• #build_response ⇒ Riffer::Agent::Response

  -- : (Riffer::Agent, String, ?tripwire: Riffer::Guardrails::Tripwire?, ?modifications: Array, ?interrupted: bool, ?interrupt_reason: (String | Symbol)?, ?structured_output: Hash[Symbol, untyped]?, ?healed_tool_call_ids: Array, ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response.

• #build_tool_class ⇒ singleton(Riffer::Mcp::Tool)

  : (String, Riffer::Mcp::Client, Hash[Symbol, untyped]) -> singleton(Riffer::Mcp::Tool).

• #build_tool_shell ⇒ Object

  -- : (Hash[Symbol, untyped]) -> untyped.

• #call_llm ⇒ Riffer::Messages::Assistant

  -- : (Riffer::Agent, ?Hash[String, String]) -> Riffer::Messages::Assistant.

• #call_llm_stream ⇒ Enumerator[Riffer::StreamEvents::Base, void]

  -- : (Riffer::Agent, ?Hash[String, String]) -> Enumerator[Riffer::StreamEvents::Base, void].

• #coerce ⇒ Boolean

  Coerces value to a boolean so an env-var "false" (truthy in Ruby) doesn't silently read as true.

• #config ⇒ Riffer::Config

  Returns the Riffer configuration.

• #configure(&block) ⇒ void

  Yields the configuration for block-based setup.

• #convert ⇒ String

  Converts a class name to snake_case identifier format.

• #convert_message ⇒ Hash[Symbol, untyped]^?

  -- : (Riffer::Messages::Base) -> Hash[Symbol, untyped]?.

• #current_context ⇒ nil

  Returns nil; there is no trace context without OTEL.

• #decode_max_steps ⇒ Numeric^?

  Reverses encode_max_steps; a missing key falls back to the default so a partial hash can't become an unbounded loop.

• #decode_structured_output ⇒ Riffer::Params^?

  -- : (Hash[Symbol, untyped]?) -> Riffer::Params?.

• #decode_v1 ⇒ Riffer::Agent

  -- : (Hash[Symbol, untyped], context: Hash[Symbol, untyped]?, session: Riffer::Agent::Session?, tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent.

• #depends_on ⇒ true

  Requires a gem by name; raises LoadError if it isn't installed.

• #description ⇒ String^?

  Gets or sets the tool description.

• #effective_tools ⇒ Array[singleton(Riffer::Tool)]

  -- : (Riffer::Agent) -> Array.

• #empty_schema ⇒ Object
• #encode_max_steps ⇒ Numeric

  Encodes unlimited steps (+nil+ in the DSL) as -1 on the wire, where a JSON null is awkward across transports (e.g. proto3).

• #execute_pending_tool_calls ⇒ void

  -- : (Riffer::Agent, ?Hash[String, String]) -> void.

• #execute_run ⇒ Riffer::Agent::Response

  -- : (Riffer::Agent, Enumerator::Yielder?, ?Hash[String, String]) -> Riffer::Agent::Response.

• #execute_tool_calls ⇒ void

  -- : (Riffer::Agent, Riffer::Messages::Assistant, ?tool_calls: Array, ?tags: Hash[String, String]) -> void.

• #file_part ⇒ Hash[Symbol, untyped]

  -- : (Riffer::Messages::FilePart) -> Hash[Symbol, untyped].

• #fill_orphans ⇒ [ Array[Riffer::Messages::Base], Array[String] ]

  Fills each orphaned tool_use in messages with an ORPHAN_PLACEHOLDER result inserted after its parent.

• #final_response ⇒ Riffer::Agent::Response

  -- : (Riffer::Agent, Array, **untyped) -> Riffer::Agent::Response.

• #find ⇒ singleton(Riffer::Providers::Base)^?

  Finds a provider class by identifier, preferring a custom registration over a built-in of the same name.

• #find_by_tags ⇒ Array[Riffer::Mcp::Registration]

  Returns all registrations whose manifest tags intersect the given tags (normalized to symbols).

• #from_h ⇒ Riffer::Agent

  Reconstructs a runnable agent from a wire hash.

• #from_json ⇒ Riffer::Agent

  Reconstructs a runnable agent from a JSON string produced by to_json.

• #generate ⇒ Riffer::Agent::Response

  Runs the generate loop for the given agent.

• #identifier ⇒ String

  Gets or sets the tool identifier/name.

• #in_span ⇒ void

  Yields the no-op span, ignoring all span options.

• #inject_discovered_tools ⇒ void

  -- : (Riffer::Agent, Array[[Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]]) -> void.

• #input_messages ⇒ String

  -- : (Array) -> String.

• #key_for ⇒ Symbol^?

  Returns the registry identifier for a provider class, or nil when unregistered.

• #kind ⇒ Symbol

  Returns the kind of toolable entity; defaults to :tool.

• #merged_model_options ⇒ Hash[Symbol, untyped]

  tags rides in the options hash as a curated key the providers extract for native request-metadata mapping (alongside :structured_output); it never reaches an SDK call verbatim.

• #name ⇒ String

  Alias for identifier — used by providers.

• #normalize_tags ⇒ Hash[String, String]

  -- : (Hash[(String | Symbol), untyped]?) -> Hash[String, String].

• #output_messages ⇒ String

  -- : (content: String?, tool_calls: Array, finish_reason: Symbol?) -> String.

• #parameters_schema ⇒ Hash[Symbol, untyped]

  Returns the JSON Schema for the tool's parameters.

• #params ⇒ void

  Defines parameters using the Params DSL.

• #parse_arguments ⇒ Object

  Semconv's tool_call part carries arguments as a JSON object; riffer holds them as a string — parse so the captured payload isn't double-encoded.

• #prune_orphans ⇒ Array[Riffer::Messages::Base]

  Prunes a seeded message array to the invariant — dropping orphaned tool exchanges and parentless Tool messages, but preserving the pending tool_calls on the resume boundary (the last assistant) for execute_pending_tool_calls.

• #record_modifications! ⇒ void

  -- : (Enumerator::Yielder?, Array, Array) -> void.

• #record_run_outcome ⇒ void

  -- : (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span, Riffer::Agent::Response) -> void.

• #record_usage ⇒ void

  Stamps token usage onto the span — the gen_ai.usage.* counts and, when the model was priced, riffer.cost.

• #register { ... } ⇒ void

  Registers a custom provider under identifier, resolved lazily by the block.

• #registrations ⇒ Hash[String, Riffer::Mcp::Registration]

  Returns a frozen snapshot of all current registrations.

• #reset! ⇒ void

  Discards the resolved backend so the next span re-resolves it.

• #resolve ⇒ Object

  Calls thing when it's a Proc (passing context if its arity is non-zero), returns it unchanged otherwise, or default when nil.

• #resolve_backend ⇒ Object

  -- : () -> untyped.

• #run ⇒ Riffer::Evals::RunResult

  Runs evaluators against an agent for the given scenarios.

• #run_after_guardrails {|arg0| ... } ⇒ Object

  -- : (Riffer::Agent, Riffer::Messages::Assistant, Enumerator::Yielder?, Array, ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> untyped.

• #run_before_guardrails {|arg0| ... } ⇒ void

  -- : (Riffer::Agent, Enumerator::Yielder?, Array, ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> void.

• #run_loop ⇒ Riffer::Agent::Response

  Both generate and stream funnel here, so this is the single place raw tags are normalized.

• #run_scenario ⇒ Riffer::Evals::ScenarioResult

  -- : (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array, ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult.

• #run_span_attributes ⇒ Hash[String, untyped]

  -- : (Riffer::Agent, ?Hash[String, String]) -> Hash[String, untyped].

• #sanitize_name_component ⇒ String

  : (String) -> String.

• #stream ⇒ Enumerator[Riffer::StreamEvents::Base, void]

  Runs the streaming loop for the given agent.

• #sum_usage ⇒ Riffer::Providers::TokenUsage^?

  -- : (Riffer::Providers::TokenUsage?, Riffer::Providers::TokenUsage?) -> Riffer::Providers::TokenUsage?.

• #system_instructions ⇒ String^?

  -- : (Array) -> String?.

• #tag_attributes ⇒ Hash[String, String]

  -- : (Hash[String, String]) -> Hash[String, String].

• #text_part ⇒ Hash[Symbol, untyped]

  -- : (String?) -> Hash[Symbol, untyped].

• #timeout ⇒ Integer, Float

  Gets or sets the tool timeout in seconds.

• #to_h ⇒ Hash[Symbol, untyped]

  Snapshots a resolved agent into a self-contained wire hash.

• #to_json ⇒ String

  Snapshots a resolved agent to a JSON string.

• #to_tool_schema ⇒ Hash[Symbol, untyped]

  Returns a provider-agnostic tool schema hash.

• #tool_call_part ⇒ Hash[Symbol, untyped]

  -- : (Riffer::Messages::Assistant::ToolCall) -> Hash[Symbol, untyped].

• #tool_descriptor ⇒ Hash[Symbol, untyped]

  -- : (singleton(Riffer::Tool)) -> Hash[Symbol, untyped].

• #track_token_usage ⇒ void

  -- : (Riffer::Agent, Riffer::Providers::TokenUsage?) -> void.

• #tripwire_response ⇒ Riffer::Agent::Response

  -- : (Riffer::Agent, Enumerator::Yielder?, Riffer::Guardrails::Tripwire, Array, ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response.

• #unregister ⇒ void

  Removes a custom registration by identifier, leaving any built-in of the same name intact.

• #validate_agent! ⇒ void

  -- : (singleton(Riffer::Agent)) -> void.

• #validate_as_tool! ⇒ true

  Validates that the minimum required metadata is present for LLM tool use.

• #validate_evaluators! ⇒ void

  -- : (Array) -> void.

• #validate_structured_output ⇒ Hash[Symbol, untyped]^?

  -- : (Riffer::Agent, Riffer::Messages::Assistant?) -> Hash[Symbol, untyped]?.

• #version ⇒ String

  Returns the gem version.

• #with_context ⇒ void

  Yields immediately; there is no context to attach.

• #wrap_all ⇒ Array[singleton(Riffer::Mcp::Tool)]

  Returns one wrapper class per inner tool, sharing manifest and matched_tags.

• #wrap_one ⇒ singleton(Riffer::Mcp::Tool)

  -- : (singleton(Riffer::Mcp::Tool), Riffer::Mcp::Manifest, Array) -> singleton(Riffer::Mcp::Tool).

Class Method Details

.all ⇒ Array[Module]

Returns all classes that have extended Toolable.

-- : () -> Array

Returns:

• (Array[Module])

# File 'sig/generated/riffer/tools/toolable.rbs', line 41

def self.all: () -> Array[Module]

.extended ⇒ void

This method returns an undefined value.

Tracks all classes that extend Toolable.

-- : (Module) -> void

Parameters:

• (Module)

# File 'sig/generated/riffer/tools/toolable.rbs', line 35

def self.extended: (Module) -> void

Instance Method Details

#accumulate_streamed_response ⇒ Riffer::Messages::Assistant

-- : (Riffer::Agent, Enumerator::Yielder, ?Hash[String, String]) -> Riffer::Messages::Assistant

Parameters:

• (Riffer::Agent)
• (Enumerator::Yielder)
• (Hash[String, String])

Returns:

• (Riffer::Messages::Assistant)

# File 'sig/generated/riffer/agent/run.rbs', line 37

def accumulate_streamed_response: (Riffer::Agent, Enumerator::Yielder, ?Hash[String, String]) -> Riffer::Messages::Assistant

#append_user_message ⇒ void

This method returns an undefined value.

Raises when files are supplied without a prompt — the provider needs text to anchor the attachments.

: (Riffer::Agent, String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?) -> void

Parameters:

• (Riffer::Agent)
• (String, nil)
• files: (Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart], nil)

# File 'sig/generated/riffer/agent/run.rbs', line 103

def append_user_message: (Riffer::Agent, String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?) -> void

#assistant_parts ⇒ Array[Hash[Symbol, untyped]]

-- : (String?, Array) -> Array[Hash[Symbol, untyped]]

Parameters:

• (String, nil)
• (Array[Riffer::Messages::Assistant::ToolCall])

Returns:

• (Array[Hash[Symbol, untyped]])

# File 'sig/generated/riffer/tracing/capture.rbs', line 27

def assistant_parts: (String?, Array[Riffer::Messages::Assistant::ToolCall]) -> Array[Hash[Symbol, untyped]]

#backend ⇒ Object

-- : () -> untyped

Returns:

• (Object)

# File 'sig/generated/riffer/tracing.rbs', line 47

def backend: () -> untyped

#build ⇒ Array[singleton(Riffer::Mcp::Tool)]

Builds one Riffer::Mcp::Tool subclass per tool definition, prefixing names with the manifest name to avoid cross-server collisions (e.g. jira__search); the server-side name stays on .mcp_server_tool_name.

: (String, Riffer::Mcp::Client, Array[Hash[Symbol, untyped]]) -> Array

Parameters:

• (String)
• (Riffer::Mcp::Client)
• (Array[Hash[Symbol, untyped]])

Returns:

• (Array[singleton(Riffer::Mcp::Tool)])

# File 'sig/generated/riffer/mcp/tool_factory.rbs', line 12

def build: (String, Riffer::Mcp::Client, Array[Hash[Symbol, untyped]]) -> Array[singleton(Riffer::Mcp::Tool)]

#build_key_index ⇒ Hash[singleton(Riffer::Providers::Base), Symbol]

-- : () -> Hash[singleton(Riffer::Providers::Base), Symbol]

Returns:

• (Hash[singleton(Riffer::Providers::Base), Symbol])

# File 'sig/generated/riffer/providers/repository.rbs', line 46

def build_key_index: () -> Hash[singleton(Riffer::Providers::Base), Symbol]

#build_response ⇒ Riffer::Agent::Response

-- : (Riffer::Agent, String, ?tripwire: Riffer::Guardrails::Tripwire?, ?modifications: Array, ?interrupted: bool, ?interrupt_reason: (String | Symbol)?, ?structured_output: Hash[Symbol, untyped]?, ?healed_tool_call_ids: Array, ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response

Parameters:

• (Riffer::Agent)
• (String)
• tripwire: (Riffer::Guardrails::Tripwire, nil)
• modifications: (Array[Riffer::Guardrails::Modification])
• interrupted: (Boolean)
• interrupt_reason: (String, Symbol, nil)
• structured_output: (Hash[Symbol, untyped], nil)
• healed_tool_call_ids: (Array[String])
• token_usage: (Riffer::Providers::TokenUsage, nil)
• steps: (Integer)

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 97

def build_response: (Riffer::Agent, String, ?tripwire: Riffer::Guardrails::Tripwire?, ?modifications: Array[Riffer::Guardrails::Modification], ?interrupted: bool, ?interrupt_reason: (String | Symbol)?, ?structured_output: Hash[Symbol, untyped]?, ?healed_tool_call_ids: Array[String], ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response

#build_tool_class ⇒ singleton(Riffer::Mcp::Tool)

: (String, Riffer::Mcp::Client, Hash[Symbol, untyped]) -> singleton(Riffer::Mcp::Tool)

Parameters:

• (String)
• (Riffer::Mcp::Client)
• (Hash[Symbol, untyped])

Returns:

• (singleton(Riffer::Mcp::Tool))

# File 'sig/generated/riffer/mcp/tool_factory.rbs', line 20

def build_tool_class: (String, Riffer::Mcp::Client, Hash[Symbol, untyped]) -> singleton(Riffer::Mcp::Tool)

#build_tool_shell ⇒ Object

-- : (Hash[Symbol, untyped]) -> untyped

Parameters:

• (Hash[Symbol, untyped])

Returns:

• (Object)

# File 'sig/generated/riffer/agent/serializer.rbs', line 78

def build_tool_shell: (Hash[Symbol, untyped]) -> untyped

#call_llm ⇒ Riffer::Messages::Assistant

-- : (Riffer::Agent, ?Hash[String, String]) -> Riffer::Messages::Assistant

Parameters:

• (Riffer::Agent)
• (Hash[String, String])

Returns:

• (Riffer::Messages::Assistant)

# File 'sig/generated/riffer/agent/run.rbs', line 53

def call_llm: (Riffer::Agent, ?Hash[String, String]) -> Riffer::Messages::Assistant

#call_llm_stream ⇒ Enumerator[Riffer::StreamEvents::Base, void]

-- : (Riffer::Agent, ?Hash[String, String]) -> Enumerator[Riffer::StreamEvents::Base, void]

Parameters:

• (Riffer::Agent)
• (Hash[String, String])

Returns:

• (Enumerator[Riffer::StreamEvents::Base, void])

# File 'sig/generated/riffer/agent/run.rbs', line 57

def call_llm_stream: (Riffer::Agent, ?Hash[String, String]) -> Enumerator[Riffer::StreamEvents::Base, void]

#coerce ⇒ Boolean

Coerces value to a boolean so an env-var "false" (truthy in Ruby) doesn't silently read as true. Raises Riffer::ArgumentError on an unrecognized value, naming attribute in the message.

: (untyped, attribute: String) -> bool

Parameters:

• (Object)
• attribute: (String)

Returns:

• (Boolean)

# File 'sig/generated/riffer/helpers/boolean.rbs', line 10

def coerce: (untyped, attribute: String) -> bool

#config ⇒ Riffer::Config

Returns the Riffer configuration.

-- : () -> Riffer::Config

Returns:

• (Riffer::Config)

# File 'lib/riffer.rb', line 39

def config
  @config ||= Config.new
end

#configure(&block) ⇒ void

This method returns an undefined value.

Yields the configuration for block-based setup.

Riffer.configure do |config|
config.openai.api_key = ENV['OPENAI_API_KEY']
end

-- : () ?{ (Riffer::Config) -> void } -> void

# File 'lib/riffer.rb', line 51

def configure(&block)
  yield config if block_given?
end

#convert ⇒ String

Converts a class name to snake_case identifier format.

-- : (String, ?separator: String) -> String

Parameters:

• (String)
• separator: (String)

Returns:

• (String)

# File 'sig/generated/riffer/helpers/class_name_converter.rbs', line 11

def convert: (String, ?separator: String) -> String

#convert_message ⇒ Hash[Symbol, untyped]^?

-- : (Riffer::Messages::Base) -> Hash[Symbol, untyped]?

Parameters:

• (Riffer::Messages::Base)

Returns:

• (Hash[Symbol, untyped], nil)

# File 'sig/generated/riffer/tracing/capture.rbs', line 23

def convert_message: (Riffer::Messages::Base) -> Hash[Symbol, untyped]?

#current_context ⇒ nil

Returns nil; there is no trace context without OTEL.

: () -> nil

Returns:

• (nil)

# File 'sig/generated/riffer/tracing.rbs', line 24

def current_context: () -> untyped

#decode_max_steps ⇒ Numeric^?

Reverses encode_max_steps; a missing key falls back to the default so a partial hash can't become an unbounded loop.

: (Hash[Symbol, untyped]) -> Numeric?

Parameters:

• (Hash[Symbol, untyped])

Returns:

• (Numeric, nil)

# File 'sig/generated/riffer/agent/serializer.rbs', line 70

def decode_max_steps: (Hash[Symbol, untyped]) -> Numeric?

#decode_structured_output ⇒ Riffer::Params^?

-- : (Hash[Symbol, untyped]?) -> Riffer::Params?

Parameters:

• (Hash[Symbol, untyped], nil)

Returns:

• (Riffer::Params, nil)

# File 'sig/generated/riffer/agent/serializer.rbs', line 58

def decode_structured_output: (Hash[Symbol, untyped]?) -> Riffer::Params?

#decode_v1 ⇒ Riffer::Agent

-- : (Hash[Symbol, untyped], context: Hash[Symbol, untyped]?, session: Riffer::Agent::Session?, tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

Parameters:

• (Hash[Symbol, untyped])
• context: (Hash[Symbol, untyped], nil)
• session: (Riffer::Agent::Session, nil)
• tool_resolver: (^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool))
• tool_runtime: (singleton(Riffer::Tools::Runtime), Riffer::Tools::Runtime, Proc, nil)

Returns:

• (Riffer::Agent)

# File 'sig/generated/riffer/agent/serializer.rbs', line 54

def decode_v1: (Hash[Symbol, untyped], context: Hash[Symbol, untyped]?, session: Riffer::Agent::Session?, tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

#depends_on ⇒ true

Requires a gem by name; raises LoadError if it isn't installed.

: (String) -> true

Parameters:

• (String)

Returns:

• (true)

# File 'sig/generated/riffer/helpers/dependencies.rbs', line 13

def depends_on: (String) -> true

#description ⇒ String^?

Gets or sets the tool description.

-- : (?String?) -> String?

Parameters:

• (String, nil)

Returns:

• (String, nil)

# File 'sig/generated/riffer/tools/toolable.rbs', line 47

def description: (?String?) -> String?

#effective_tools ⇒ Array[singleton(Riffer::Tool)]

-- : (Riffer::Agent) -> Array

Parameters:

• (Riffer::Agent)

Returns:

• (Array[singleton(Riffer::Tool)])

# File 'sig/generated/riffer/agent/run.rbs', line 85

def effective_tools: (Riffer::Agent) -> Array[singleton(Riffer::Tool)]

#empty_schema ⇒ Object

Returns:

• (Object)

# File 'sig/generated/riffer/tools/toolable.rbs', line 100

def empty_schema: () -> untyped

#encode_max_steps ⇒ Numeric

Encodes unlimited steps (+nil+ in the DSL) as -1 on the wire, where a JSON null is awkward across transports (e.g. proto3).

: (Numeric?) -> Numeric

Parameters:

• (Numeric, nil)

Returns:

• (Numeric)

# File 'sig/generated/riffer/agent/serializer.rbs', line 64

def encode_max_steps: (Numeric?) -> Numeric

#execute_pending_tool_calls ⇒ void

This method returns an undefined value.

-- : (Riffer::Agent, ?Hash[String, String]) -> void

Parameters:

• (Riffer::Agent)
• (Hash[String, String])

# File 'sig/generated/riffer/agent/run.rbs', line 69

def execute_pending_tool_calls: (Riffer::Agent, ?Hash[String, String]) -> void

#execute_run ⇒ Riffer::Agent::Response

-- : (Riffer::Agent, Enumerator::Yielder?, ?Hash[String, String]) -> Riffer::Agent::Response

Parameters:

• (Riffer::Agent)
• (Enumerator::Yielder, nil)
• (Hash[String, String])

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 33

def execute_run: (Riffer::Agent, Enumerator::Yielder?, ?Hash[String, String]) -> Riffer::Agent::Response

#execute_tool_calls ⇒ void

This method returns an undefined value.

-- : (Riffer::Agent, Riffer::Messages::Assistant, ?tool_calls: Array, ?tags: Hash[String, String]) -> void

Parameters:

• (Riffer::Agent)
• (Riffer::Messages::Assistant)
• tool_calls: (Array[Riffer::Messages::Assistant::ToolCall])
• tags: (Hash[String, String])

# File 'sig/generated/riffer/agent/run.rbs', line 61

def execute_tool_calls: (Riffer::Agent, Riffer::Messages::Assistant, ?tool_calls: Array[Riffer::Messages::Assistant::ToolCall], ?tags: Hash[String, String]) -> void

#file_part ⇒ Hash[Symbol, untyped]

-- : (Riffer::Messages::FilePart) -> Hash[Symbol, untyped]

Parameters:

• (Riffer::Messages::FilePart)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/tracing/capture.rbs', line 39

def file_part: (Riffer::Messages::FilePart) -> Hash[Symbol, untyped]

#fill_orphans ⇒ [ Array[Riffer::Messages::Base], Array[String] ]

Fills each orphaned tool_use in messages with an ORPHAN_PLACEHOLDER result inserted after its parent. Returns [new_messages, filled_call_ids].

: (Array) -> [Array[Riffer::Messages::Base], Array[String]]

Parameters:

• (Array[Riffer::Messages::Base])

Returns:

• ([ Array[Riffer::Messages::Base], Array[String] ])

# File 'sig/generated/riffer/agent/session/repair.rbs', line 14

def fill_orphans: (Array[Riffer::Messages::Base]) -> [ Array[Riffer::Messages::Base], Array[String] ]

#final_response ⇒ Riffer::Agent::Response

-- : (Riffer::Agent, Array, **untyped) -> Riffer::Agent::Response

Parameters:

• (Riffer::Agent)
• (Array[Riffer::Guardrails::Modification])
• (Object)

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 49

def final_response: (Riffer::Agent, Array[Riffer::Guardrails::Modification], **untyped) -> Riffer::Agent::Response

#find ⇒ singleton(Riffer::Providers::Base)^?

Finds a provider class by identifier, preferring a custom registration over a built-in of the same name.

-- : ((String | Symbol)) -> singleton(Riffer::Providers::Base)?

Parameters:

• (String, Symbol)

Returns:

• (singleton(Riffer::Providers::Base), nil)

# File 'sig/generated/riffer/providers/repository.rbs', line 35

def find: (String | Symbol) -> singleton(Riffer::Providers::Base)?

#find_by_tags ⇒ Array[Riffer::Mcp::Registration]

Returns all registrations whose manifest tags intersect the given tags (normalized to symbols).

: (Array) -> Array

Parameters:

• (Array[Symbol])

Returns:

• (Array[Riffer::Mcp::Registration])

# File 'sig/generated/riffer/mcp/registry.rbs', line 31

def find_by_tags: (Array[Symbol]) -> Array[Riffer::Mcp::Registration]

#from_h ⇒ Riffer::Agent

Reconstructs a runnable agent from a wire hash. context is threaded into tool dispatch (not used to re-resolve the already-resolved config); session seeds conversation history (the hash carries the agent definition, not its history). Raises Riffer::Agent::Serializer::VersionError on an unsupported schema_version.

-- : (Hash[Symbol, untyped], ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

Parameters:

• (Hash[Symbol, untyped])
• context: (Hash[Symbol, untyped], nil)
• session: (Riffer::Agent::Session, nil)
• tool_resolver: (^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool))
• tool_runtime: (singleton(Riffer::Tools::Runtime), Riffer::Tools::Runtime, Proc, nil)

Returns:

• (Riffer::Agent)

# File 'sig/generated/riffer/agent/serializer.rbs', line 37

def from_h: (Hash[Symbol, untyped], ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

#from_json ⇒ Riffer::Agent

Reconstructs a runnable agent from a JSON string produced by to_json. See from_h for the arguments.

: (String, ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

Parameters:

• (String)
• context: (Hash[Symbol, untyped], nil)
• session: (Riffer::Agent::Session, nil)
• tool_resolver: (^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool))
• tool_runtime: (singleton(Riffer::Tools::Runtime), Riffer::Tools::Runtime, Proc, nil)

Returns:

• (Riffer::Agent)

# File 'sig/generated/riffer/agent/serializer.rbs', line 48

def from_json: (String, ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent

#generate ⇒ Riffer::Agent::Response

Runs the generate loop for the given agent. See Riffer::Agent#generate for prompt/files semantics.

-- : (agent: Riffer::Agent, ?prompt: String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response

Parameters:

• agent: (Riffer::Agent)
• prompt: (String, nil)
• files: (Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart], nil)
• tags: (Hash[String | Symbol, untyped])

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 11

def generate: (agent: Riffer::Agent, ?prompt: String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[String | Symbol, untyped]) -> Riffer::Agent::Response

#identifier ⇒ String

Gets or sets the tool identifier/name.

-- : (?String?) -> String

Parameters:

• (String, nil)

Returns:

• (String)

# File 'sig/generated/riffer/tools/toolable.rbs', line 53

def identifier: (?String?) -> String

#in_span ⇒ void

This method returns an undefined value.

Yields the no-op span, ignoring all span options.

: [R] (String, **untyped) { (Riffer::Tracing::NoOp::Span) -> R } -> R

# File 'sig/generated/riffer/tracing.rbs', line 18

def in_span: [R] (String, ?attributes: Hash[String, untyped]?, ?kind: Symbol) { (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span) -> R } -> R

#inject_discovered_tools ⇒ void

This method returns an undefined value.

-- : (Riffer::Agent, Array[[Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]]) -> void

Parameters:

• (Riffer::Agent)
• (Array[[ Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response ]])

# File 'sig/generated/riffer/agent/run.rbs', line 65

def inject_discovered_tools: (Riffer::Agent, Array[[ Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response ]]) -> void

#input_messages ⇒ String

-- : (Array) -> String

Parameters:

• (Array[Riffer::Messages::Base])

Returns:

• (String)

# File 'sig/generated/riffer/tracing/capture.rbs', line 9

def input_messages: (Array[Riffer::Messages::Base]) -> String

#key_for ⇒ Symbol^?

Returns the registry identifier for a provider class, or nil when unregistered.

: (singleton(Riffer::Providers::Base)) -> Symbol?

Parameters:

• (singleton(Riffer::Providers::Base))

Returns:

• (Symbol, nil)

# File 'sig/generated/riffer/providers/repository.rbs', line 40

def key_for: (singleton(Riffer::Providers::Base)) -> Symbol?

#kind ⇒ Symbol

Returns the kind of toolable entity; defaults to :tool.

: (?Symbol?) -> Symbol

Parameters:

• (Symbol, nil)

Returns:

• (Symbol)

# File 'sig/generated/riffer/tools/toolable.rbs', line 82

def kind: (?Symbol?) -> Symbol

#merged_model_options ⇒ Hash[Symbol, untyped]

tags rides in the options hash as a curated key the providers extract for native request-metadata mapping (alongside :structured_output); it never reaches an SDK call verbatim. Span tagging is threaded separately to each builder.

: (Riffer::Agent, ?Hash[String, String]) -> Hash[Symbol, untyped]

Parameters:

• (Riffer::Agent)
• (Hash[String, String])

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/agent/run.rbs', line 93

def merged_model_options: (Riffer::Agent, ?Hash[String, String]) -> Hash[Symbol, untyped]

#name ⇒ String

Alias for identifier — used by providers.

-- : (?String?) -> String

Parameters:

• (String, nil)

Returns:

• (String)

# File 'sig/generated/riffer/tools/toolable.rbs', line 59

def name: (?String?) -> String

#normalize_tags ⇒ Hash[String, String]

-- : (Hash[(String | Symbol), untyped]?) -> Hash[String, String]

Parameters:

• (Hash[String | Symbol, untyped], nil)

Returns:

• (Hash[String, String])

# File 'sig/generated/riffer/agent/run.rbs', line 119

def normalize_tags: (Hash[String | Symbol, untyped]?) -> Hash[String, String]

#output_messages ⇒ String

-- : (content: String?, tool_calls: Array, finish_reason: Symbol?) -> String

Parameters:

• content: (String, nil)
• tool_calls: (Array[Riffer::Messages::Assistant::ToolCall])
• finish_reason: (Symbol, nil)

Returns:

• (String)

# File 'sig/generated/riffer/tracing/capture.rbs', line 17

def output_messages: (content: String?, tool_calls: Array[Riffer::Messages::Assistant::ToolCall], finish_reason: Symbol?) -> String

#parameters_schema ⇒ Hash[Symbol, untyped]

Returns the JSON Schema for the tool's parameters.

-- : (?strict: bool) -> Hash[Symbol, untyped]

Parameters:

• strict: (Boolean)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/tools/toolable.rbs', line 77

def parameters_schema: (?strict: bool) -> Hash[Symbol, untyped]

#params ⇒ void

This method returns an undefined value.

Defines parameters using the Params DSL.

-- : () ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?

# File 'sig/generated/riffer/tools/toolable.rbs', line 71

def params: () ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?

#parse_arguments ⇒ Object

Semconv's tool_call part carries arguments as a JSON object; riffer holds them as a string — parse so the captured payload isn't double-encoded.

: (untyped) -> untyped

Parameters:

• (Object)

Returns:

• (Object)

# File 'sig/generated/riffer/tracing/capture.rbs', line 45

def parse_arguments: (untyped) -> untyped

#prune_orphans ⇒ Array[Riffer::Messages::Base]

Prunes a seeded message array to the invariant — dropping orphaned tool exchanges and parentless Tool messages, but preserving the pending tool_calls on the resume boundary (the last assistant) for execute_pending_tool_calls. Returns a new array.

: (Array) -> Array

Parameters:

• (Array[Riffer::Messages::Base])

Returns:

• (Array[Riffer::Messages::Base])

# File 'sig/generated/riffer/agent/session/repair.rbs', line 22

def prune_orphans: (Array[Riffer::Messages::Base]) -> Array[Riffer::Messages::Base]

#record_modifications! ⇒ void

This method returns an undefined value.

-- : (Enumerator::Yielder?, Array, Array) -> void

Parameters:

• (Enumerator::Yielder, nil)
• (Array[Riffer::Guardrails::Modification])
• (Array[Riffer::Guardrails::Modification])

# File 'sig/generated/riffer/agent/run.rbs', line 41

def record_modifications!: (Enumerator::Yielder?, Array[Riffer::Guardrails::Modification], Array[Riffer::Guardrails::Modification]) -> void

#record_run_outcome ⇒ void

This method returns an undefined value.

-- : (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span, Riffer::Agent::Response) -> void

Parameters:

• (Riffer::Tracing::Otel::Span, Riffer::Tracing::NoOp::Span)
• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 127

def record_run_outcome: (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span, Riffer::Agent::Response) -> void

#record_usage ⇒ void

This method returns an undefined value.

Stamps token usage onto the span — the gen_ai.usage.* counts and, when the model was priced, riffer.cost.

: ((Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span), Riffer::Providers::TokenUsage?) -> void

Parameters:

• (Riffer::Tracing::Otel::Span, Riffer::Tracing::NoOp::Span)
• (Riffer::Providers::TokenUsage, nil)

# File 'sig/generated/riffer/tracing.rbs', line 36

def record_usage: (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span, Riffer::Providers::TokenUsage?) -> void

#register { ... } ⇒ void

This method returns an undefined value.

Registers a custom provider under identifier, resolved lazily by the block. Takes precedence over a built-in sharing the identifier.

Riffer::Providers::Repository.register(:jane) { MyApp::JaneProvider }

Raises Riffer::ArgumentError when called without a block.

-- : ((String | Symbol)) { () -> singleton(Riffer::Providers::Base) } -> void

Parameters:

• (String, Symbol)

Yields:

Yield Returns:

• (singleton(Riffer::Providers::Base))

# File 'sig/generated/riffer/mcp.rbs', line 32

def register: (Hash[Symbol, untyped] | Riffer::Mcp::Manifest) -> Riffer::Mcp::Registration

#registrations ⇒ Hash[String, Riffer::Mcp::Registration]

Returns a frozen snapshot of all current registrations.

-- : () -> Hash[String, Riffer::Mcp::Registration]

Returns:

• (Hash[String, Riffer::Mcp::Registration])

# File 'sig/generated/riffer/mcp.rbs', line 43

def registrations: () -> Hash[String, Riffer::Mcp::Registration]

#reset! ⇒ void

This method returns an undefined value.

Discards the resolved backend so the next span re-resolves it.

: () -> void

# File 'sig/generated/riffer/tracing.rbs', line 41

def reset!: () -> void

#resolve ⇒ Object

Calls thing when it's a Proc (passing context if its arity is non-zero), returns it unchanged otherwise, or default when nil.

: (untyped, ?context: untyped, ?default: untyped) -> untyped

Parameters:

• (Object)
• context: (Object)
• default: (Object)

Returns:

• (Object)

# File 'sig/generated/riffer/helpers/call_or_value.rbs', line 9

def resolve: (untyped, ?context: untyped, ?default: untyped) -> untyped

#resolve_backend ⇒ Object

-- : () -> untyped

Returns:

• (Object)

# File 'sig/generated/riffer/tracing.rbs', line 51

def resolve_backend: () -> untyped

#run ⇒ Riffer::Evals::RunResult

Runs evaluators against an agent for the given scenarios. Raises Riffer::ArgumentError on an invalid agent or evaluator.

: (agent: singleton(Riffer::Agent), scenarios: Array[Hash[Symbol, untyped]], evaluators: Array, ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::RunResult

Parameters:

• agent: (singleton(Riffer::Agent))
• scenarios: (Array[Hash[Symbol, untyped]])
• evaluators: (Array[singleton(Riffer::Evals::Evaluator)])
• context: (Hash[Symbol, untyped], nil)

Returns:

• (Riffer::Evals::RunResult)

# File 'sig/generated/riffer/evals/evaluator_runner.rbs', line 20

def run: (agent: singleton(Riffer::Agent), scenarios: Array[Hash[Symbol, untyped]], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::RunResult

#run_after_guardrails {|arg0| ... } ⇒ Object

-- : (Riffer::Agent, Riffer::Messages::Assistant, Enumerator::Yielder?, Array, ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> untyped

Parameters:

• (Riffer::Agent)
• (Riffer::Messages::Assistant)
• (Enumerator::Yielder, nil)
• (Array[Riffer::Guardrails::Modification])
• (Hash[String, String])

Yields:

Yield Parameters:

• arg0 (Riffer::Guardrails::Tripwire)

Yield Returns:

• (void)

Returns:

• (Object)

# File 'sig/generated/riffer/agent/run.rbs', line 77

def run_after_guardrails: (Riffer::Agent, Riffer::Messages::Assistant, Enumerator::Yielder?, Array[Riffer::Guardrails::Modification], ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> untyped

#run_before_guardrails {|arg0| ... } ⇒ void

This method returns an undefined value.

-- : (Riffer::Agent, Enumerator::Yielder?, Array, ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> void

Parameters:

• (Riffer::Agent)
• (Enumerator::Yielder, nil)
• (Array[Riffer::Guardrails::Modification])
• (Hash[String, String])

Yields:

Yield Parameters:

• arg0 (Riffer::Guardrails::Tripwire)

Yield Returns:

• (void)

# File 'sig/generated/riffer/agent/run.rbs', line 73

def run_before_guardrails: (Riffer::Agent, Enumerator::Yielder?, Array[Riffer::Guardrails::Modification], ?Hash[String, String]) { (Riffer::Guardrails::Tripwire) -> void } -> void

#run_loop ⇒ Riffer::Agent::Response

Both generate and stream funnel here, so this is the single place raw tags are normalized. The clean String => String map is then threaded to every span builder in the run as riffer.tag.* and to each provider call (via merged_model_options) for native request-metadata mapping.

: (Riffer::Agent, ?tags: Hash[(String | Symbol), untyped]?, ?stream_yielder: Enumerator::Yielder?) -> Riffer::Agent::Response

Parameters:

• (Riffer::Agent)
• tags: (Hash[String | Symbol, untyped], nil)
• stream_yielder: (Enumerator::Yielder, nil)

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 29

def run_loop: (Riffer::Agent, ?tags: Hash[String | Symbol, untyped]?, ?stream_yielder: Enumerator::Yielder?) -> Riffer::Agent::Response

#run_scenario ⇒ Riffer::Evals::ScenarioResult

-- : (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array, ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult

Parameters:

• agent: (singleton(Riffer::Agent))
• scenario: (Hash[Symbol, untyped])
• evaluators: (Array[singleton(Riffer::Evals::Evaluator)])
• context: (Hash[Symbol, untyped], nil)

Returns:

• (Riffer::Evals::ScenarioResult)

# File 'sig/generated/riffer/evals/evaluator_runner.rbs', line 34

def run_scenario: (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult

#run_span_attributes ⇒ Hash[String, untyped]

-- : (Riffer::Agent, ?Hash[String, String]) -> Hash[String, untyped]

Parameters:

• (Riffer::Agent)
• (Hash[String, String])

Returns:

• (Hash[String, untyped])

# File 'sig/generated/riffer/agent/run.rbs', line 115

def run_span_attributes: (Riffer::Agent, ?Hash[String, String]) -> Hash[String, untyped]

#sanitize_name_component ⇒ String

: (String) -> String

Parameters:

• (String)

Returns:

• (String)

# File 'sig/generated/riffer/mcp/tool_factory.rbs', line 17

def sanitize_name_component: (String) -> String

#stream ⇒ Enumerator[Riffer::StreamEvents::Base, void]

Runs the streaming loop for the given agent. See Riffer::Agent#stream for prompt/files semantics.

-- : (agent: Riffer::Agent, ?prompt: String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Enumerator[Riffer::StreamEvents::Base, void]

Parameters:

• agent: (Riffer::Agent)
• prompt: (String, nil)
• files: (Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart], nil)
• tags: (Hash[String | Symbol, untyped])

Returns:

• (Enumerator[Riffer::StreamEvents::Base, void])

# File 'sig/generated/riffer/agent/run.rbs', line 18

def stream: (agent: Riffer::Agent, ?prompt: String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[String | Symbol, untyped]) -> Enumerator[Riffer::StreamEvents::Base, void]

#sum_usage ⇒ Riffer::Providers::TokenUsage^?

-- : (Riffer::Providers::TokenUsage?, Riffer::Providers::TokenUsage?) -> Riffer::Providers::TokenUsage?

Parameters:

• (Riffer::Providers::TokenUsage, nil)
• (Riffer::Providers::TokenUsage, nil)

Returns:

• (Riffer::Providers::TokenUsage, nil)

# File 'sig/generated/riffer/agent/run.rbs', line 111

def sum_usage: (Riffer::Providers::TokenUsage?, Riffer::Providers::TokenUsage?) -> Riffer::Providers::TokenUsage?

#system_instructions ⇒ String^?

-- : (Array) -> String?

Parameters:

• (Array[Riffer::Messages::Base])

Returns:

• (String, nil)

# File 'sig/generated/riffer/tracing/capture.rbs', line 13

def system_instructions: (Array[Riffer::Messages::Base]) -> String?

#tag_attributes ⇒ Hash[String, String]

-- : (Hash[String, String]) -> Hash[String, String]

Parameters:

• (Hash[String, String])

Returns:

• (Hash[String, String])

# File 'sig/generated/riffer/agent/run.rbs', line 123

def tag_attributes: (Hash[String, String]) -> Hash[String, String]

#text_part ⇒ Hash[Symbol, untyped]

-- : (String?) -> Hash[Symbol, untyped]

Parameters:

• (String, nil)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/tracing/capture.rbs', line 31

def text_part: (String?) -> Hash[Symbol, untyped]

#timeout ⇒ Integer, Float

Gets or sets the tool timeout in seconds.

-- : (?(Integer | Float)?) -> (Integer | Float)

Parameters:

• (?(Integer | Float), nil)

Returns:

• (Integer, Float)

# File 'sig/generated/riffer/tools/toolable.rbs', line 65

def timeout: (?(Integer | Float)?) -> (Integer | Float)

#to_h ⇒ Hash[Symbol, untyped]

Snapshots a resolved agent into a self-contained wire hash. Proc-based settings are already evaluated against the agent's context, so the hash carries plain data, never Procs.

: (agent: Riffer::Agent) -> Hash[Symbol, untyped]

Parameters:

• agent: (Riffer::Agent)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/agent/serializer.rbs', line 27

def to_h: (agent: Riffer::Agent) -> Hash[Symbol, untyped]

#to_json ⇒ String

Snapshots a resolved agent to a JSON string.

: (agent: Riffer::Agent) -> String

Parameters:

• agent: (Riffer::Agent)

Returns:

• (String)

# File 'sig/generated/riffer/agent/serializer.rbs', line 42

def to_json: (agent: Riffer::Agent) -> String

#to_tool_schema ⇒ Hash[Symbol, untyped]

Returns a provider-agnostic tool schema hash.

-- : (?strict: bool) -> Hash[Symbol, untyped]

Parameters:

• strict: (Boolean)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/tools/toolable.rbs', line 88

def to_tool_schema: (?strict: bool) -> Hash[Symbol, untyped]

#tool_call_part ⇒ Hash[Symbol, untyped]

-- : (Riffer::Messages::Assistant::ToolCall) -> Hash[Symbol, untyped]

Parameters:

• (Riffer::Messages::Assistant::ToolCall)

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/tracing/capture.rbs', line 35

def tool_call_part: (Riffer::Messages::Assistant::ToolCall) -> Hash[Symbol, untyped]

#tool_descriptor ⇒ Hash[Symbol, untyped]

-- : (singleton(Riffer::Tool)) -> Hash[Symbol, untyped]

Parameters:

• (singleton(Riffer::Tool))

Returns:

• (Hash[Symbol, untyped])

# File 'sig/generated/riffer/agent/serializer.rbs', line 74

def tool_descriptor: (singleton(Riffer::Tool)) -> Hash[Symbol, untyped]

#track_token_usage ⇒ void

This method returns an undefined value.

-- : (Riffer::Agent, Riffer::Providers::TokenUsage?) -> void

Parameters:

• (Riffer::Agent)
• (Riffer::Providers::TokenUsage, nil)

# File 'sig/generated/riffer/agent/run.rbs', line 107

def track_token_usage: (Riffer::Agent, Riffer::Providers::TokenUsage?) -> void

#tripwire_response ⇒ Riffer::Agent::Response

-- : (Riffer::Agent, Enumerator::Yielder?, Riffer::Guardrails::Tripwire, Array, ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response

Parameters:

• (Riffer::Agent)
• (Enumerator::Yielder, nil)
• (Riffer::Guardrails::Tripwire)
• (Array[Riffer::Guardrails::Modification])
• token_usage: (Riffer::Providers::TokenUsage, nil)
• steps: (Integer)

Returns:

• (Riffer::Agent::Response)

# File 'sig/generated/riffer/agent/run.rbs', line 45

def tripwire_response: (Riffer::Agent, Enumerator::Yielder?, Riffer::Guardrails::Tripwire, Array[Riffer::Guardrails::Modification], ?token_usage: Riffer::Providers::TokenUsage?, ?steps: Integer) -> Riffer::Agent::Response

#unregister ⇒ void

This method returns an undefined value.

Removes a custom registration by identifier, leaving any built-in of the same name intact.

: ((String | Symbol)) -> void

Parameters:

• (String, Symbol)

# File 'sig/generated/riffer/mcp.rbs', line 37

def unregister: (String) -> void

#validate_agent! ⇒ void

This method returns an undefined value.

-- : (singleton(Riffer::Agent)) -> void

Parameters:

• (singleton(Riffer::Agent))

# File 'sig/generated/riffer/evals/evaluator_runner.rbs', line 26

def validate_agent!: (singleton(Riffer::Agent)) -> void

#validate_as_tool! ⇒ true

Validates that the minimum required metadata is present for LLM tool use.

Raises Riffer::ArgumentError if validation fails.

-- : () -> true

Returns:

• (true)

# File 'sig/generated/riffer/tools/toolable.rbs', line 96

def validate_as_tool!: () -> true

#validate_evaluators! ⇒ void

This method returns an undefined value.

-- : (Array) -> void

Parameters:

• (Array[singleton(Riffer::Evals::Evaluator)])

# File 'sig/generated/riffer/evals/evaluator_runner.rbs', line 30

def validate_evaluators!: (Array[singleton(Riffer::Evals::Evaluator)]) -> void

#validate_structured_output ⇒ Hash[Symbol, untyped]^?

-- : (Riffer::Agent, Riffer::Messages::Assistant?) -> Hash[Symbol, untyped]?

Parameters:

• (Riffer::Agent)
• (Riffer::Messages::Assistant, nil)

Returns:

• (Hash[Symbol, untyped], nil)

# File 'sig/generated/riffer/agent/run.rbs', line 81

def validate_structured_output: (Riffer::Agent, Riffer::Messages::Assistant?) -> Hash[Symbol, untyped]?

#version ⇒ String

Returns the gem version.

: () -> String

Returns:

• (String)

# File 'lib/riffer.rb', line 58

def version
  VERSION
end

#with_context ⇒ void

This method returns an undefined value.

Yields immediately; there is no context to attach.

: [R] (untyped) { () -> R } -> R

# File 'sig/generated/riffer/tracing.rbs', line 30

def with_context: [R] (untyped) { () -> R } -> R

#wrap_all ⇒ Array[singleton(Riffer::Mcp::Tool)]

Returns one wrapper class per inner tool, sharing manifest and matched_tags.

-- : (Array, Riffer::Mcp::Manifest, Array) -> Array

Parameters:

• (Array[singleton(Riffer::Mcp::Tool)])
• (Riffer::Mcp::Manifest)
• (Array[Symbol])

Returns:

• (Array[singleton(Riffer::Mcp::Tool)])

# File 'sig/generated/riffer/mcp/authenticated_tool.rbs', line 11

def wrap_all: (Array[singleton(Riffer::Mcp::Tool)], Riffer::Mcp::Manifest, Array[Symbol]) -> Array[singleton(Riffer::Mcp::Tool)]

#wrap_one ⇒ singleton(Riffer::Mcp::Tool)

-- : (singleton(Riffer::Mcp::Tool), Riffer::Mcp::Manifest, Array) -> singleton(Riffer::Mcp::Tool)

Parameters:

• (singleton(Riffer::Mcp::Tool))
• (Riffer::Mcp::Manifest)
• (Array[Symbol])

Returns:

• (singleton(Riffer::Mcp::Tool))

# File 'sig/generated/riffer/mcp/authenticated_tool.rbs', line 15

def wrap_one: (singleton(Riffer::Mcp::Tool), Riffer::Mcp::Manifest, Array[Symbol]) -> singleton(Riffer::Mcp::Tool)