flowengine 0.3.0 → 0.4.0

data/docs/PROJECT_STRUCTURE.md

@@ -0,0 +1,64 @@
+# Project Structure
+
+```text
+lib/flowengine/
+  flowengine.rb              # Module entry: define() and load_dsl()
+  version.rb                 # VERSION = "0.3.1"
+  errors.rb                  # Error hierarchy (8 classes)
+  clarification_result.rb    # Data.define for AI intake round results
+  introduction.rb            # Data.define(:label, :placeholder, :maxlength)
+  definition.rb              # Immutable flow graph container
+  node.rb                    # Single flow step (question, type, transitions, max_clarifications)
+  transition.rb              # Directed edge with optional rule condition
+  evaluator.rb               # Rule evaluation against answers
+  engine.rb                  # Runtime session (answers, history, navigation, AI intake state)
+  engine/
+    state_serializer.rb      # Symbolizes string-keyed state from JSON round-trips
+  dsl/
+    flow_builder.rb          # FlowEngine.define {} context (start, introduction, step)
+    step_builder.rb          # step {} block builder (includes max_clarifications)
+    rule_helpers.rb          # contains(), equals(), all(), any(), etc.
+  rules/
+    base.rb                  # Abstract rule (evaluate + to_s)
+    contains.rb              # Array.include? semantics
+    equals.rb                # Simple equality
+    greater_than.rb          # Numeric > comparison (coerces to_i)
+    less_than.rb             # Numeric < comparison (coerces to_i)
+    not_empty.rb             # !nil && !empty?
+    all.rb                   # Composite AND
+    any.rb                   # Composite OR
+  validation/
+    adapter.rb               # Abstract validator interface
+    null_adapter.rb          # No-op default validator
+  llm/
+    adapter.rb               # Abstract LLM adapter interface
+    adapters.rb              # Requires all concrete adapters
+    auto_client.rb           # FlowEngine::LLM.auto_client factory
+    provider.rb              # Provider/model registry from models.yml
+    client.rb                # High-level LLM client (prompt building + response parsing)
+    system_prompt_builder.rb # Builds system prompt for introduction pre-fill
+    intake_prompt_builder.rb # Builds system prompt for AI intake steps
+    sensitive_data_filter.rb # Rejects SSN, ITIN, EIN patterns
+  graph/
+    mermaid_exporter.rb      # Exports Definition to Mermaid diagram
+resources/
+  models.yml                 # Vendor/model registry (Anthropic, OpenAI, Gemini)
+  prompts/
+    generic-dsl-intake.j2    # Static system prompt template for LLM parsing
+spec/
+  flowengine_spec.rb         # Top-level define/load_dsl tests
+  flowengine/                # Mirrors lib/ structure
+    engine_spec.rb           # Core engine tests
+    engine_ai_intake_spec.rb # AI intake step tests
+    engine_introduction_spec.rb # Introduction pre-fill tests
+    engine_state_spec.rb     # State persistence tests
+    clarification_result_spec.rb
+    llm/                     # LLM adapter, client, filter, prompt builder specs
+  integration/
+    introduction_flow_spec.rb # Introduction + LLM pre-fill integration
+    multi_ai_intake_spec.rb  # Multi-AI intake integration test
+    tax_intake_flow_spec.rb  # Real-world tax intake example
+    complex_flow_spec.rb     # Complex branching tests
+  fixtures/
+    complex_tax_intake.rb    # 17-step tax intake flow definition
+```

data/lefthook.yml

@@ -0,0 +1,16 @@
+pre-commit:
+  parallel: true
+  jobs:
+    - name: format
+      glob: "*.{js,ts,tsx}"
+      run: npx biome format --write {staged_files}
+      stage_fixed: true
+
+    - name: rubocop
+      glob: "*.{rb,rake}"
+      run: bundle exec rubocop -a --format progress {staged_files}
+      staged_fixed: true
+
+    - name: rspecs
+      glob: "spec/**/*_spec.rb"
+      run: bundle exec rspec --format progress

data/lib/flowengine/clarification_result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FlowEngine
+  # Immutable result from an AI intake or clarification round.
+  #
+  # @attr_reader answered [Hash<Symbol, Object>] step_id => value pairs filled this round
+  # @attr_reader pending_steps [Array<Symbol>] step ids still unanswered after this round
+  # @attr_reader follow_up [String, nil] clarifying question from the LLM, or nil if done
+  # @attr_reader round [Integer] current clarification round (1-based)
+  ClarificationResult = Data.define(:answered, :pending_steps, :follow_up, :round) do
+    def initialize(answered: {}, pending_steps: [], follow_up: nil, round: 1)
+      super
+      freeze
+    end
+
+    # @return [Boolean] true when the LLM has no more questions or max rounds reached
+    def done?
+      follow_up.nil?
+    end
+  end
+end

data/lib/flowengine/definition.rb

@@ -30,7 +30,7 @@ module FlowEngine
     # @return [Node] the node for that step
     # @raise [UnknownStepError] if id is not in steps
     def step(id)
-      steps.fetch(id) { raise UnknownStepError, "Unknown step: #{id.inspect}" }
+      steps.fetch(id) { raise Errors::UnknownStepError, "Unknown step: #{id.inspect}" }
     end
 
     # @return [Array<Symbol>] all step ids in the definition
@@ -41,7 +41,9 @@ module FlowEngine
     private
 
     def validate!
-      raise DefinitionError, "Start step #{start_step_id.inspect} not found in nodes" unless steps.key?(start_step_id)
+      return if steps.key?(start_step_id)
+
+      raise Errors::DefinitionError, "Start step #{start_step_id.inspect} not found in nodes"
     end
   end
 end

data/lib/flowengine/dsl/flow_builder.rb

@@ -45,8 +45,8 @@ module FlowEngine
       # @return [Definition]
       # @raise [DefinitionError] if start was not set or no steps were defined
       def build
-        raise DefinitionError, "No start step defined" if @start_step_id.nil?
-        raise DefinitionError, "No steps defined" if @nodes.empty?
+        raise ::FlowEngine::Errors::DefinitionError, "No start step defined" if @start_step_id.nil?
+        raise ::FlowEngine::Errors::DefinitionError, "No steps defined" if @nodes.empty?
 
         Definition.new(start_step_id: @start_step_id, nodes: @nodes, introduction: @introduction)
       end

data/lib/flowengine/dsl/step_builder.rb

@@ -15,6 +15,7 @@ module FlowEngine
         @transitions = []
         @visibility_rule = nil
         @decorations = nil
+        @max_clarifications = 0
       end
 
       # Sets the step/input type (e.g. :multi_select, :number_matrix).
@@ -62,6 +63,13 @@ module FlowEngine
         @visibility_rule = rule
       end
 
+      # Sets the maximum number of clarification rounds for an :ai_intake step.
+      #
+      # @param count [Integer] max follow-up rounds (0 = one-shot, no clarifications)
+      def max_clarifications(count)
+        @max_clarifications = count
+      end
+
       # Builds the {Node} for the given step id from accumulated attributes.
       #
       # @param id [Symbol] step id
@@ -75,7 +83,8 @@ module FlowEngine
           fields: @fields,
           transitions: @transitions,
           visibility_rule: @visibility_rule,
-          decorations: @decorations
+          decorations: @decorations,
+          max_clarifications: @max_clarifications
         )
       end
     end

data/lib/flowengine/dsl.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "dsl/rule_helpers"
-require_relative "dsl/step_builder"
-require_relative "dsl/flow_builder"
-
 module FlowEngine
   # Namespace for the declarative flow DSL: {FlowBuilder} builds a {Definition} from blocks,
   # {StepBuilder} builds individual {Node}s, and {RuleHelpers} provide rule factory methods.

data/lib/flowengine/engine/state_serializer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FlowEngine
+  class Engine
+    # Handles state serialization and deserialization for Engine persistence.
+    # Normalizes string-keyed hashes (from JSON) to symbol-keyed hashes.
+    module StateSerializer
+      SYMBOLIZERS = {
+        current_step_id: ->(v) { v&.to_sym },
+        active_intake_step_id: ->(v) { v&.to_sym },
+        history: ->(v) { Array(v).map { |e| e&.to_sym } },
+        answers: ->(v) { symbolize_answers(v) },
+        conversation_history: ->(v) { symbolize_conversation_history(v) }
+      }.freeze
+
+      # Normalizes a state hash so step ids and history entries are symbols.
+      def self.symbolize_state(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          sym_key = key.to_sym
+          result[sym_key] = SYMBOLIZERS.fetch(sym_key, ->(v) { v }).call(value)
+        end
+      end
+
+      # @param answers [Hash] answers map (keys may be strings)
+      # @return [Hash] same map with symbol keys
+      def self.symbolize_answers(answers)
+        return {} unless answers.is_a?(Hash)
+
+        answers.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      end
+
+      # @param history [Array<Hash>] conversation history entries
+      # @return [Array<Hash>] same entries with symbolized keys and role
+      def self.symbolize_conversation_history(history)
+        return [] unless history.is_a?(Array)
+
+        history.map do |entry|
+          next entry unless entry.is_a?(Hash)
+
+          entry.each_with_object({}) do |(k, v), h|
+            sym_key = k.to_sym
+            h[sym_key] = sym_key == :role ? v.to_sym : v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flowengine/engine.rb

@@ -3,14 +3,9 @@
 module FlowEngine
   # Runtime session that drives flow navigation: holds definition, answers, and current step.
   # Validates each answer via an optional {Validation::Adapter}, then advances using node transitions.
-  #
-  # @attr_reader definition [Definition] immutable flow definition
-  # @attr_reader answers [Hash] step_id => value (mutable as user answers)
-  # @attr_reader history [Array<Symbol>] ordered list of step ids visited (including current)
-  # @attr_reader current_step_id [Symbol, nil] current step id, or nil when flow is finished
-  # @attr_reader introduction_text [String, nil] free-form text submitted before the flow began
-  class Engine
-    attr_reader :definition, :answers, :history, :current_step_id, :introduction_text
+  class Engine # rubocop:disable Metrics/ClassLength
+    attr_reader :definition, :answers, :history, :current_step_id, :introduction_text,
+                :clarification_round, :conversation_history
 
     # @param definition [Definition] the flow to run
     # @param validator [Validation::Adapter] validator for step answers (default: {Validation::NullAdapter})
@@ -21,6 +16,9 @@ module FlowEngine
       @current_step_id = definition.start_step_id
       @validator = validator
       @introduction_text = nil
+      @clarification_round = 0
+      @conversation_history = []
+      @active_intake_step_id = nil
       @history << @current_step_id
     end
 
@@ -42,10 +40,10 @@ module FlowEngine
     # @raise [AlreadyFinishedError] if the flow has already finished
     # @raise [ValidationError] if the validator rejects the value
     def answer(value)
-      raise AlreadyFinishedError, "Flow is already finished" if finished?
+      raise Errors::AlreadyFinishedError, "Flow is already finished" if finished?
 
       result = @validator.validate(current_step, value)
-      raise ValidationError, "Validation failed: #{result.errors.join(", ")}" unless result.valid?
+      raise Errors::ValidationError, "Validation failed: #{result.errors.join(", ")}" unless result.valid?
 
       answers[@current_step_id] = value
       advance_step
@@ -56,9 +54,6 @@ module FlowEngine
     #
     # @param text [String] user's free-form introduction
     # @param llm_client [LLM::Client] configured LLM client for parsing
-    # @raise [SensitiveDataError] if text contains SSN, ITIN, EIN, etc.
-    # @raise [ValidationError] if text exceeds the introduction maxlength
-    # @raise [LLMError] on LLM communication or parsing failures
     def submit_introduction(text, llm_client:)
       validate_introduction_length!(text)
       LLM::SensitiveDataFilter.check!(text)
@@ -68,65 +63,67 @@ module FlowEngine
       auto_advance_prefilled
     end
 
-    # Serializable state for persistence or resumption.
+    # Submits free-form text for the current AI intake step. Returns a ClarificationResult.
     #
-    # @return [Hash] current_step_id, answers, history, and introduction_text
+    # @param text [String] user's free-form text
+    # @param llm_client [LLM::Client] configured LLM client
+    # @return [ClarificationResult]
+    def submit_ai_intake(text, llm_client:)
+      node = current_step
+      raise Errors::EngineError, "Current step is not an AI intake step" unless node&.ai_intake?
+
+      LLM::SensitiveDataFilter.check!(text)
+
+      @active_intake_step_id = @current_step_id
+      @clarification_round = 1
+      @conversation_history = [{ role: :user, text: text }]
+
+      perform_intake_round(text, llm_client, node)
+    end
+
+    # Submits a clarification response for an ongoing AI intake conversation.
+    #
+    # @param text [String] user's response to the follow-up question
+    # @param llm_client [LLM::Client] configured LLM client
+    # @return [ClarificationResult]
+    def submit_clarification(text, llm_client:)
+      raise Errors::EngineError, "No active AI intake conversation to clarify" unless @active_intake_step_id
+
+      LLM::SensitiveDataFilter.check!(text)
+
+      node = @definition.step(@active_intake_step_id)
+      @clarification_round += 1
+      @conversation_history << { role: :user, text: text }
+
+      perform_intake_round(text, llm_client, node)
+    end
+
+    # Serializable state for persistence or resumption.
     def to_state
       {
         current_step_id: @current_step_id,
         answers: @answers,
         history: @history,
-        introduction_text: @introduction_text
+        introduction_text: @introduction_text,
+        clarification_round: @clarification_round,
+        conversation_history: @conversation_history,
+        active_intake_step_id: @active_intake_step_id
       }
     end
 
-    # Rebuilds an engine from a previously saved state (e.g. from DB or session).
+    # Rebuilds an engine from a previously saved state.
     #
     # @param definition [Definition] same definition used when state was captured
-    # @param state_hash [Hash] hash with :current_step_id, :answers, :history (keys may be strings)
+    # @param state_hash [Hash] hash with state keys (may be strings from JSON)
     # @param validator [Validation::Adapter] validator to use (default: NullAdapter)
     # @return [Engine] restored engine instance
     def self.from_state(definition, state_hash, validator: Validation::NullAdapter.new)
-      state = symbolize_state(state_hash)
+      state = StateSerializer.symbolize_state(state_hash)
       engine = allocate
       engine.send(:restore_state, definition, state, validator)
       engine
     end
 
-    # Normalizes a state hash so step ids and history entries are symbols; answers keys are symbols.
-    #
-    # @param hash [Hash] raw state (e.g. from JSON)
-    # @return [Hash] symbolized state
-    def self.symbolize_state(hash)
-      return hash unless hash.is_a?(Hash)
-
-      hash.each_with_object({}) do |(key, value), result|
-        sym_key = key.to_sym
-        result[sym_key] = case sym_key
-                          when :current_step_id
-                            value&.to_sym
-                          when :history
-                            Array(value).map { |v| v&.to_sym }
-                          when :answers
-                            symbolize_answers(value)
-                          else
-                            value
-                          end
-      end
-    end
-
-    # @param answers [Hash] answers map (keys may be strings)
-    # @return [Hash] same map with symbol keys
-    def self.symbolize_answers(answers)
-      return {} unless answers.is_a?(Hash)
-
-      answers.each_with_object({}) do |(key, value), result|
-        result[key.to_sym] = value
-      end
-    end
-
-    private_class_method :symbolize_state, :symbolize_answers
-
     private
 
     def restore_state(definition, state, validator)
@@ -136,12 +133,14 @@ module FlowEngine
       @answers = state[:answers] || {}
       @history = state[:history] || []
       @introduction_text = state[:introduction_text]
+      @clarification_round = state[:clarification_round] || 0
+      @conversation_history = state[:conversation_history] || []
+      @active_intake_step_id = state[:active_intake_step_id]
     end
 
     def advance_step
       node = definition.step(@current_step_id)
       next_id = node.next_step_id(answers)
-
       @current_step_id = next_id
       @history << next_id if next_id
     end
@@ -151,13 +150,58 @@ module FlowEngine
       return unless maxlength
       return if text.length <= maxlength
 
-      raise ValidationError, "Introduction text exceeds maxlength (#{text.length}/#{maxlength})"
+      raise Errors::ValidationError, "Introduction text exceeds maxlength (#{text.length}/#{maxlength})"
     end
 
-    # Advances through consecutive steps that already have pre-filled answers.
-    # Stops at the first step without a pre-filled answer or when the flow ends.
     def auto_advance_prefilled
       advance_step while @current_step_id && @answers.key?(@current_step_id)
     end
+
+    def perform_intake_round(user_text, llm_client, node)
+      result = llm_client.parse_ai_intake(
+        definition: @definition, user_text: user_text,
+        answered: @answers, conversation_history: @conversation_history
+      )
+      @answers.merge!(result[:answers])
+      follow_up = resolve_follow_up(result[:follow_up], node)
+
+      build_clarification_result(result[:answers], follow_up)
+    end
+
+    def resolve_follow_up(follow_up, node)
+      if follow_up && @clarification_round <= node.max_clarifications
+        @conversation_history << { role: :assistant, text: follow_up }
+        follow_up
+      else
+        finalize_intake
+        nil
+      end
+    end
+
+    def build_clarification_result(round_answers, follow_up)
+      ClarificationResult.new(
+        answered: round_answers,
+        pending_steps: pending_non_intake_steps,
+        follow_up: follow_up,
+        round: @clarification_round
+      )
+    end
+
+    def finalize_intake
+      @answers[@active_intake_step_id] = conversation_summary
+      @active_intake_step_id = nil
+      advance_step
+      auto_advance_prefilled
+    end
+
+    def conversation_summary
+      @conversation_history.map { |e| "#{e[:role]}: #{e[:text]}" }.join("\n")
+    end
+
+    def pending_non_intake_steps
+      @definition.steps.each_with_object([]) do |(id, node), pending|
+        pending << id unless node.ai_intake? || @answers.key?(id)
+      end
+    end
   end
 end

data/lib/flowengine/errors.rb

@@ -1,27 +1,50 @@
 # frozen_string_literal: true
 
 module FlowEngine
-  # Base exception for all flowengine errors.
-  class Error < StandardError; end
+  module Errors
+    # Base exception for all flowengine errors.
+    class Error < StandardError; end
 
-  # Raised when a flow definition is invalid (e.g. missing start step, unknown step reference).
-  class DefinitionError < Error; end
+    # Raised when configuration is invalid (e.g. missing models.yml).
+    class ConfigurationError < Error; end
 
-  # Raised when navigating to or requesting a step id that does not exist in the definition.
-  class UnknownStepError < Error; end
+    # Raised when a flow definition is invalid (e.g. missing start step, unknown step reference).
+    class DefinitionError < Error; end
 
-  # Base exception for runtime engine errors (e.g. validation, already finished).
-  class EngineError < Error; end
+    # Raised when navigating to or requesting a step id that does not exist in the definition.
+    class UnknownStepError < Error; end
 
-  # Raised when {Engine#answer} is called after the flow has already finished.
-  class AlreadyFinishedError < EngineError; end
+    # Base exception for runtime engine errors (e.g. validation, already finished).
+    class EngineError < Error; end
 
-  # Raised when the validator rejects the user's answer for the current step.
-  class ValidationError < EngineError; end
+    # Raised when {Engine#answer} is called after the flow has already finished.
+    class AlreadyFinishedError < EngineError; end
 
-  # Raised for LLM-related errors (missing API key, response parsing, etc.).
-  class LLMError < Error; end
+    # Raised when the validator rejects the user's answer for the current step.
+    class ValidationError < EngineError; end
 
-  # Raised when introduction text contains sensitive data (SSN, ITIN, EIN, etc.).
-  class SensitiveDataError < EngineError; end
+    # Raised when introduction text contains sensitive data (SSN, ITIN, EIN, etc.).
+    class SensitiveDataError < EngineError; end
+
+    # Base exception for LLM-related errors (missing API key, response parsing, etc.).
+    class LLMError < Error; end
+
+    # Raised when no API key is found for any provider.
+    class NoAPIKeyFoundError < LLMError; end
+
+    # Raised when a requested provider does not exist.
+    class NoSuchProviderExists < LLMError; end
+
+    # Raised when a provider is missing its API key.
+    class ProviderMissingApiKey < LLMError; end
+
+    # Raised when a requested model is not available.
+    class ModelNotAvailable < LLMError; end
+
+    # Raised when the LLM provider rejects the request due to rate limits or budget.
+    class OutOfBudgetError < LLMError; end
+
+    # Raised when the LLM provider rejects authentication credentials.
+    class AuthorizationError < LLMError; end
+  end
 end

data/lib/flowengine/llm/adapter.rb

@@ -1,18 +1,80 @@
 # frozen_string_literal: true
 
+require "ruby_llm"
+
 module FlowEngine
   module LLM
-    # Abstract adapter for LLM API calls. Subclass and implement {#chat}
-    # to integrate with a specific provider (OpenAI, Anthropic, etc.).
+    # Abstract adapter for LLM API calls. Subclass and implement the class methods
+    # {.api_key_var_name} and {.default_model} to integrate with a specific provider.
+    # Thread-safe: RubyLLM configuration is protected by a mutex.
     class Adapter
+      CONFIGURE_MUTEX = Mutex.new
+
+      attr_reader :api_key, :model, :qualifier, :vendor
+
+      # @param api_key [String, nil] API key; falls back to env var from {.api_key_var_name}
+      # @param model [String, nil] model identifier; falls back to {.default_model}
+      # @param qualifier [Symbol] adapter qualifier (:top, :default, :fastest)
+      # @raise [Errors::NoAPIKeyFoundError] if no API key is available
+      def initialize(api_key: nil, model: nil, qualifier: :default)
+        @qualifier = qualifier
+        @api_key = api_key || ENV.fetch(self.class.api_key_var_name, nil)
+        @model = model || self.class.default_model
+        @vendor = self.class.provider
+
+        unless @api_key
+          raise ::FlowEngine::Errors::NoAPIKeyFoundError,
+                "#{vendor} API key not available ($#{self.class.api_key_var_name} not set)"
+        end
+
+        configure_ruby_llm!
+        freeze
+      end
+
       # Sends a system + user prompt pair to the LLM and returns the response text.
       #
       # @param system_prompt [String] system instructions for the LLM
-      # @param user_prompt [String] user's introduction text
-      # @param model [String] model identifier (e.g. "gpt-4o-mini")
-      # @return [String] the LLM's response text (expected to be JSON)
-      def chat(system_prompt:, user_prompt:, model:)
-        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      # @param user_prompt [String] user's text
+      # @param model [String] model identifier (defaults to the adapter's model)
+      # @return [String] the LLM's response content
+      def chat(system_prompt:, user_prompt:, model: @model)
+        conversation = RubyLLM.chat(model: model)
+        response = conversation.with_instructions(system_prompt).ask(user_prompt)
+        response.content
+      end
+
+      # Derives the provider symbol from the class name.
+      # e.g. AnthropicAdapter => :anthropic, OpenAIAdapter => :openai
+      #
+      # @return [Symbol]
+      def self.provider
+        name.split("::").last.downcase.gsub("adapter", "").to_sym
+      end
+
+      # @return [String] name of the environment variable for this provider's API key
+      def self.api_key_var_name
+        raise NotImplementedError, "#{name}.api_key_var_name must be implemented"
+      end
+
+      # @return [String] default model identifier for this provider
+      def self.default_model
+        raise NotImplementedError, "#{name}.default_model must be implemented"
+      end
+
+      def inspect
+        "#<#{self.class.name} vendor=#{vendor} model=#{model} qualifier=#{qualifier}>"
+      end
+
+      alias to_s inspect
+
+      private
+
+      def configure_ruby_llm!
+        method_name = "#{vendor}_api_key="
+        key = api_key
+        CONFIGURE_MUTEX.synchronize do
+          RubyLLM.configure { |config| config.send(method_name, key) }
+        end
       end
     end
   end

data/lib/flowengine/llm/adapters/anthropic_adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlowEngine
+  module LLM
+    module Adapters
+      class AnthropicAdapter < Adapter
+        def self.api_key_var_name
+          "ANTHROPIC_API_KEY"
+        end
+
+        def self.default_model
+          "claude-sonnet-4-6"
+        end
+      end
+    end
+  end
+end

data/lib/flowengine/llm/adapters/gemini_adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlowEngine
+  module LLM
+    module Adapters
+      class GeminiAdapter < Adapter
+        def self.api_key_var_name
+          "GEMINI_API_KEY"
+        end
+
+        def self.default_model
+          "gemini-2.5-flash"
+        end
+      end
+    end
+  end
+end