smith-agents 0.4.0

data/lib/smith/persistence_adapters.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "monitor"
+require_relative "persistence_adapters/cache_store"
+require_relative "persistence_adapters/rails_cache"
+require_relative "persistence_adapters/redis_store"
+require_relative "persistence_adapters/active_record_store"
+require_relative "persistence_adapters/memory"
+require_relative "persistence_adapters/retry"
+
+module Smith
+  module PersistenceAdapters
+    SolidCache = RailsCache
+
+    # REQUIRED_METHODS is the immutable adapter contract: any object
+    # responding to these is a valid Smith persistence adapter. This
+    # contract is preserved across the Phase B persistence hardening
+    # work; new optional capabilities (store_versioned, TTL kwarg) are
+    # additive and queried via respond_to?.
+    REQUIRED_METHODS = %i[store fetch delete].freeze
+
+    # OPTIONAL_METHODS: capabilities adapters MAY implement. Callers
+    # check support via `supports?(adapter, capability)` and fall back
+    # gracefully (e.g., Workflow#persist! warns once and uses plain
+    # `store` when `store_versioned` is missing).
+    OPTIONAL_METHODS = %i[store_versioned record_heartbeat last_heartbeat].freeze
+
+    def self.resolve(adapter, **options)
+      return nil if adapter.nil?
+      return validate!(adapter) if adapter_like?(adapter)
+
+      if adapter.is_a?(Class)
+        instance = options.empty? ? adapter.new : adapter.new(**options)
+        return validate!(instance)
+      end
+
+      built_in = case adapter.to_sym
+                 when :cache_store
+                   CacheStore.new(**options)
+                 when :rails_cache, :solid_cache
+                   RailsCache.new(**options)
+                 when :redis
+                   RedisStore.new(**options)
+                 when :active_record
+                   ActiveRecordStore.new(**options)
+                 when :memory
+                   Memory.new
+                 else
+                   raise ArgumentError, "Unknown persistence adapter #{adapter.inspect}"
+                 end
+
+      validate!(built_in)
+    end
+
+    def self.adapter_like?(adapter)
+      REQUIRED_METHODS.all? { |method_name| adapter.respond_to?(method_name) }
+    end
+
+    def self.validate!(adapter)
+      return adapter if adapter_like?(adapter)
+
+      missing = REQUIRED_METHODS.reject { |method_name| adapter.respond_to?(method_name) }
+      raise ArgumentError, "Persistence adapter must implement #{missing.join(', ')}"
+    end
+
+    # Capability introspection used by Workflow#persist! to decide
+    # whether the adapter supports optimistic locking via store_versioned.
+    def self.supports?(adapter, capability)
+      adapter.respond_to?(capability)
+    end
+
+    # Tracks which adapter CLASSES have already warned about missing
+    # store_versioned capability. One warning per adapter class per
+    # Smith boot (not per workflow instance, not per persist call).
+    @_warned_classes = Set.new
+    @_warned_monitor = Monitor.new
+
+    def self.warn_missing_versioning(adapter)
+      klass = adapter.class
+      @_warned_monitor.synchronize do
+        return if @_warned_classes.include?(klass)
+
+        @_warned_classes << klass
+      end
+
+      Smith.config.logger&.warn(
+        "#{klass.name} does not implement store_versioned; " \
+        "optimistic locking is disabled for this adapter. " \
+        "Switch to RedisStore, ActiveRecordStore (with lock_version column), " \
+        "or the Memory adapter for race protection."
+      )
+    end
+
+    @_warned_heartbeat_classes = Set.new
+    @_warned_heartbeat_monitor = Monitor.new
+
+    def self.warn_missing_heartbeat(adapter)
+      klass = adapter.class
+      @_warned_heartbeat_monitor.synchronize do
+        return if @_warned_heartbeat_classes.include?(klass)
+
+        @_warned_heartbeat_classes << klass
+      end
+
+      Smith.config.logger&.warn(
+        "#{klass.name} does not implement record_heartbeat/last_heartbeat; " \
+        "Smith::Workflow.stuck_for? falls back to payload['updated_at'] parsing. " \
+        "For accurate liveness probes, switch to RedisStore or Memory."
+      )
+    end
+  end
+end

data/lib/smith/pricing.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Smith
+  module Pricing
+    # Compute provider cost for a single agent call. Two pricing shapes
+    # are supported:
+    #
+    #   Flat (existing): the catalog entry is a Hash with
+    #     `:input_cost_per_token` / `:output_cost_per_token` keys. Used
+    #     for models with a single rate across all input sizes
+    #     (Gemini 2.5 Flash, Claude Opus 4.6/4.7).
+    #
+    #   Tiered (new): the catalog entry has a `:tiers` array of bracket
+    #     hashes, each with `:max_input_tokens` (nil = unbounded ceiling),
+    #     `:input_cost_per_token`, `:output_cost_per_token`. Tiers are
+    #     walked in order; the first whose `max_input_tokens` covers the
+    #     call's input_tokens picks the rate. Used for models with
+    #     long-context premium pricing (Gemini 2.5 Pro: $1.25/$10 below
+    #     200K input tokens, $2.50/$15 above).
+    def self.compute_cost(model:, input_tokens:, output_tokens:)
+      catalog = Smith.config.pricing
+      return nil unless catalog
+
+      entry = catalog[model.to_s]
+      return nil unless entry
+
+      rates = resolve_rates(entry, input_tokens)
+      return nil unless rates
+
+      input_rate, output_rate = rates
+      (input_tokens * input_rate) + (output_tokens * output_rate)
+    end
+
+    # Returns [input_rate, output_rate] or nil if no applicable rate.
+    # Tiered shape is recognized by the presence of a :tiers key; flat
+    # shape is the legacy default.
+    def self.resolve_rates(entry, input_tokens)
+      tiers = entry[:tiers] || entry["tiers"]
+      if tiers.is_a?(Array) && !tiers.empty?
+        resolve_tiered(tiers, input_tokens)
+      else
+        flat = [entry[:input_cost_per_token], entry[:output_cost_per_token]]
+        return nil unless flat.all? { |r| r.is_a?(Numeric) }
+
+        flat
+      end
+    end
+    private_class_method :resolve_rates
+
+    def self.resolve_tiered(tiers, input_tokens)
+      tier = tiers.find do |t|
+        max = t[:max_input_tokens] || t["max_input_tokens"]
+        max.nil? || input_tokens <= max
+      end
+      return nil unless tier
+
+      input_rate = tier[:input_cost_per_token] || tier["input_cost_per_token"]
+      output_rate = tier[:output_cost_per_token] || tier["output_cost_per_token"]
+      return nil unless input_rate.is_a?(Numeric) && output_rate.is_a?(Numeric)
+
+      [input_rate, output_rate]
+    end
+    private_class_method :resolve_tiered
+  end
+end

data/lib/smith/providers/openai/responses.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+# VENDORED FROM: crmne/ruby_llm PR #770
+# Pinned SHA: a84517db65d3774c6b129dc88032fe32c8dbc722
+# Source path: lib/ruby_llm/providers/openai/responses.rb (rev a84517d)
+# License: MIT (matches RubyLLM upstream)
+#
+# Re-namespaced under `Smith::Providers::OpenAI::Responses`. The
+# render/parse methods are vendored verbatim (only constant qualification
+# changed: `Utils` → `::RubyLLM::Utils`, `Message` → `::RubyLLM::Message`,
+# etc.). Smith adds:
+#   - `complete(provider, messages, ...)`: Smith-authored entry point
+#     that the routing prepend (Smith::Providers::OpenAI::Routing) calls
+#     once the normalizer flags a request for /v1/responses routing.
+#     Drives HTTP dispatch via the provider's Faraday connection.
+#   - Inline `format_role` + `resolve_effort` helpers (vendored from
+#     PR #770's chat.rb because Smith's Responses module is standalone,
+#     not mixed into the provider class as upstream does).
+#
+# RETIREMENT: this file goes away when PR #770 merges into RubyLLM
+# (Smith bumps the ruby_llm dep + deletes this file + its routing
+# branch). The retirement path is documented in UPSTREAM_PROPOSAL.md.
+#
+# SYNC PROTOCOL: do NOT edit "vendored verbatim" methods directly. To
+# pull upstream changes before PR #770 merges, re-pin the SHA, re-fetch
+# via `gh api repos/crmne/ruby_llm/contents/lib/ruby_llm/providers/
+# openai/responses.rb?ref=<SHA>`, and replace the vendored block.
+# Smith-authored additions are clearly marked "SMITH-AUTHORED".
+
+require "json"
+require "ruby_llm"
+
+module Smith
+  module Providers
+    module OpenAI
+      # Responses API adapter consumed by Smith::Providers::OpenAI::Routing
+      # when Smith::Models::Normalizer flags a request for routing via
+      # OpenAI /v1/responses (typically: gpt-5 family + tools + thinking).
+      module Responses
+        # ---- Vendored verbatim from PR #770 responses.rb -----------------
+
+        RESPONSE_REASONING_TEXT_TYPES = %w[summary_text output_text].freeze
+
+        def self.responses_url
+          "responses"
+        end
+
+        # SMITH-AUTHORED entry point. Routing prepend calls this with
+        # the OpenAI provider instance + the same kwargs `complete`
+        # would receive. Renders the /v1/responses payload using the
+        # vendored helpers, POSTs via the provider's Faraday connection,
+        # parses the response back into a RubyLLM::Message.
+        #
+        # Streaming is intentionally NOT supported in this initial vendor
+        # because Smith's workflow execution path doesn't use it.
+        # Block-given calls raise NotImplementedError with a clear
+        # message so the host can either disable streaming or fall back
+        # to `openai_api_mode = :off`.
+        def self.complete(provider, messages, tools:, temperature:, model:, params: {}, headers: {},
+                          schema: nil, thinking: nil, tool_prefs: nil, &block)
+          if block
+            raise NotImplementedError,
+                  "Smith::Providers::OpenAI::Responses does not yet support streaming. " \
+                  "Streaming over /v1/responses needs a separate stream_response port from PR #770. " \
+                  "Workaround: pass no block (sync only), or set Smith.config.openai_api_mode = :off " \
+                  "to route via chat-completions with graceful tool-dropping."
+          end
+
+          payload = render_response_payload(
+            messages,
+            tools: tools,
+            temperature: temperature,
+            model: model,
+            stream: false,
+            schema: schema,
+            thinking: thinking,
+            tool_prefs: tool_prefs
+          )
+          payload = ::RubyLLM::Utils.deep_merge(payload, params) unless params.empty?
+
+          connection = provider.instance_variable_get(:@connection)
+          provider_headers = provider.send(:headers)
+          merged_headers = provider_headers.merge(headers)
+
+          http_response = connection.post(responses_url, payload) do |req|
+            merged_headers.each { |k, v| req.headers[k] = v }
+          end
+
+          parse_response_response(http_response, provider: provider)
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def self.render_response_payload(messages, tools:, temperature:, model:, stream: false, schema: nil,
+                                         thinking: nil, tool_prefs: nil, native_tools: nil)
+          tool_prefs ||= {}
+          payload = {
+            model: model.id,
+            input: format_response_input(messages),
+            stream: stream,
+            store: false
+          }
+
+          payload[:temperature] = temperature unless temperature.nil?
+          apply_response_tools(payload, tools, native_tools, tool_prefs)
+          apply_response_schema(payload, schema) if schema
+          apply_response_thinking(payload, thinking)
+          payload
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def self.format_response_input(messages)
+          messages.flat_map do |message|
+            if message.tool_call?
+              format_response_tool_calls(message.tool_calls)
+            elsif message.role == :tool
+              format_response_tool_result(message)
+            else
+              format_response_message(message)
+            end
+          end
+        end
+
+        # SMITH-AUTHORED kwarg addition: `provider:` is passed in so this
+        # standalone module can read `@config.openai_use_system_role` for
+        # `format_role`. Upstream method lives on the provider instance
+        # and reads `@config` directly; Smith's standalone module needs
+        # the indirection.
+        def self.parse_response_response(response, provider: nil) # rubocop:disable Lint/UnusedMethodArgument
+          data = response.body
+          return if data.empty?
+
+          raise ::RubyLLM::Error.new(response, data.dig("error", "message")) if data.dig("error", "message")
+
+          outputs = data["output"] || []
+          return if outputs.empty?
+
+          usage = data["usage"] || {}
+
+          ::RubyLLM::Message.new(
+            role: :assistant,
+            content: response_output_text(data),
+            thinking: ::RubyLLM::Thinking.build(text: response_reasoning_text(outputs)),
+            tool_calls: ToolsExtensions.parse_response_tool_calls(outputs),
+            input_tokens: usage["input_tokens"],
+            output_tokens: usage["output_tokens"],
+            cached_tokens: usage.dig("input_tokens_details", "cached_tokens"),
+            cache_creation_tokens: usage.dig("input_tokens_details", "cache_write_tokens") || 0,
+            thinking_tokens: usage.dig("output_tokens_details", "reasoning_tokens"),
+            model_id: data["model"],
+            raw: response
+          )
+        end
+
+        def self.format_response_message(message, provider: nil)
+          {
+            type: "message",
+            role: format_role(message.role, provider: provider),
+            content: format_response_content(message.content)
+          }.compact
+        end
+
+        def self.format_response_tool_calls(tool_calls)
+          tool_calls.map do |_, tool_call|
+            {
+              type: "function_call",
+              call_id: tool_call.id,
+              name: tool_call.name,
+              arguments: JSON.generate(tool_call.arguments || {})
+            }
+          end
+        end
+
+        def self.format_response_tool_result(message)
+          {
+            type: "function_call_output",
+            call_id: message.tool_call_id,
+            output: response_tool_output(message.content)
+          }
+        end
+
+        def self.apply_response_tools(payload, tools, native_tools, tool_prefs)
+          response_tools = tools.map { |_, tool| ToolsExtensions.response_tool_for(tool) }
+          response_tools.concat(::RubyLLM::Utils.to_safe_array(native_tools))
+          payload[:tools] = response_tools if response_tools.any?
+          unless tool_prefs[:choice].nil?
+            payload[:tool_choice] = ToolsExtensions.build_response_tool_choice(tool_prefs[:choice])
+          end
+          payload[:parallel_tool_calls] = tool_prefs[:calls] == :many unless tool_prefs[:calls].nil?
+        end
+
+        def self.apply_response_schema(payload, schema)
+          payload[:text] = {
+            format: {
+              type: "json_schema",
+              name: schema[:name],
+              schema: schema[:schema],
+              strict: schema[:strict]
+            }
+          }
+        end
+
+        def self.apply_response_thinking(payload, thinking)
+          effort = resolve_effort(thinking)
+          payload[:reasoning] = { effort: effort } if effort
+        end
+
+        def self.format_response_content(content)
+          return content.value if content.is_a?(::RubyLLM::Content::Raw)
+          return content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+          return content unless content.is_a?(::RubyLLM::Content)
+
+          parts = []
+          parts << format_response_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            parts << format_response_attachment(attachment)
+          end
+
+          parts
+        end
+
+        def self.format_response_attachment(attachment)
+          case attachment.type
+          when :image
+            {
+              type: "input_image",
+              image_url: attachment.url? ? attachment.source.to_s : attachment.for_llm
+            }
+          when :pdf
+            {
+              type: "input_file",
+              filename: attachment.filename,
+              file_data: attachment.for_llm
+            }
+          when :text
+            format_response_text(attachment.for_llm)
+          when :audio
+            raise ::RubyLLM::UnsupportedAttachmentError, "OpenAI Responses API does not support audio inputs yet"
+          else
+            raise ::RubyLLM::UnsupportedAttachmentError, attachment.type
+          end
+        end
+
+        def self.format_response_text(text)
+          {
+            type: "input_text",
+            text: text
+          }
+        end
+
+        def self.response_tool_output(content)
+          return JSON.generate(content.value) if content.is_a?(::RubyLLM::Content::Raw)
+          return content.text.to_s if content.is_a?(::RubyLLM::Content) && content.text
+          return JSON.generate(content.to_h) if content.is_a?(::RubyLLM::Content)
+          return JSON.generate(content) if content.is_a?(Hash) || content.is_a?(Array)
+
+          content.to_s
+        end
+
+        def self.response_output_text(data)
+          output_text = data["output_text"]
+          return output_text if output_text.is_a?(String) && !output_text.empty?
+
+          text = response_output_text_parts(data["output"]).join
+          text.empty? ? nil : text
+        end
+
+        def self.response_output_text_parts(outputs)
+          ::RubyLLM::Utils.to_safe_array(outputs).select { |output| output["type"] == "message" }.flat_map do |output|
+            ::RubyLLM::Utils.to_safe_array(output["content"]).filter_map do |content|
+              content["text"] if content["type"] == "output_text" && content["text"].is_a?(String)
+            end
+          end
+        end
+
+        def self.response_reasoning_text(outputs)
+          text = outputs.select { |output| output["type"] == "reasoning" }.flat_map do |output|
+            ::RubyLLM::Utils.to_safe_array(output["summary"] || output["content"]).filter_map do |content|
+              if RESPONSE_REASONING_TEXT_TYPES.include?(content["type"]) && content["text"].is_a?(String)
+                content["text"]
+              end
+            end
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        # ---- SMITH-AUTHORED helpers (inlined from PR #770 chat.rb) -------
+        #
+        # Upstream PR #770 keeps these on the chat module (which is mixed
+        # into the provider class so they're available as instance methods
+        # with access to @config). Smith's vendored Responses module is
+        # standalone (it can't read @config), so these helpers are
+        # inlined as class methods with the provider passed in where
+        # @config access is needed.
+
+        def self.format_role(role, provider: nil)
+          case role
+          when :system
+            config = provider&.instance_variable_get(:@config)
+            (config && config.respond_to?(:openai_use_system_role) && config.openai_use_system_role) ? "system" : "developer"
+          else
+            role.to_s
+          end
+        end
+
+        def self.resolve_effort(thinking)
+          return nil unless thinking
+
+          thinking.respond_to?(:effort) ? thinking.effort : thinking
+        end
+      end
+    end
+  end
+end

data/lib/smith/providers/openai/routing.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Smith
+  module Providers
+    module OpenAI
+      # Prepended onto RubyLLM::Providers::OpenAI. Intercepts the chat
+      # `complete` call and routes to /v1/responses when the rendered
+      # payload's `openai_api_mode` hint (set by the normalizer via
+      # `chat.with_params(openai_api_mode: :responses)`) requests it.
+      #
+      # Does NOT rename `RubyLLM::Providers::OpenAI::Chat#completion_url`
+      # (PR #770 does; Smith diverges to keep the surface narrower).
+      # The instance_of? check prevents routing on OpenAI-compatible
+      # subclasses (OpenRouter, Azure, Bedrock).
+      #
+      # The full /v1/responses payload assembly lives in
+      # Smith::Providers::OpenAI::Responses (vendored from
+      # crmne/ruby_llm PR #770 at SHA a84517db65d3774c6b129dc88032fe32c8dbc722).
+      # When the PR merges upstream, Smith bumps the ruby_llm dep and
+      # deletes the vendored files. The defined? guard in
+      # `route_via_responses` keeps the routing safe even if a host pins
+      # an older Smith without the vendored adapter, raising a clear
+      # NotImplementedError rather than silently falling through to
+      # chat-completions (which would still fail with the original
+      # tools+reasoning combo error).
+      module Routing
+        def complete(messages, tools:, temperature:, model:, params: {}, headers: {},
+                     schema: nil, thinking: nil, tool_prefs: nil, &)
+          mode = params[:openai_api_mode] || params["openai_api_mode"]
+          if mode.to_s == "responses" && instance_of?(::RubyLLM::Providers::OpenAI)
+            route_via_responses(
+              messages,
+              tools: tools, temperature: temperature, model: model,
+              params: params.except(:openai_api_mode, "openai_api_mode"),
+              headers: headers, schema: schema, thinking: thinking,
+              tool_prefs: tool_prefs, &
+            )
+          else
+            super
+          end
+        end
+
+        private
+
+        def route_via_responses(messages, **, &)
+          if defined?(Smith::Providers::OpenAI::Responses)
+            Smith::Providers::OpenAI::Responses.complete(self, messages, **, &)
+          else
+            raise NotImplementedError,
+                  "Smith::Providers::OpenAI::Responses (the /v1/responses adapter) " \
+                  "is not yet vendored. PR #770 on crmne/ruby_llm tracks the upstream " \
+                  "implementation. Until it lands, set Smith.config.openai_api_mode = :off " \
+                  "to fall back to graceful tool-dropping when (gpt-5 + tools + thinking) " \
+                  "is detected."
+          end
+        end
+      end
+    end
+  end
+end
+
+# Install once at gem-require. Idempotent.
+unless RubyLLM::Providers::OpenAI.ancestors.include?(Smith::Providers::OpenAI::Routing)
+  RubyLLM::Providers::OpenAI.prepend(Smith::Providers::OpenAI::Routing)
+end

data/lib/smith/providers/openai/tools_extensions.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# VENDORED FROM: crmne/ruby_llm PR #770
+# Pinned SHA: a84517db65d3774c6b129dc88032fe32c8dbc722
+# Source path: lib/ruby_llm/providers/openai/tools.rb (rev a84517d)
+# License: MIT (matches RubyLLM upstream)
+#
+# Re-namespaced under `Smith::Providers::OpenAI::ToolsExtensions` (the
+# upstream is `RubyLLM::Providers::OpenAI::Tools`, which Smith cannot
+# vendor under the same name without colliding with RubyLLM's existing
+# Tools module). Functionally a verbatim copy of the methods needed by
+# Smith::Providers::OpenAI::Responses; constants and helpers used only
+# by the chat-completions path were intentionally omitted.
+#
+# RETIREMENT: this file goes away when PR #770 merges into RubyLLM
+# (Smith bumps the ruby_llm dep + deletes this file + the routing
+# branch that references it). Tracking: UPSTREAM_PROPOSAL.md retirement
+# checklist.
+#
+# SYNC PROTOCOL: do NOT modify methods marked "vendored verbatim". When
+# PR #770 lands changes upstream before merge, re-pin the SHA at the
+# top of this file, re-fetch via `gh api repos/crmne/ruby_llm/contents/
+# lib/ruby_llm/providers/openai/tools.rb?ref=<SHA>`, and replace the
+# vendored block. Smith-authored helpers (none currently in this file)
+# would be marked with "SMITH-AUTHORED" comments.
+
+require "ruby_llm"
+
+module Smith
+  module Providers
+    module OpenAI
+      # Tool format helpers consumed by Smith::Providers::OpenAI::Responses.
+      # Vendored from PR #770; namespace-only changes.
+      module ToolsExtensions
+        module_function
+
+        EMPTY_PARAMETERS_SCHEMA = {
+          "type" => "object",
+          "properties" => {},
+          "required" => [],
+          "additionalProperties" => false,
+          "strict" => true
+        }.freeze
+
+        def parameters_schema_for(tool)
+          tool.params_schema ||
+            schema_from_parameters(tool.parameters)
+        end
+
+        def schema_from_parameters(parameters)
+          schema_definition = ::RubyLLM::Tool::SchemaDefinition.from_parameters(parameters)
+          schema_definition&.json_schema || EMPTY_PARAMETERS_SCHEMA
+        end
+
+        def response_tool_for(tool)
+          definition = {
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: parameters_schema_for(tool)
+          }
+
+          return definition if tool.provider_params.empty?
+
+          ::RubyLLM::Utils.deep_merge(definition, tool.provider_params)
+        end
+
+        def parse_response_tool_calls(outputs)
+          function_calls = ::RubyLLM::Utils.to_safe_array(outputs).select { |output| output["type"] == "function_call" }
+          return nil if function_calls.empty?
+
+          function_calls.to_h do |output|
+            id = output["call_id"] || output["id"]
+            [
+              id,
+              ::RubyLLM::ToolCall.new(
+                id: id,
+                name: output["name"],
+                arguments: parse_response_tool_call_arguments(output)
+              )
+            ]
+          end
+        end
+
+        def parse_response_tool_call_arguments(output)
+          arguments = output["arguments"]
+          return {} if arguments.nil? || arguments.empty?
+
+          JSON.parse(arguments)
+        end
+
+        def build_response_tool_choice(tool_choice)
+          case tool_choice
+          when :auto, :none, :required
+            tool_choice
+          else
+            {
+              type: "function",
+              name: tool_choice
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smith/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Smith
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path("tasks/doctor.rake", __dir__)
+    end
+  end
+end