fix specs... a few more to go

Author: SamSaffron

lib/completions/dialects/claude_tools.rb

@@ -9,32 +9,8 @@ def initialize(tools)
         end
 
         def translated_tools
-          # Transform the raw tools into the required Anthropic Claude API format
           raw_tools.map do |t|
-            properties = {}
-            required = []
-
-            if t.parameters
-              properties = {}
-
-              t.parameters.each do |param|
-                mapped = { type: param.type, description: param.description }
-                mapped[:items] = { type: param.item_type } if param.item_type
-                mapped[:enum] = param.enum if param.enum
-                properties[param.name] = mapped
-              end
-              required = t.parameters.select { |param| param.required }.map { |param| param.name }
-            end
-
-            {
-              name: t.name,
-              description: t.description,
-              input_schema: {
-                type: "object",
-                properties: properties,
-                required: required,
-              },
-            }
+            { name: t.name, description: t.description, input_schema: t.parameters_json_schema }
           end
         end
 

lib/completions/dialects/gemini.rb

@@ -47,22 +47,8 @@ def tools
 
           translated_tools =
             prompt.tools.map do |t|
-              tool = t.slice(:name, :description)
-
-              if t[:parameters]
-                tool[:parameters] = t[:parameters].reduce(
-                  { type: "object", required: [], properties: {} },
-                ) do |memo, p|
-                  name = p[:name]
-                  memo[:required] << name if p[:required]
-
-                  memo[:properties][name] = p.except(:name, :required, :item_type)
-
-                  memo[:properties][name][:items] = { type: p[:item_type] } if p[:item_type]
-                  memo
-                end
-              end
-
+              tool = { name: t.name, description: t.description }
+              tool[:parameters] = t.parameters_json_schema if t.parameters
               tool
             end
 

lib/completions/dialects/ollama_tools.rb

@@ -14,23 +14,15 @@ def instructions
         end
 
         def translated_tools
-          raw_tools.map do |t|
-            tool = t.dup
-
-            tool[:parameters] = t[:parameters]
-              .to_a
-              .reduce({ type: "object", properties: {}, required: [] }) do |memo, p|
-                name = p[:name]
-                memo[:required] << name if p[:required]
-
-                except = %i[name required item_type]
-                except << :enum if p[:enum].blank?
-
-                memo[:properties][name] = p.except(*except)
-                memo
-              end
-
-            { type: "function", function: tool }
+          raw_tools.map do |tool|
+            {
+              type: "function",
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters_json_schema,
+              },
+            }
           end
         end
 

lib/completions/dialects/open_ai_tools.rb

@@ -10,28 +10,14 @@ def initialize(tools)
 
         def translated_tools
           raw_tools.map do |tool|
-            properties = {}
-            required = []
-
-            result = {
-              name: tool.name,
-              description: tool.description,
-              parameters: {
-                type: "object",
-                properties: properties,
-                required: required,
+            {
+              type: "function",
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters_json_schema,
               },
             }
-
-            tool.parameters.each do |param|
-              name = param.name
-              required << name if param.required
-              properties[name] = { type: param.type, description: param.description }
-              properties[name][:items] = { type: param.item_type } if param.item_type
-              properties[name][:enum] = param.enum if param.enum
-            end
-
-            { type: "function", function: result }
           end
         end
 

lib/completions/tool_definition.rb

@@ -95,6 +95,23 @@ def to_h
         end
       end
 
+      def parameters_json_schema
+        properties = {}
+        required = []
+
+        result = { type: "object", properties: properties, required: required }
+
+        parameters.each do |param|
+          name = param.name
+          required << name if param.required
+          properties[name] = { type: param.type, description: param.description }
+          properties[name][:items] = { type: param.item_type } if param.item_type
+          properties[name][:enum] = param.enum if param.enum
+        end
+
+        result
+      end
+
       attr_reader :name, :description, :parameters
 
       def self.from_hash(hash)

spec/lib/completions/dialects/chat_gpt_spec.rb

@@ -99,17 +99,21 @@
     it "returns a list of available tools" do
       open_ai_tool_f = {
         function: {
-          description: context.tools.first[:description],
-          name: context.tools.first[:name],
+          description: context.tools.first.description,
+          name: context.tools.first.name,
           parameters: {
             properties:
-              context.tools.first[:parameters].reduce({}) do |memo, p|
-                memo[p[:name]] = { description: p[:description], type: p[:type] }
+              context
+                .tools
+                .first
+                .parameters
+                .reduce({}) do |memo, p|
+                  memo[p.name] = { description: p.description, type: p.type }
 
-                memo[p[:name]][:enum] = p[:enum] if p[:enum]
+                  memo[p.name][:enum] = p.enum if p.enum
 
-                memo
-              end,
+                  memo
+                end,
             required: %w[location unit],
             type: "object",
           },

spec/lib/completions/dialects/dialect_context.rb

@@ -115,6 +115,6 @@ def tools
           },
         ],
       },
-    ]
+    ].map { |tool| DiscourseAi::Completions::ToolDefinition.from_hash(tool) }
   end
 end

spec/lib/completions/tool_definition_spec.rb

@@ -90,14 +90,14 @@
       end
     end
 
-    context "with items specification" do
-      it "only allows items for array type parameters" do
+    context "with item_type specification" do
+      it "only allows item_type for array type parameters" do
         expect {
           described_class.new(
             name: "colors",
             description: "List of colors",
             type: :array,
-            items: :string,
+            item_type: :string,
           )
         }.not_to raise_error
 
@@ -106,9 +106,9 @@
             name: "color",
             description: "A single color",
             type: :string,
-            items: :string,
+            item_type: :string,
           )
-        }.to raise_error(ArgumentError, /items can only be specified for array type/)
+        }.to raise_error(ArgumentError, /item_type can only be specified for array type/)
       end
     end
   end
@@ -179,7 +179,7 @@
             name: "numbers",
             description: "List of numeric values",
             type: :array,
-            items: :integer,
+            item_type: :integer,
           )
 
         described_class.new(
@@ -311,7 +311,7 @@
           name: "colors",
           description: "List of colors",
           type: :array,
-          items: :string,
+          item_type: :string,
           required: true,
         )
 
@@ -331,7 +331,7 @@
       param_hash = hash[:parameters].first
       expect(param_hash[:name]).to eq("colors")
       expect(param_hash[:type]).to eq(:array)
-      expect(param_hash[:items]).to eq(:string)
+      expect(param_hash[:item_type]).to eq(:string)
       expect(param_hash[:required]).to eq(true)
     end
   end