ruby_llm 1.16.0 → 2.0.0.rc1

data/lib/ruby_llm/protocols/invoke_model/embedding_batches.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class InvokeModel
+      # Titan embedding requests over Bedrock's S3 batch job API.
+      module EmbeddingBatches
+        include Protocols::Bedrock::Batches
+
+        private
+
+        def bedrock_invocation_type
+          'InvokeModel'
+        end
+
+        def validate_bedrock_batch_requests!(requests)
+          requests.each do |request|
+            values = request.fetch(:text)
+            values = [values] unless values.is_a?(Array)
+            unless values.any? && values.all? { |value| value.is_a?(String) && !value.empty? }
+              raise ArgumentError, 'Bedrock embedding batches require nonempty text strings'
+            end
+            unless request.fetch(:payload).key?(:inputText)
+              raise ArgumentError, 'Bedrock embedding batches require Titan embedding requests'
+            end
+          end
+        end
+
+        def bedrock_batch_jsonl(requests)
+          requests.flat_map do |request|
+            array = request.fetch(:text).is_a?(Array)
+            texts = array ? request.fetch(:text) : [request.fetch(:text)]
+            texts.each_with_index.map do |text, index|
+              id = "rllm-#{request.fetch(:custom_id)}-#{index}-#{texts.size}-#{array ? 'a' : 's'}"
+              JSON.generate(recordId: id, modelInput: batch_payload(request).merge(inputText: text))
+            end
+          end.join("\n")
+        end
+
+        def bedrock_job_name(input_uri, requests:)
+          "ruby-llm-embed-#{requests.size}-#{Digest::SHA256.hexdigest(input_uri)[0, 16]}"
+        end
+
+        def parse_batch_response(data)
+          super.merge(request_count: data['jobName'].to_s[/\Aruby-llm-embed-(\d+)-[0-9a-f]+\z/, 1]&.to_i)
+        end
+
+        def parse_bedrock_outputs(outputs, model:)
+          records = outputs.flat_map { |body| body.to_s.each_line.map { |line| JSON.parse(line) } }
+          groups = records.group_by { |record| embedding_record_id(record).first }
+          groups.filter_map { |index, group| parse_embedding_batch_group(index, group, model:) }
+        end
+
+        def embedding_record_id(record)
+          id = record['recordId'] || record['record_id']
+          match = /\Arllm-(\d+)-(\d+)-(\d+)-([as])\z/.match(id.to_s)
+          raise Error, "Unknown Bedrock embedding record ID: #{id.inspect}" unless match
+
+          [Integer(match[1]), Integer(match[2]), Integer(match[3]), match[4] == 'a']
+        end
+
+        def parse_embedding_batch_group(index, records, model:)
+          metadata = records.map { |record| embedding_record_id(record) }
+          count = metadata.first[2]
+          array = metadata.first[3]
+          error = embedding_group_error(records, metadata)
+          return [index, nil, batch_failure(index, error)] if error
+          return if records.size < count
+
+          ordered = records.sort_by { |record| embedding_record_id(record)[1] }
+          unless ordered.map { |record| embedding_record_id(record)[1] } == (0...count).to_a
+            return [index, nil, batch_failure(index, 'Invalid embedding record positions')]
+          end
+
+          parse_embedding_batch_result(index, ordered, model:, array:)
+        end
+
+        def embedding_group_error(records, metadata)
+          return 'Invalid or duplicate embedding record positions' unless consistent_embedding_metadata?(metadata)
+
+          error = records.find { |record| !record['modelOutput'] }
+          return unless error
+
+          batch_error_value(error['error']) || error['errorMessage'] || 'Bedrock returned no model output'
+        end
+
+        def consistent_embedding_metadata?(metadata)
+          metadata.map { |item| item[2..] }.uniq.one? &&
+            metadata.map { |item| item[1] }.uniq.size == metadata.size &&
+            (metadata.first[3] || metadata.first[2] == 1)
+        end
+
+        def parse_embedding_batch_result(index, records, model:, array:)
+          bodies = records.map { |record| record.fetch('modelOutput') }
+          vectors = embedding_batch_vectors(bodies)
+          return [index, nil, batch_failure(index, 'Bedrock returned no embedding')] unless vectors
+
+          counts = bodies.map { |body| body['inputTextTokenCount'] }
+          tokens = counts.sum if counts.all?
+          result = Embedding.new(vectors: array ? vectors : vectors.first, model:, input_tokens: tokens)
+          [index, result]
+        end
+
+        def embedding_batch_vectors(bodies)
+          vectors = bodies.map { |body| extract_embedding(body) }
+          vectors if vectors.all? { |vector| vector.is_a?(Array) && !vector.empty? && vector.all?(Numeric) }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/invoke_model/nova_embeddings.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class InvokeModel
+      # Amazon Nova multimodal embedding models over Bedrock InvokeModel.
+      class NovaEmbeddings < InvokeModel
+        DEFAULT_EMBEDDING_PURPOSE = 'GENERIC_INDEX'
+
+        # rubocop:disable-next Lint/UnusedMethodArgument
+        def embed(text, model:, dimensions:, task_type: nil, title: nil, with: nil, provider_options: {})
+          ensure_no_embedding_media!(with)
+          track_usage(:embedding) do
+            responses = [text].flatten.map do |value|
+              payload = render_embedding_payload(value, dimensions:, task_type:, provider_options:)
+              signed_post(embedding_url(model:), payload).tap { |response| record_embedding_attempt(response) }
+            end
+
+            parse_single_embedding_responses(responses, model:, text:)
+          end
+        end
+
+        private
+
+        def render_embedding_payload(text, dimensions:, task_type:, provider_options:)
+          params = {
+            embeddingPurpose: task_type || DEFAULT_EMBEDDING_PURPOSE,
+            text: {
+              truncationMode: 'END',
+              value: text.to_s
+            }
+          }
+          params[:embeddingDimension] = dimensions if dimensions
+
+          deep_merge_provider_options(
+            {
+              taskType: 'SINGLE_EMBEDDING',
+              singleEmbeddingParams: params
+            },
+            provider_options
+          )
+        end
+
+        def extract_embedding(body)
+          body.dig('embeddings', 0, 'embedding')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/invoke_model/stability_images.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class InvokeModel
+      # Stability image generation and inpainting over Bedrock InvokeModel.
+      class StabilityImages < InvokeModel
+        GENERATION_MODELS = %w[
+          stability.sd3-5-large-v1:0 stability.stable-image-core-v1:1 stability.stable-image-ultra-v1:1
+        ].freeze
+        INPAINT_MODEL = 'stability.stable-image-inpaint-v1:0'
+        MODELS = (GENERATION_MODELS + [INPAINT_MODEL]).freeze
+        ASPECT_RATIOS = %w[16:9 1:1 21:9 2:3 3:2 4:5 5:4 9:16 9:21].freeze
+        IMAGE_TYPES = %w[image/jpeg image/png image/webp].freeze
+
+        def paint(prompt, model:, size:, count: nil, with: nil, mask: nil, provider_options: {})
+          track_usage(:image) do
+            payload = render_image_payload(prompt, model:, size:, count:, with:, mask:, provider_options:)
+            response = signed_post("/model/#{model}/invoke", payload)
+            images = parse_image_responses(response, model:)
+            images.each { |image| image.config = @config }
+            images.one? ? images.first : images
+          end
+        end
+
+        def render_image_payload(prompt, model:, size:, count: nil, with: nil, mask: nil, provider_options: {})
+          RubyLLM.logger.debug { 'Stability image models return one image per request' } if count && count > 1
+          attachments = Attachment.wrap(with, config: @config)
+          payload = { prompt: }.merge(render_image_inputs(attachments, model:, mask:, size:))
+          payload.merge(provider_options.transform_keys(&:to_sym))
+        end
+
+        def parse_image_responses(response, model:)
+          images = Array(response.body['images']).compact.reject(&:empty?)
+          if images.empty?
+            reasons = Array(response.body['finish_reasons']).compact.join(', ')
+            message = reasons.empty? ? 'Bedrock returned no images' : "Bedrock image generation failed: #{reasons}"
+            raise Error.new(message, response:)
+          end
+
+          images.map do |data|
+            mime_type = RubyLLM::Files::MimeType.for(StringIO.new(Base64.decode64(data)))
+            raise Error.new('Bedrock returned invalid image data', response:) unless IMAGE_TYPES.include?(mime_type)
+
+            Image.new(data:, model:, mime_type:)
+          end
+        end
+
+        private
+
+        def render_image_inputs(attachments, model:, mask:, size:)
+          return render_inpaint_inputs(attachments, mask:, size:) if model.end_with?(INPAINT_MODEL)
+          raise UnsupportedAttachmentError, 'image mask' if mask
+          return { aspect_ratio: image_aspect_ratio(size) }.compact if attachments.empty?
+          raise UnsupportedAttachmentError, 'image reference' unless model.end_with?('stability.sd3-5-large-v1:0')
+
+          { image: single_image(attachments, size:), mode: 'image-to-image', strength: 0.5 }
+        end
+
+        def render_inpaint_inputs(attachments, mask:, size:)
+          payload = { image: single_image(attachments, size:) }
+          payload[:mask] = single_image(Attachment.wrap(mask, config: @config), size: nil) if mask
+          payload
+        end
+
+        def single_image(attachments, size:)
+          raise ArgumentError, 'with: must contain exactly one image' unless attachments.one?
+          raise ArgumentError, 'size: cannot change dimensions when editing a Stability image' if size
+
+          encoded_image(attachments.first)
+        end
+
+        def encoded_image(attachment)
+          raise UnsupportedAttachmentError, attachment.mime_type unless IMAGE_TYPES.include?(attachment.mime_type)
+
+          attachment.encoded
+        end
+
+        def image_aspect_ratio(size)
+          return unless size
+
+          match = size.to_s.match(/\A(\d+)\s*[x×:]\s*(\d+)\z/i)
+          raise ArgumentError, "Invalid image size: #{size.inspect}" unless match
+
+          width, height = match.captures.map(&:to_i)
+          raise ArgumentError, "Invalid image size: #{size.inspect}" unless width.positive? && height.positive?
+
+          ratio = matching_aspect_ratio(width, height)
+          raise ArgumentError, "Unsupported Stability image aspect ratio: #{size}" unless ratio
+
+          ratio
+        end
+
+        def matching_aspect_ratio(width, height)
+          ASPECT_RATIOS.find do |candidate|
+            ratio_width, ratio_height = candidate.split(':').map(&:to_i)
+            width * ratio_height == height * ratio_width
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/invoke_model/titan_multimodal_embeddings.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class InvokeModel
+      # Amazon Titan multimodal embedding models over Bedrock InvokeModel.
+      class TitanMultimodalEmbeddings < InvokeModel
+        # rubocop:disable-next Lint/UnusedMethodArgument
+        def embed(text, model:, dimensions:, task_type: nil, title: nil, with: nil, provider_options: {})
+          ensure_no_embedding_media!(with)
+          track_usage(:embedding) do
+            responses = [text].flatten.map do |value|
+              payload = render_embedding_payload(value, dimensions:, provider_options:)
+              signed_post(embedding_url(model:), payload).tap { |response| record_embedding_attempt(response) }
+            end
+
+            parse_single_embedding_responses(responses, model:, text:)
+          end
+        end
+
+        private
+
+        def render_embedding_payload(text, dimensions:, provider_options:, **)
+          payload = {}
+          payload[:inputText] = text.to_s unless text.nil? || text.to_s.empty?
+          payload[:embeddingConfig] = { outputEmbeddingLength: dimensions } if dimensions
+
+          deep_merge_provider_options(payload, provider_options)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/invoke_model/titan_text_embeddings.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class InvokeModel
+      # Amazon Titan text embedding models over Bedrock InvokeModel.
+      class TitanTextEmbeddings < InvokeModel
+        # rubocop:disable-next Lint/UnusedMethodArgument
+        def embed(text, model:, dimensions:, task_type: nil, title: nil, with: nil, provider_options: {})
+          ensure_no_embedding_media!(with)
+          track_usage(:embedding) do
+            responses = [text].flatten.map do |value|
+              payload = render_embedding_payload(value, model:, dimensions:, provider_options:)
+              signed_post(embedding_url(model:), payload).tap { |response| record_embedding_attempt(response) }
+            end
+
+            parse_single_embedding_responses(responses, model:, text:)
+          end
+        end
+
+        private
+
+        # The G1 and V1 models take inputText alone; Bedrock rejects the V2
+        # tuning keys as extraneous.
+        def render_embedding_payload(text, model:, dimensions:, provider_options:, **)
+          payload = { inputText: text.to_s }
+
+          if titan_v2?(model)
+            payload[:dimensions] = dimensions if dimensions
+            payload[:normalize] = true
+          elsif dimensions
+            raise Error, "#{model} does not support custom dimensions"
+          end
+
+          deep_merge_provider_options(payload, provider_options)
+        end
+
+        def titan_v2?(model)
+          model.to_s.include?('titan-embed-text-v2')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/invoke_model.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    # The AWS InvokeModel API, where the envelope is shared but each model
+    # family owns its request and response body. Subclasses under
+    # Protocols::InvokeModel implement one family each. Requests are signed
+    # by the provider, which knows the credentials and the signing service.
+    class InvokeModel < Protocol
+      private
+
+      def signed_post(url, payload, additional_headers = {})
+        body = JSON.generate(payload)
+
+        @connection.post(url, payload, usage: @usage_tracker) do |req|
+          req.headers.merge!(@provider.sign_headers('POST', url, body))
+          req.headers.merge!(additional_headers) unless additional_headers.empty?
+        end
+      end
+
+      def embedding_url(model:)
+        "/model/#{model}/invoke"
+      end
+
+      def ensure_no_embedding_media!(with)
+        attachments = Attachment.wrap(with)
+        raise UnsupportedAttachmentError, attachments.first.mime_type if attachments.any?
+      end
+
+      def parse_single_embedding_responses(responses, model:, text:)
+        vectors = responses.map { |response| extract_embedding(response.body) }
+        input_tokens = Tokens.aggregate(embedding_attempt_tokens(responses)).input
+        vectors = vectors.first unless text.is_a?(Array)
+
+        Embedding.new(vectors:, model:, input_tokens:)
+      end
+
+      def record_embedding_attempt(response)
+        @usage_tracker&.succeed_attempts(tokens: embedding_attempt_tokens([response]))
+      end
+
+      def embedding_attempt_tokens(responses)
+        responses.map { |response| Tokens.new(input: response.body['inputTextTokenCount']) }
+      end
+
+      def deep_merge_provider_options(payload, provider_options)
+        return payload if provider_options.empty?
+
+        Support::Utils.deep_merge(payload, provider_options)
+      end
+
+      def extract_embedding(body)
+        body['embedding'] || body.dig('embeddingsByType', 'float') || body['embeddingsByType']&.values&.first
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/mistral/content.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    module Mistral
+      module Content # :nodoc:
+        module_function
+
+        def parse_conversation_content(output)
+          result = { text: +'', thinking: +'', attachments: [], citations: [] }
+          output.select { |entry| entry['type'] == 'message.output' }.each do |entry|
+            parse_conversation_parts(entry['content'], result)
+          end
+          result[:thinking] = nil if result[:thinking].empty?
+          result
+        end
+
+        def parse_conversation_parts(content, result)
+          return result[:text] << content if content.is_a?(String)
+
+          Array(content).compact.each do |part|
+            case part['type']
+            when 'text' then result[:text] << part['text'].to_s
+            when 'thinking' then result[:thinking] << Array(part['thinking']).filter_map { |item| item['text'] }.join
+            when 'tool_reference' then result[:citations] << parse_conversation_citation(part, result[:text].length)
+            when 'tool_file' then result[:attachments] << parse_conversation_file(part)
+            when 'image_url'
+              url = part['image_url'].is_a?(Hash) ? part['image_url']['url'] : part['image_url']
+              result[:attachments] << Attachment.new(url, config: @config)
+            end
+          end
+        end
+
+        def parse_conversation_citation(part, offset)
+          Citation.new(url: part['url'], title: part['title'], cited_text: part['description'],
+                       start_index: offset, end_index: offset)
+        end
+
+        def parse_conversation_file(part)
+          format = part['file_type'].to_s
+          mime_type = format.include?('/') ? format : RubyLLM::Files::MimeType.for(name: "file.#{format}")
+          file = UploadedFile.new(id: part.fetch('file_id'), provider: @provider.slug,
+                                  filename: part['file_name'], mime_type: mime_type, downloadable: true, metadata: part)
+          Attachment.new(file, config: @config)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/mistral/conversations/chat.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    module Mistral
+      class Conversations
+        module Chat # :nodoc:
+          module_function
+
+          def completion_url
+            'conversations'
+          end
+
+          def render(...)
+            payload = super
+            payload[:tools] = Support::Utils.deep_stringify_keys(payload[:tools]).uniq
+            if payload[:tools].any? { |tool| Array(tool.dig('tool_configuration', 'requires_confirmation')).any? }
+              raise ArgumentError, 'Mistral hosted tool confirmations require provider conversation storage'
+            end
+
+            payload
+          end
+
+          def render_payload(messages, tools:, temperature:, model:, stream: false, max_output_tokens: nil,
+                             schema: nil, thinking: nil, tool_prefs: nil, **)
+            options = super(messages, tools:, temperature:, model:, stream:, max_output_tokens:,
+                                      schema:, thinking:, citations: false, caching: nil, tool_prefs:)
+            normalize_conversation_choice(options)
+            {
+              model: model.id,
+              inputs: format_entries(messages),
+              instructions: messages.select { |message| message.role == :system }.map(&:content).join("\n\n"),
+              completion_args: options.slice(:temperature, :max_tokens, :response_format, :reasoning_effort,
+                                             :tool_choice),
+              tools: options.fetch(:tools, []),
+              store: false,
+              stream: stream
+            }
+          end
+
+          def normalize_conversation_choice(options)
+            choice = options[:tool_choice]
+            if choice.is_a?(Hash)
+              raise ArgumentError, 'Mistral Conversations supports :auto, :none, or :required for tool choice'
+            end
+
+            options[:tool_choice] = 'any' if choice == 'required'
+          end
+
+          def format_entries(messages)
+            entries = messages.reject { |message| message.role == :system }.flat_map do |message|
+              if message.raw_content
+                Array(message.raw_content)
+              elsif message.tool_result?
+                [{ type: 'function.result', tool_call_id: message.tool_call_id, result: message.content.to_s }]
+              else
+                format_conversation_message(message)
+              end
+            end
+            entries.each_with_index.flat_map { |entry, index| replay_conversation_entry(entry, index) }
+          end
+
+          def replay_conversation_entry(entry, index)
+            return replay_conversation_execution(entry, index) if entry['type'] == 'tool.execution'
+
+            result = entry.except('id', 'object', 'created_at', 'completed_at')
+            if entry['type'] == 'message.output' && entry['content'].is_a?(Array)
+              result['content'] = entry['content'].map do |part|
+                next part unless part['type'] == 'tool_reference'
+
+                { 'type' => 'text', 'text' => "[#{part['title']}](#{part['url']})" }
+              end
+            end
+            [result]
+          end
+
+          def replay_conversation_execution(entry, index)
+            identity = entry['id'] || "#{index}:#{JSON.generate(entry)}"
+            id = entry['tool_call_id'] || Digest::SHA256.hexdigest(identity)[0, 9]
+            info = entry['info']
+            result = info.is_a?(Hash) && info.key?('result') ? info['result'] : info
+            [
+              { 'type' => 'function.call', 'tool_call_id' => id,
+                'name' => entry['function'] || entry['name'], 'arguments' => entry['arguments'] },
+              { 'type' => 'function.result', 'tool_call_id' => id,
+                'result' => result.is_a?(String) ? result : JSON.generate(result) }
+            ]
+          end
+
+          def format_conversation_message(message)
+            entries = []
+            if message.content || message.attachments.any?
+              entries << {
+                type: 'message.input', role: message.role.to_s,
+                content: format_message_content(message)
+              }
+            end
+            message.tool_calls&.each_value do |call|
+              entries << { type: 'function.call', tool_call_id: call.id, name: call.name,
+                           arguments: JSON.generate(call.arguments) }
+            end
+            entries
+          end
+
+          def parse_completion_body(data, raw:)
+            output = data.fetch('outputs')
+            content = parse_conversation_content(output)
+            calls = parse_conversation_calls(output, raw:)
+            response_model = output.filter_map { |entry| entry['model'] }.last || @model&.id
+            Message.new(
+              role: :assistant, content: content[:text], attachments: content[:attachments],
+              citations: content[:citations], thinking: Thinking.build(text: content[:thinking]),
+              tool_calls: calls, server_tool_calls: parse_conversation_steps(output),
+              raw_content: output, model: response_model,
+              finish_reason: calls.empty? ? :stop : :tool_calls, raw: raw,
+              **parse_conversation_usage(data['usage'] || {})
+            )
+          end
+
+          def parse_conversation_calls(output, raw:)
+            if output.any? { |entry| entry['type'] == 'function.call' && entry['confirmation_status'] == 'pending' }
+              raise Error.new('Mistral returned a hosted tool confirmation that requires provider conversation storage',
+                              response: raw)
+            end
+
+            output.select { |entry| pending_conversation_call?(entry) }.to_h do |entry|
+              call = parse_tool_calls([
+                                        { 'id' => entry['tool_call_id'], 'type' => 'function',
+                                          'function' => entry.slice('name', 'arguments') }
+                                      ], response: raw, finish_reason: :tool_calls).values.first
+              [call.id, call]
+            end
+          end
+
+          def pending_conversation_call?(entry)
+            entry['type'] == 'function.call' && entry['confirmation_status'].nil?
+          end
+
+          def parse_conversation_steps(output)
+            output.filter_map do |entry|
+              next unless entry['type'] == 'tool.execution' ||
+                          (entry['type'] == 'function.call' && !pending_conversation_call?(entry))
+
+              ServerToolCall.new(type: entry['type'], name: entry['name'], id: entry['id'],
+                                 input: entry['arguments'], result: entry['info'], raw: entry)
+            end
+          end
+
+          def parse_conversation_usage(usage)
+            input = usage['prompt_tokens'] && (usage['prompt_tokens'] + usage.fetch('connector_tokens', 0).to_i)
+            {
+              input_tokens: input,
+              output_tokens: usage['completion_tokens'], server_tool_use: usage['connectors']
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/mistral/conversations/images.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    module Mistral
+      class Conversations
+        module Images # :nodoc:
+          def images_url(**)
+            'conversations'
+          end
+
+          def render_image_payload(prompt, model:, size:, count: nil, with: nil, mask: nil, provider_options: {})
+            if size || (count && count != 1)
+              raise ArgumentError,
+                    'Mistral image generation does not accept size or count options'
+            end
+            raise UnsupportedAttachmentError, 'image editing' if with || mask
+
+            payload = { model: model, store: false, inputs: prompt, tools: [{ type: 'image_generation' }] }
+            Support::Utils.deep_merge(payload, provider_options)
+          end
+
+          def parse_image_response(response, model:)
+            parse_image_responses(response, model:).first
+          end
+
+          def parse_image_responses(response, model:)
+            data = response.body
+            attachments = parse_conversation_content(data.fetch('outputs'))[:attachments]
+            raise Error.new('Mistral returned no generated image', response:) if attachments.empty?
+
+            usage = parse_conversation_usage(data['usage'] || {}).transform_keys(&:to_s)
+            attachments.each_with_index.map do |attachment, index|
+              bytes = @provider.download_file(attachment.provider_file_id)
+              Image.new(data: Base64.strict_encode64(bytes), mime_type: RubyLLM::Files::MimeType.for(StringIO.new(bytes)),
+                        model: model, usage: index.zero? ? usage : {})
+            end
+          end
+        end
+      end
+    end
+  end
+end