langchainrb 0.16.1 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b078089a99e9e8d6654a244165ecc9d0f3dfdd8fbc0367623d41fe771a98ac41
-  data.tar.gz: 890c371564ce9188087bed9eb053a59e11f7b734a44b9f753696f8458f8a7b7e
+  metadata.gz: f7061ef2090d35626239ca575b60edb291dbbadab7de85a5a2796792e1691437
+  data.tar.gz: 30cb1f14b602a22e7df8f2dba42660383d44482cbe83fb35dc9539afa836739c
 SHA512:
-  metadata.gz: 8f458bfae5af31190f41661a13c24e5cd63d5f88e594e854ee79ea3b8af1f51b20552f178c89c71e454a86e4d827b3facecd97f0fa3ef107b7b6097754fab5e3
-  data.tar.gz: cfe0c684f89c5eef73ceb26b70292fe8fc4f941e13795ac98bd1d3197321a1303250d2584f9e45aa530e311304004911ffe3a6af7f606f6a733baad21ff2b814
+  metadata.gz: dd08fb29bd0ff9237cc27980c3bac607baeb9d54a93f297b1e81fb863b7cbb9720db4adacb3dae92bcbe71d2eb59b38d4de0ee321face467a0b82bde627d2929
+  data.tar.gz: 4a3661afd2d9d75a64e02f6f173cd0bf0e016207c444ca4506bab907f00dc906f5bbf82c96aad9521280265f214b0f3e82dd5e4ee54dc40f3afb415a6f50b365

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.17.1] - 2024-10-07
+- Move Langchain::Assistant::LLM::Adapter-related classes to separate files
+- Fix Langchain::Tool::Database#describe_table method
+
+## [0.17.0] - 2024-10-02
+- [BREAKING] Langchain::Vectorsearch::Milvus was rewritten to work with newer milvus 0.10.0 gem
+- [BREAKING] Removing Langchain::LLM::GooglePalm
+- Assistant can now process image_urls in the messages (currently only for OpenAI and Mistral AI)
+- Vectorsearch providers utilize the global Langchain.logger
+- Update required milvus, qdrant and weaviate versions
+
 ## [0.16.1] - 2024-09-30
 - Deprecate Langchain::LLM::GooglePalm
 - Allow setting response_object: {} parameter when initializing supported Langchain::LLM::* classes

data/README.md

@@ -63,7 +63,6 @@ The `Langchain::LLM` module provides a unified interface for interacting with va
 - Azure OpenAI
 - Cohere
 - Google Gemini
-- Google PaLM (deprecated)
 - Google Vertex AI
 - HuggingFace
 - LlamaCpp
@@ -501,6 +500,12 @@ assistant = Langchain::Assistant.new(
 # Add a user message and run the assistant
 assistant.add_message_and_run!(content: "What's the latest news about AI?")
 
+# Supply an image to the assistant
+assistant.add_message_and_run!(
+  content: "Show me a picture of a cat",
+  image: "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
+)
+
 # Access the conversation thread
 messages = assistant.messages
 

data/lib/langchain/assistants/assistant.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "llm/adapter"
+
 module Langchain
   # Assistants are Agent-like objects that leverage helpful instructions, LLMs, tools and knowledge to respond to user queries.
   # Assistants can be configured with an LLM of your choice, any vector search database and easily extended with additional tools.
@@ -63,13 +65,14 @@ module Langchain
 
     # Add a user message to the messages array
     #
-    # @param content [String] The content of the message
     # @param role [String] The role attribute of the message. Default: "user"
+    # @param content [String] The content of the message
+    # @param image_url [String] The URL of the image to include in the message
     # @param tool_calls [Array<Hash>] The tool calls to include in the message
     # @param tool_call_id [String] The ID of the tool call to include in the message
     # @return [Array<Langchain::Message>] The messages
-    def add_message(content: nil, role: "user", tool_calls: [], tool_call_id: nil)
-      message = build_message(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+    def add_message(role: "user", content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+      message = build_message(role: role, content: content, image_url: image_url, tool_calls: tool_calls, tool_call_id: tool_call_id)
 
       # Call the callback with the message
       add_message_callback.call(message) if add_message_callback # rubocop:disable Style/SafeNavigation
@@ -145,8 +148,8 @@ module Langchain
     # @param content [String] The content of the message
     # @param auto_tool_execution [Boolean] Whether or not to automatically run tools
     # @return [Array<Langchain::Message>] The messages
-    def add_message_and_run(content:, auto_tool_execution: false)
-      add_message(content: content, role: "user")
+    def add_message_and_run(content: nil, image_url: nil, auto_tool_execution: false)
+      add_message(content: content, image_url: image_url, role: "user")
       run(auto_tool_execution: auto_tool_execution)
     end
 
@@ -154,8 +157,8 @@ module Langchain
     #
     # @param content [String] The content of the message
     # @return [Array<Langchain::Message>] The messages
-    def add_message_and_run!(content:)
-      add_message_and_run(content: content, auto_tool_execution: true)
+    def add_message_and_run!(content: nil, image_url: nil)
+      add_message_and_run(content: content, image_url: image_url, auto_tool_execution: true)
     end
 
     # Submit tool output
@@ -388,11 +391,12 @@ module Langchain
     #
     # @param role [String] The role of the message
     # @param content [String] The content of the message
+    # @param image_url [String] The URL of the image to include in the message
     # @param tool_calls [Array<Hash>] The tool calls to include in the message
     # @param tool_call_id [String] The ID of the tool call to include in the message
     # @return [Langchain::Message] The Message object
-    def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-      @llm_adapter.build_message(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+    def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+      @llm_adapter.build_message(role: role, content: content, image_url: image_url, tool_calls: tool_calls, tool_call_id: tool_call_id)
     end
 
     # Increment the tokens count based on the last interaction with the LLM
@@ -410,314 +414,5 @@ module Langchain
     def available_tool_names
       llm_adapter.available_tool_names(tools)
     end
-
-    # TODO: Fix the message truncation when context window is exceeded
-
-    module LLM
-      class Adapter
-        def self.build(llm)
-          case llm
-          when Langchain::LLM::Anthropic
-            Adapters::Anthropic.new
-          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
-            Adapters::GoogleGemini.new
-          when Langchain::LLM::MistralAI
-            Adapters::MistralAI.new
-          when Langchain::LLM::Ollama
-            Adapters::Ollama.new
-          when Langchain::LLM::OpenAI
-            Adapters::OpenAI.new
-          else
-            raise ArgumentError, "Unsupported LLM type: #{llm.class}"
-          end
-        end
-      end
-
-      module Adapters
-        class Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            raise NotImplementedError, "Subclasses must implement build_chat_params"
-          end
-
-          def extract_tool_call_args(tool_call:)
-            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            raise NotImplementedError, "Subclasses must implement build_message"
-          end
-        end
-
-        class Ollama < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the OpenAI tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          private
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-        end
-
-        class OpenAI < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::OpenAIMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the OpenAI tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              choice
-            else
-              {"type" => "function", "function" => {"name" => choice}}
-            end
-          end
-        end
-
-        class MistralAI < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::MistralAIMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the OpenAI tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              choice
-            else
-              {"type" => "function", "function" => {"name" => choice}}
-            end
-          end
-        end
-
-        class GoogleGemini < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:system] = instructions if instructions
-              params[:tool_choice] = build_tool_config(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the Google Gemini tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("functionCall", "name")
-            function_name = tool_call.dig("functionCall", "name")
-            tool_name, method_name = function_name.split("__")
-            tool_arguments = tool_call.dig("functionCall", "args").transform_keys(&:to_sym)
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:name) }
-          end
-
-          private
-
-          def build_tool_config(choice)
-            case choice
-            when "auto"
-              {function_calling_config: {mode: "auto"}}
-            when "none"
-              {function_calling_config: {mode: "none"}}
-            else
-              {function_calling_config: {mode: "any", allowed_function_names: [choice]}}
-            end
-          end
-        end
-
-        class Anthropic < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params[:system] = instructions if instructions
-            params
-          end
-
-          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the Anthropic tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-            function_name = tool_call.dig("name")
-            tool_name, method_name = function_name.split("__")
-            tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "any"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              {type: "auto"}
-            when "any"
-              {type: "any"}
-            else
-              {type: "tool", name: choice}
-            end
-          end
-        end
-      end
-    end
   end
 end

data/lib/langchain/assistants/llm/adapter.rb

@@ -0,0 +1,27 @@
+Dir[Pathname.new(__FILE__).dirname.join("adapters", "*.rb")].sort.each { |file| require file }
+
+module Langchain
+  class Assistant
+    module LLM
+      # TODO: Fix the message truncation when context window is exceeded
+      class Adapter
+        def self.build(llm)
+          case llm
+          when Langchain::LLM::Anthropic
+            LLM::Adapters::Anthropic.new
+          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
+            LLM::Adapters::GoogleGemini.new
+          when Langchain::LLM::MistralAI
+            LLM::Adapters::MistralAI.new
+          when Langchain::LLM::Ollama
+            LLM::Adapters::Ollama.new
+          when Langchain::LLM::OpenAI
+            LLM::Adapters::OpenAI.new
+          else
+            raise ArgumentError, "Unsupported LLM type: #{llm.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/_base.rb

@@ -0,0 +1,21 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            raise NotImplementedError, "Subclasses must implement build_chat_params"
+          end
+
+          def extract_tool_call_args(tool_call:)
+            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            raise NotImplementedError, "Subclasses must implement build_message"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/anthropic.rb

@@ -0,0 +1,62 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class Anthropic < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
+            end
+            params[:system] = instructions if instructions
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            warn "Image URL is not supported by Anthropic currently" if image_url
+
+            Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the Anthropic tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+            function_name = tool_call.dig("name")
+            tool_name, method_name = function_name.split("__")
+            tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "any"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:name) }
+          end
+
+          private
+
+          def build_tool_choice(choice)
+            case choice
+            when "auto"
+              {type: "auto"}
+            when "any"
+              {type: "any"}
+            else
+              {type: "tool", name: choice}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/google_gemini.rb

@@ -0,0 +1,62 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class GoogleGemini < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:system] = instructions if instructions
+              params[:tool_choice] = build_tool_config(tool_choice)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            warn "Image URL is not supported by Google Gemini" if image_url
+
+            Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the Google Gemini tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("functionCall", "name")
+            function_name = tool_call.dig("functionCall", "name")
+            tool_name, method_name = function_name.split("__")
+            tool_arguments = tool_call.dig("functionCall", "args").transform_keys(&:to_sym)
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:name) }
+          end
+
+          private
+
+          def build_tool_config(choice)
+            case choice
+            when "auto"
+              {function_calling_config: {mode: "auto"}}
+            when "none"
+              {function_calling_config: {mode: "none"}}
+            else
+              {function_calling_config: {mode: "any", allowed_function_names: [choice]}}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/mistral_ai.rb

@@ -0,0 +1,65 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class MistralAI < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::MistralAIMessage.new(role: role, content: content, image_url: image_url, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the OpenAI tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+
+            function_name = tool_call.dig("function", "name")
+            tool_name, method_name = function_name.split("__")
+
+            tool_arguments = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:function, :name) }
+          end
+
+          private
+
+          def build_tool_choice(choice)
+            case choice
+            when "auto"
+              choice
+            else
+              {"type" => "function", "function" => {"name" => choice}}
+            end
+          end
+        end
+      end
+    end
+  end
+end