foobara-llm-backed-command 0.0.10 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad9f2ebc5f7f9277ed85e0f8cc410470a8ee00d9b6d88c8afb8dabab1bd604fb
-  data.tar.gz: 1076fec92769e65d72a4674e77989520f562e0c5c6f432afe4a11cab5e38a853
+  metadata.gz: 7747f5873ca5862ac16e10edc62f856fe9f41b480ca9537e2fac7d967b2647ba
+  data.tar.gz: 718b24e6f4e33bc993fd39fd043a17343ea7e7b8342b5cc1807d5b7f662f009b
 SHA512:
-  metadata.gz: 03e6f1c662e353803a097cc675e8f71d8911d02036fa668a66f64dbd6940b7c48125d538dd975ae80ff8348a9f43cfdecd602bb0a4393fd8c0d27f9871c31e1c
-  data.tar.gz: 99f9120528785f7260d896967c4d9737e3ebdd75967aec9432e20ce9a3dbed5f85a1d6ebd1a254a23e370562e4ab4f44825f8b662ce3b7732abb0068d2c6e706
+  metadata.gz: 7425c556694c8350956580d8492321b8d622c66245d0853911602229ecf894457f1bdb5c08934de8bc4a4e9bf06583983173a84f7dd563bd25f949cccfc41b19
+  data.tar.gz: 14847e3e1fc3de9d2f438b4a19690a018341e09d40f9ff617175ce8be2604f8abb99d6b860b8015f92136bc373b903d0c72e644e9080df1e4df3a19324d5ed58

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.0.0] - 2025-07-08
+
+- Add support for separate serializers for user and assistant messages
+
 ## [0.0.10] - 2025-07-06
 
 - Handle bizarre deepseek-r1 stranded </think> tag

data/src/llm_backed_execute_method.rb

@@ -2,13 +2,20 @@
 # on the class.
 #
 # inputs do
-#   association_depth :symbol, one_of: JsonSchemaGenerator::AssociationDepth, default: AssociationDepth::ATOM
+#   association_depth :symbol, one_of: AssociationDepth, default: AssociationDepth::ATOM
 #   llm_model :symbol, one_of: Foobara::Ai::AnswerBot::Types::ModelEnum
 # end
 module Foobara
   module LlmBackedExecuteMethod
     include Concern
 
+    LLM_INTEGRATION_KEYS = [
+      :llm_model,
+      :association_depth,
+      :user_association_depth,
+      :assistant_association_depth
+    ].freeze
+
     on_include do
       depends_on Ai::AnswerBot::GenerateNextMessage
       possible_error :could_not_parse_result_json,
@@ -20,7 +27,11 @@ module Foobara
     end
 
     def execute
-      determine_serializer
+      determine_user_association_depth
+      determine_assistant_association_depth
+      determine_user_serializer
+      determine_assistant_serializer
+      determine_llm_instructions
       construct_messages
       generate_answer
       parse_answer
@@ -28,32 +39,51 @@ module Foobara
       parsed_answer
     end
 
-    attr_accessor :serializer, :answer, :parsed_answer, :messages
-
-    def determine_serializer
-      depth = if respond_to?(:association_depth)
-                association_depth
-              else
-                Foobara::JsonSchemaGenerator::AssociationDepth::AGGREGATE
-              end
-
-      serializer = case depth
-                   when Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-                     Foobara::CommandConnectors::Serializers::AtomicSerializer
-                   when Foobara::JsonSchemaGenerator::AssociationDepth::AGGREGATE
-                     Foobara::CommandConnectors::Serializers::AggregateSerializer
-                   when Foobara::JsonSchemaGenerator::AssociationDepth::PRIMARY_KEY_ONLY
-                     # :nocov:
-                     raise "PRIMARY_KEY_ONLY depth not yet implemented"
-                   # :nocov:
-                   else
-                     # :nocov:
-                     raise "Unknown depth: #{depth}"
-                     # :nocov:
-                   end
-
-      # cache this?
-      self.serializer = serializer.new
+    attr_accessor :answer, :parsed_answer, :messages, :assistant_serializer, :user_serializer,
+                  :computed_assistant_association_depth, :computed_user_association_depth,
+                  :llm_instructions
+
+    def determine_assistant_association_depth
+      self.computed_assistant_association_depth = if respond_to?(:assistant_association_depth)
+                                                    assistant_association_depth
+                                                  elsif respond_to?(:association_depth)
+                                                    association_depth
+                                                  else
+                                                    Foobara::AssociationDepth::PRIMARY_KEY_ONLY
+                                                  end
+    end
+
+    def determine_assistant_serializer
+      self.assistant_serializer = depth_to_serializer(computed_assistant_association_depth)
+    end
+
+    def determine_user_association_depth
+      self.computed_user_association_depth = if respond_to?(:user_association_depth)
+                                               user_association_depth
+                                             elsif respond_to?(:association_depth)
+                                               association_depth
+                                             else
+                                               Foobara::AssociationDepth::ATOM
+                                             end
+    end
+
+    def determine_user_serializer
+      self.user_serializer = depth_to_serializer(computed_user_association_depth)
+    end
+
+    def depth_to_serializer(depth)
+      case depth
+      when Foobara::AssociationDepth::ATOM
+        Foobara::CommandConnectors::Serializers::AtomicSerializer
+      when Foobara::AssociationDepth::AGGREGATE
+        Foobara::CommandConnectors::Serializers::AggregateSerializer
+      when Foobara::AssociationDepth::PRIMARY_KEY_ONLY
+        Foobara::CommandConnectors::Serializers::EntitiesToPrimaryKeysSerializer
+      else
+        # :nocov:
+        raise "Unknown depth: #{depth}"
+        # :nocov:
+      end.instance
     end
 
     def generate_answer
@@ -61,6 +91,7 @@ module Foobara
         chat: Ai::AnswerBot::Types::Chat.new(messages:)
       }
 
+      # NOTE: some models don't allow 0 such as o1.  Manually set to 1 in calling code for such models for now.
       inputs[:temperature] = if respond_to?(:temperature)
                                temperature
                              end || 0
@@ -81,12 +112,25 @@ module Foobara
         if content.is_a?(String)
           message
         else
+          serializer = if message[:role] == :user
+                         user_serializer
+                       else
+                         assistant_serializer
+                       end
+
           content = serializer.serialize(content)
           message.merge(content: JSON.fast_generate(content))
         end
       end
     end
 
+    def determine_llm_instructions
+      self.llm_instructions = self.class.llm_instructions(
+        computed_user_association_depth,
+        computed_assistant_association_depth
+      )
+    end
+
     def build_messages
       [
         {
@@ -95,20 +139,16 @@ module Foobara
         },
         {
           role: :user,
-          content: inputs.except(:llm_model, :association_depth)
+          content: inputs.except(*LLM_INTEGRATION_KEYS)
         }
       ]
     end
 
-    def llm_instructions
-      self.class.llm_instructions
-    end
-
     def parse_answer
       stripped_answer = answer.gsub(/<THINK>.*?<\/THINK>/mi, "")
       # For some reason sometimes deepseek-r1:32b starts the answer with "\n\n</think>\n\n"
       # so removing it as a special case
-      stripped_answer = stripped_answer.gsub(/\A\s*<\/think>\s*/mi, "")
+      stripped_answer = stripped_answer.gsub(/\A\s*<\/?think>\s*/mi, "")
       fencepostless_answer = stripped_answer.gsub(/^\s*```\w*\n(.*)```\s*\z/m, "\\1")
 
       # TODO: should we verify against json-schema or no?
@@ -142,71 +182,81 @@ module Foobara
     end
 
     module ClassMethods
-      def inputs_json_schema
-        @inputs_json_schema ||= JsonSchemaGenerator.to_json_schema(inputs_type_without_llm_integration_inputs)
+      def inputs_json_schema(association_depth)
+        JsonSchemaGenerator.to_json_schema(
+          inputs_type_without_llm_integration_inputs,
+          association_depth:
+        )
       end
 
       def inputs_type_without_llm_integration_inputs
-        return @inputs_type_without_llm_integration_inputs if @inputs_type_without_llm_integration_inputs
-
         type_declaration = Util.deep_dup(inputs_type.declaration_data)
 
         element_type_declarations = type_declaration[:element_type_declarations]
 
         changed = false
 
-        if element_type_declarations.key?(:llm_model)
-          changed = true
-          element_type_declarations.delete(:llm_model)
-        end
-
-        if element_type_declarations.key?(:association_depth)
-          changed = true
-          element_type_declarations.delete(:association_depth)
+        LLM_INTEGRATION_KEYS.each do |key|
+          if element_type_declarations.key?(key)
+            changed = true
+            element_type_declarations.delete(key)
+          end
         end
 
         if type_declaration.key?(:defaults)
-          if type_declaration[:defaults].key?(:llm_model)
-            changed = true
-            type_declaration[:defaults].delete(:llm_model)
+          LLM_INTEGRATION_KEYS.each do |key|
+            if type_declaration[:defaults].key?(key)
+              changed = true
+              type_declaration[:defaults].delete(key)
+            end
           end
 
-          if type_declaration[:defaults].key?(:association_depth)
-            changed = true
-            type_declaration[:defaults].delete(:association_depth)
-          end
           if type_declaration[:defaults].empty?
             type_declaration.delete(:defaults)
           end
         end
 
-        @inputs_type_without_llm_integration_inputs = if changed
-                                                        domain.foobara_type_from_declaration(type_declaration)
-                                                      else
-                                                        inputs_type
-                                                      end
+        if changed
+          domain.foobara_type_from_declaration(type_declaration)
+        else
+          inputs_type
+        end
       end
 
-      def result_json_schema
-        @result_json_schema ||= JsonSchemaGenerator.to_json_schema(
+      def result_json_schema(association_depth)
+        JsonSchemaGenerator.to_json_schema(
           result_type,
-          association_depth: JsonSchemaGenerator::AssociationDepth::PRIMARY_KEY_ONLY
+          association_depth:
         )
       end
 
-      def llm_instructions
-        @llm_instructions ||= <<~INSTRUCTIONS
+      def llm_instructions(user_association_depth, assistant_association_depth)
+        key = [user_association_depth, assistant_association_depth]
+
+        @llm_instructions_cache ||= {}
+
+        if @llm_instructions_cache.key?(key)
+          # :nocov:
+          @llm_instructions_cache[key]
+          # :nocov:
+        else
+          @llm_instructions_cache[key] = build_llm_instructions(user_association_depth, assistant_association_depth)
+        end
+      end
+
+      def build_llm_instructions(user_association_depth, assistant_association_depth)
+        <<~INSTRUCTIONS
           You are implementing an API for a command named #{scoped_full_name} which has the following description:
 
-          #{description}#{"  "}
+          #{description}
 
           Here is the inputs JSON schema for the data you will receive:
 
-          #{inputs_json_schema}
+          #{inputs_json_schema(user_association_depth)}
 
           Here is the result JSON schema:
 
-          #{result_json_schema}
+          #{result_json_schema(assistant_association_depth)}
 
           You will receive 1 message containing only JSON data according to the inputs JSON schema above
           and you will generate a JSON response that is a valid response according to the result JSON schema above.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-llm-backed-command
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 1.0.0
 platform: ruby
 authors:
 - Miles Georgi
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: 1.0.0
 email:
 - azimux@gmail.com
 executables: []