foobara-llm-backed-command 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9cb07021ef2c77ed1e05d97c0d4b5cfaddca33c909c704fe3af57beddc5b2c4
-  data.tar.gz: c8da8cc8464a78c6ed709bd466de6bd55dab9ce371cdd7744aa8a875281726eb
+  metadata.gz: 53a125a1cf6ed542e1f7a45b271caa6e6651458afc54c817a21be114f9a29003
+  data.tar.gz: 45bce6b28ca7a1a68629056e62be036cbe11890a851e5da8e193747d4382b212
 SHA512:
-  metadata.gz: 5ee46b5b1f6d5a45d2b1bff8781256a1e63f0df734c5a1473ab0eb348d89c6ef3b9352892bc88f1bc5e0a637e68ce9321ac49fecd2b4448d32d2495d407f2a8b
-  data.tar.gz: 598341d453c7b9e6b17d0d7c5d09a34212f4ff697e7d91780eb0cc3ac3428134be890722c85189bc8f0d35ecb6feaf3bc5cf770405aaf88dd33795406f9d49da
+  metadata.gz: 8b2c99f1f022275d2ee480d0492b81f6e18d346d7d809143fb548915dd719e0f7080b8d79714f89c61b0f5f6a928dd482e92f58df3d6e262e368d216db9741bd
+  data.tar.gz: 716b310f5628dd2c3c7fe97463d98248107c3c597572a62b0cbd4c32abf0a99f523d3ce52285388f43c966d0958c1e4c957204f8a57cbe631cb2e22baed85d36

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.0.5] - 2025-03-06
+
+- Defer to downstream default model if none specified
+- Split LlmBackedCommand into a Command and a LlmBackedExecuteMethod mixin
+
 ## [0.0.3] - 2025-03-05
 
 - Support answers with an explanation followed by the proper answer in fence posts

data/src/llm_backed_command.rb

@@ -1,172 +1,5 @@
-# NOTE: You can add the following inputs if you'd like, or, create methods with these names
-# on the class.
-#
-# inputs do
-#   association_depth :symbol, one_of: JsonSchemaGenerator::AssociationDepth, default: AssociationDepth::ATOM
-#   llm_model :symbol, one_of: Foobara::Ai::AnswerBot::Types::ModelEnum
-# end
 module Foobara
-  module LlmBackedCommand
-    include Concern
-
-    on_include do
-      depends_on Ai::AnswerBot::Ask
-    end
-
-    def execute
-      determine_serializer
-      construct_input_json
-      generate_answer
-      parse_answer
-
-      parsed_answer
-    end
-
-    attr_accessor :serializer, :input_json, :answer, :parsed_answer
-
-    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
-    end
-
-    def construct_input_json
-      inputs_without_llm_integration_inputs = inputs.except(:llm_model, :association_depth)
-      input_json = serializer.serialize(inputs_without_llm_integration_inputs)
-
-      self.input_json = JSON.fast_generate(input_json)
-    end
-
-    def generate_answer
-      self.answer = run_subcommand!(
-        Ai::AnswerBot::Ask,
-        model: llm_model,
-        instructions: llm_instructions,
-        question: input_json
-      )
-    end
-
-    def llm_instructions
-      self.class.llm_instructions
-    end
-
-    def parse_answer
-      stripped_answer = answer.gsub(/<THINK>.*?<\/THINK>/mi, "")
-      fencepostless_answer = stripped_answer.gsub(/^\s*```\w*\n(.*)```\s*\z/m, "\\1")
-      # TODO: should we verify against json-schema or no?
-      self.parsed_answer = begin
-        JSON.parse(fencepostless_answer)
-      rescue => e
-        # see if we can extract the last fence-posts content just in case
-        last_fence_post_regex = /```\w*\s*\n((?:(?!```).)+)\n```(?:(?!```).)*\z/m
-        begin
-          match = last_fence_post_regex.match(stripped_answer)
-          if match
-            JSON.parse(match[1])
-          else
-            # :nocov:
-            raise e
-            # :nocov:
-          end
-        rescue
-          # :nocov:
-          raise e
-          # :nocov:
-        end
-      end
-    end
-
-    module ClassMethods
-      def inputs_json_schema
-        @inputs_json_schema ||= JsonSchemaGenerator.to_json_schema(inputs_type_without_llm_integration_inputs)
-      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)
-        end
-
-        if type_declaration.key?(:defaults)
-          if type_declaration[:defaults].key?(:llm_model)
-            changed = true
-            type_declaration[:defaults].delete(:llm_model)
-          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
-      end
-
-      def result_json_schema
-        @result_json_schema ||= JsonSchemaGenerator.to_json_schema(result_type)
-      end
-
-      def llm_instructions
-        @llm_instructions ||= <<~INSTRUCTIONS
-          You are implementing an API for a command named #{scoped_full_name} which has the following description:
-
-          #{description}#{"  "}
-
-          Here is the inputs JSON schema for the data you will receive:
-
-          #{inputs_json_schema}
-
-          Here is the result JSON schema:
-
-          #{result_json_schema}
-
-          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.
-
-          You will reply with nothing more than the JSON you've generated so that the calling code
-          can successfully parse your answer.
-        INSTRUCTIONS
-      end
-    end
+  class LlmBackedCommand < Foobara::Command
+    include LlmBackedExecuteMethod
   end
 end

data/src/llm_backed_execute_method.rb

@@ -0,0 +1,176 @@
+# NOTE: You can add the following inputs if you'd like, or, create methods with these names
+# on the class.
+#
+# inputs do
+#   association_depth :symbol, one_of: JsonSchemaGenerator::AssociationDepth, default: AssociationDepth::ATOM
+#   llm_model :symbol, one_of: Foobara::Ai::AnswerBot::Types::ModelEnum
+# end
+module Foobara
+  module LlmBackedExecuteMethod
+    include Concern
+
+    on_include do
+      depends_on Ai::AnswerBot::Ask
+    end
+
+    def execute
+      determine_serializer
+      construct_input_json
+      generate_answer
+      parse_answer
+
+      parsed_answer
+    end
+
+    attr_accessor :serializer, :input_json, :answer, :parsed_answer
+
+    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
+    end
+
+    def construct_input_json
+      inputs_without_llm_integration_inputs = inputs.except(:llm_model, :association_depth)
+      input_json = serializer.serialize(inputs_without_llm_integration_inputs)
+
+      self.input_json = JSON.fast_generate(input_json)
+    end
+
+    def generate_answer
+      ask_inputs = {
+        instructions: llm_instructions,
+        question: input_json
+      }
+
+      if respond_to?(:llm_model)
+        ask_inputs[:model] = llm_model
+      end
+
+      self.answer = run_subcommand!(Ai::AnswerBot::Ask, ask_inputs)
+    end
+
+    def llm_instructions
+      self.class.llm_instructions
+    end
+
+    def parse_answer
+      stripped_answer = answer.gsub(/<THINK>.*?<\/THINK>/mi, "")
+      fencepostless_answer = stripped_answer.gsub(/^\s*```\w*\n(.*)```\s*\z/m, "\\1")
+      # TODO: should we verify against json-schema or no?
+      self.parsed_answer = begin
+        JSON.parse(fencepostless_answer)
+      rescue => e
+        # see if we can extract the last fence-posts content just in case
+        last_fence_post_regex = /```\w*\s*\n((?:(?!```).)+)\n```(?:(?!```).)*\z/m
+        begin
+          match = last_fence_post_regex.match(stripped_answer)
+          if match
+            JSON.parse(match[1])
+          else
+            # :nocov:
+            raise e
+            # :nocov:
+          end
+        rescue
+          # :nocov:
+          raise e
+          # :nocov:
+        end
+      end
+    end
+
+    module ClassMethods
+      def inputs_json_schema
+        @inputs_json_schema ||= JsonSchemaGenerator.to_json_schema(inputs_type_without_llm_integration_inputs)
+      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)
+        end
+
+        if type_declaration.key?(:defaults)
+          if type_declaration[:defaults].key?(:llm_model)
+            changed = true
+            type_declaration[:defaults].delete(:llm_model)
+          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
+      end
+
+      def result_json_schema
+        @result_json_schema ||= JsonSchemaGenerator.to_json_schema(result_type)
+      end
+
+      def llm_instructions
+        @llm_instructions ||= <<~INSTRUCTIONS
+          You are implementing an API for a command named #{scoped_full_name} which has the following description:
+
+          #{description}#{"  "}
+
+          Here is the inputs JSON schema for the data you will receive:
+
+          #{inputs_json_schema}
+
+          Here is the result JSON schema:
+
+          #{result_json_schema}
+
+          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.
+
+          You will reply with nothing more than the JSON you've generated so that the calling code
+          can successfully parse your answer.
+        INSTRUCTIONS
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-llm-backed-command
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Miles Georgi
@@ -49,6 +49,7 @@ files:
 - README.md
 - lib/foobara/llm_backed_command.rb
 - src/llm_backed_command.rb
+- src/llm_backed_execute_method.rb
 homepage: https://github.com/foobara/llm-backed-command
 licenses:
 - MPL-2.0