Add support for getting base64 encoded uploads

Author: SamSaffron

lib/personas/tool_runner.rb

@@ -79,6 +79,9 @@ def framework_script
         const upload = {
           create: _upload_create,
           getUrl: _upload_get_url,
+          getBase64: function(id, maxPixels) {
+            return _upload_get_base64(id, maxPixels);
+          }
         }
 
         const chain = {
@@ -604,6 +607,42 @@ def attach_discourse(mini_racer_context)
       end
 
       def attach_upload(mini_racer_context)
+        mini_racer_context.attach(
+          "_upload_get_base64",
+          ->(upload_id_or_url, max_pixels) do
+            in_attached_function do
+              return nil if upload_id_or_url.blank?
+
+              upload = nil
+
+              # Handle both upload ID and short URL
+              if upload_id_or_url.to_s.start_with?("upload://")
+                # Handle short URL format
+                sha1 = Upload.sha1_from_short_url(upload_id_or_url)
+                return nil if sha1.blank?
+                upload = Upload.find_by(sha1: sha1)
+              else
+                # Handle numeric ID
+                upload_id = upload_id_or_url.to_i
+                return nil if upload_id <= 0
+                upload = Upload.find_by(id: upload_id)
+              end
+
+              return nil if upload.nil?
+
+              max_pixels = max_pixels&.to_i
+              max_pixels = nil if max_pixels && max_pixels <= 0
+
+              encoded_uploads =
+                DiscourseAi::Completions::UploadEncoder.encode(
+                  upload_ids: [upload.id],
+                  max_pixels: max_pixels || 10_000_000, # Default to 10M pixels if not specified
+                )
+
+              encoded_uploads.first&.dig(:base64)
+            end
+          end,
+        )
         mini_racer_context.attach(
           "_upload_get_url",
           ->(short_url) do

spec/models/ai_tool_spec.rb

@@ -696,6 +696,67 @@ def stub_embeddings
     expect(result).to eq([{ "slept" => 1 }, { "slept" => 1 }, { "slept" => 1 }])
   end
 
+  let(:jpg) { plugin_file_from_fixtures("1x1.jpg") }
+
+  describe "upload base64 encoding" do
+    it "can get base64 data from upload ID and short URL" do
+      upload = UploadCreator.new(jpg, "1x1.jpg").create_for(Discourse.system_user.id)
+
+      # Test with upload ID
+      script_id = <<~JS
+        function invoke(params) {
+          return upload.getBase64(params.upload_id, params.max_pixels);
+        }
+      JS
+
+      tool = create_tool(script: script_id)
+      runner =
+        tool.runner(
+          { "upload_id" => upload.id, "max_pixels" => 1_000_000 },
+          llm: nil,
+          bot_user: nil,
+        )
+      result_id = runner.invoke
+
+      expect(result_id).to be_present
+      expect(result_id).to be_a(String)
+      expect(result_id.length).to be > 0
+
+      # Test with short URL
+      script_url = <<~JS
+        function invoke(params) {
+          return upload.getBase64(params.short_url, params.max_pixels);
+        }
+      JS
+
+      tool = create_tool(script: script_url)
+      runner =
+        tool.runner(
+          { "short_url" => upload.short_url, "max_pixels" => 1_000_000 },
+          llm: nil,
+          bot_user: nil,
+        )
+      result_url = runner.invoke
+
+      expect(result_url).to be_present
+      expect(result_url).to be_a(String)
+      expect(result_url).to eq(result_id) # Should return same base64 data
+
+      # Test with invalid upload ID
+      script_invalid = <<~JS
+        function invoke(params) {
+          return upload.getBase64(99999);
+        }
+      JS
+
+      tool = create_tool(script: script_invalid)
+      runner = tool.runner({}, llm: nil, bot_user: nil)
+      result_invalid = runner.invoke
+
+      expect(result_invalid).to be_nil
+    end
+  end
+
   describe "upload URL resolution" do
     it "can resolve upload short URLs to public URLs" do
       upload =