omniai-google 3.19.0 → 3.22.0

data/lib/omniai/google/live.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Google
+    # A Gemini Live API session on Vertex (BidiGenerateContent over a WebSocket): stream microphone audio in, receive
+    # speech, transcripts and tool calls back.
+    #
+    # Usage:
+    #
+    #   session = client.live(model: "gemini-3.8-live", system: "...", tools: [RecordAnswer.new]) do |event|
+    #     case event
+    #     when OmniAI::Google::Live::Event::Audio then play(event.data)
+    #     when OmniAI::Google::Live::Event::Closed then reconnect
+    #     end
+    #   end
+    #   session.send_audio(pcm16_16khz)
+    #   session.close
+    #
+    # Each session holds one socket and one reader thread. Events are yielded, and tools run, on that thread; the
+    # `send_*` methods may be called from any thread. The gem never logs or raises audio, transcripts or tool arguments.
+    class Live
+      # @!attribute code [Integer, nil] the WebSocket close code
+      # @!attribute reason [String, nil] Google's close reason; kept out of the message because it can echo content
+      class Error < OmniAI::Error
+        attr_reader :code, :reason
+
+        def initialize(message, code: nil, reason: nil)
+          super(message)
+          @code = code
+          @reason = reason
+        end
+      end
+
+      class ClosedError < Error; end
+      class TimeoutError < Error; end
+
+      module Model
+        GEMINI_3_8_LIVE = "gemini-3.8-live"
+      end
+
+      DEFAULT_MODEL = Model::GEMINI_3_8_LIVE
+      INPUT_MIME_TYPE = "audio/pcm;rate=16000"
+      PATH = "/ws/google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent"
+      SETUP_TIMEOUT = 15 # seconds
+      WRITE_TIMEOUT = 5 # seconds
+      BEHAVIORS = { blocking: "BLOCKING", non_blocking: "NON_BLOCKING" }.freeze
+      ACTIVITY = { "ACTIVITY_START" => :start, "ACTIVITY_END" => :end }.freeze
+
+      # Opens a session and waits for the server's setupComplete.
+      #
+      # @raise [Error] if the server rejects the setup or it times out
+      #
+      # @return [Live]
+      def self.open(...)
+        new(...).tap(&:open)
+      end
+
+      # @return [String, nil] the server's session id, once open
+      attr_reader :session_id
+
+      # @param client [OmniAI::Google::Client] must use Vertex credentials, a project and a location (e.g. "us")
+      # @param model [String]
+      # @param system [String, nil] the system instruction
+      # @param tools [Array<OmniAI::Tool>, nil] run automatically; each result is sent back as a tool response
+      # @param tool_behavior [Symbol, Hash] `:blocking` (default) or `:non_blocking`, or a Hash of tool name to either
+      # @param voice [String, nil] a prebuilt voice name, e.g. "Kore"
+      # @param transcription [Boolean] transcribe both the user's and the model's speech (default true)
+      # @param vad [Hash, nil] automatic activity detection: `disabled:`, `start_sensitivity:` / `end_sensitivity:`
+      #   (`:high` or `:low`), `prefix_padding_ms:`, `silence_ms:`
+      # @param compression [Boolean, Hash] sliding-window context compression, which lifts the 15-minute session cap and
+      #   bounds the context re-billed every turn. true uses Google's defaults (trigger at 80% of the context window);
+      #   or pass `trigger_tokens:` / `target_tokens:`
+      # @param resumption [Boolean, String, nil] true to receive resumption handles, or a handle to resume
+      # @param write_timeout [Numeric] seconds a send may block before the session is closed
+      #
+      # @yieldparam event [Live::Event::*]
+      def initialize(client:, model: DEFAULT_MODEL, system: nil, tools: nil, tool_behavior: :blocking, voice: nil,
+        transcription: true, vad: nil, compression: false, resumption: nil, write_timeout: WRITE_TIMEOUT, &handler)
+        @client = client.for_model(model)
+        @model = model
+        @system = system
+        @tools = tools || []
+        @tool_behavior = tool_behavior
+        @voice = voice
+        @transcription = transcription
+        @vad = vad
+        @compression = compression
+        @resumption = resumption
+        @write_timeout = write_timeout
+        @handler = handler
+        @state = :new
+      end
+
+      # @raise [Error]
+      #
+      # @return [Live]
+      def open
+        raise ArgumentError, "#{self.class.name} requires Vertex credentials" unless @client.credentials?
+
+        @ready = Queue.new
+        @connection = Connection.new(
+          url:,
+          headers: { "Authorization" => @client.send(:auth) }, # a fresh token per connection
+          write_timeout: @write_timeout,
+          on_open: method(:on_open),
+          on_message: method(:on_message),
+          on_close: method(:on_close)
+        )
+        log("LIVE connect #{host} #{@model}")
+        begin
+          @connection.connect
+        rescue Connection::ConnectTimeout => e
+          raise TimeoutError, "#{self.class.name} #{e.message} (model=#{@model})"
+        end
+        await_setup!
+        self
+      end
+
+      # @return [Boolean]
+      def open?
+        @state == :open && @connection.open?
+      end
+
+      # @param audio [String] raw PCM16 audio, 16 kHz, mono, little-endian
+      def send_audio(audio)
+        deliver(realtimeInput: { audio: { mimeType: INPUT_MIME_TYPE, data: Base64.strict_encode64(audio) } })
+      end
+
+      # Tells the server the microphone paused, so it flushes any buffered audio.
+      def end_audio
+        deliver(realtimeInput: { audioStreamEnd: true })
+      end
+
+      # Sends a complete user turn of text, e.g. to re-seed context after reconnecting.
+      #
+      # @param text [String]
+      def send_text(text)
+        deliver(clientContent: { turns: [{ role: "user", parts: [{ text: }] }], turnComplete: true })
+      end
+
+      def close
+        @connection&.close
+      end
+
+    private
+
+      # @param message [Hash]
+      #
+      # @raise [ClosedError, TimeoutError]
+      def deliver(message)
+        raise ClosedError, "#{self.class.name} session is closed (session=#{@session_id})" unless open?
+
+        @connection.send_text(JSON.generate(message))
+      rescue Connection::WriteTimeout
+        raise TimeoutError, "#{self.class.name} write timed out after #{@write_timeout}s (session=#{@session_id})"
+      end
+
+      def await_setup!
+        result = @ready.pop(timeout: SETUP_TIMEOUT)
+        return if result == :ready
+
+        @connection.close
+        raise Error, "#{self.class.name} setup timed out (model=#{@model})" if result.nil?
+
+        code, reason, error = result
+        raise Error.new("#{self.class.name} setup failed (model=#{@model} code=#{code.inspect} " \
+          "error=#{error&.class.inspect})", code:, reason:)
+      end
+
+      def on_open
+        @connection.send_text(JSON.generate(setup))
+      end
+
+      # @param data [String]
+      def on_message(data)
+        message, events = decode(data)
+        if (complete = message["setupComplete"])
+          @session_id = complete["sessionId"]
+          @state = :open
+          @ready << :ready
+          return
+        end
+
+        events.each do |event|
+          @handler&.call(event)
+          respond(event) if event.is_a?(Event::ToolCall)
+        end
+      end
+
+      def on_close(code, reason, error)
+        state = @state
+        @state = :closed
+        log("LIVE close #{code || '-'} #{@session_id || '-'}")
+        if state == :open
+          @handler&.call(Event::Closed.new(code:, reason:, error:))
+        else
+          @ready << [code, reason, error]
+        end
+      end
+
+      # Runs each called tool and sends the results. A raising tool answers with its error class only (never its
+      # message, which may carry arguments), and the session carries on.
+      #
+      # @param event [Event::ToolCall]
+      def respond(event)
+        responses = event.calls.map do |call|
+          tool = @tools.find { |candidate| candidate.name == call.name }
+          response =
+            if tool.nil?
+              { error: "unknown tool: #{call.name}" }
+            else
+              begin
+                { output: tool.call(call.arguments) }
+              rescue StandardError => e
+                { error: e.class.name }
+              end
+            end
+          { id: call.id, name: call.name, response: }
+        end
+        deliver(toolResponse: { functionResponses: responses })
+      end
+
+      # A frame that fails to parse or build closes the session with an error naming only the exception class: the
+      # original's message (and so its cause) can quote the frame, which may hold transcripts.
+      #
+      # @param data [String]
+      #
+      # @raise [Error]
+      #
+      # @return [Array(Hash, Array)] the message and its events
+      def decode(data)
+        message = JSON.parse(data)
+        [message, message["setupComplete"] ? [] : events(message)]
+      rescue StandardError => e
+        raise Error.new("#{self.class.name} could not decode a server message: #{e.class.name} " \
+          "(session=#{@session_id || '-'})"), cause: nil
+      end
+
+      # Server message keys and their event builders, in the order events are yielded (usage after content).
+      MESSAGE_EVENTS = {
+        "serverContent" => :server_content_events,
+        "toolCall" => :tool_call_events,
+        "toolCallCancellation" => :cancellation_events,
+        "voiceActivity" => :voice_activity_events,
+        "sessionResumptionUpdate" => :resumption_events,
+        "goAway" => :go_away_events,
+        "usageMetadata" => :usage_events,
+      }.freeze
+      private_constant :MESSAGE_EVENTS
+
+      # @param message [Hash]
+      # @return [Array]
+      def events(message)
+        MESSAGE_EVENTS.flat_map { |key, builder| message[key] ? send(builder, message[key]) : [] }
+      end
+
+      def server_content_events(content)
+        [
+          *transcript_events(:user, content["inputTranscription"]),
+          *model_turn_events(content["modelTurn"]),
+          *transcript_events(:model, content["outputTranscription"]),
+          (Event::Interrupted.new if content["interrupted"]),
+          (Event::GenerationComplete.new if content["generationComplete"]),
+          (Event::TurnComplete.new if content["turnComplete"]),
+        ].compact
+      end
+
+      def transcript_events(role, transcription)
+        return [] unless transcription
+
+        [Event::Transcript.new(role:, text: transcription["text"], finished: transcription["finished"] == true)]
+      end
+
+      def model_turn_events(turn)
+        (turn&.dig("parts") || []).filter_map do |part|
+          if (inline = part["inlineData"])
+            Event::Audio.new(data: Base64.decode64(inline["data"]), mime_type: inline["mimeType"])
+          elsif part["text"] && !part["thought"]
+            Event::Text.new(text: part["text"])
+          end
+        end
+      end
+
+      def tool_call_events(tool_call)
+        calls = (tool_call["functionCalls"] || []).map do |call|
+          Event::FunctionCall.new(id: call["id"], name: call["name"], arguments: call["args"] || {})
+        end
+        [Event::ToolCall.new(calls:)]
+      end
+
+      def cancellation_events(cancellation)
+        [Event::ToolCallCancellation.new(ids: cancellation["ids"] || [])]
+      end
+
+      def voice_activity_events(activity)
+        type = ACTIVITY.fetch(activity["type"], activity["type"])
+        [Event::VoiceActivity.new(type:, offset: seconds(activity["audioOffset"]))]
+      end
+
+      def resumption_events(update)
+        [Event::ResumptionUpdate.new(handle: update["newHandle"], resumable: update["resumable"] == true)]
+      end
+
+      def go_away_events(go_away)
+        [Event::GoAway.new(time_left: seconds(go_away["timeLeft"]))]
+      end
+
+      def usage_events(usage)
+        [Event::Usage.new(usage: Chat::UsageSerializer.deserialize(usage), data: usage)]
+      end
+
+      # @return [Hash]
+      def setup
+        {
+          setup: {
+            model: "projects/#{project_id}/locations/#{location_id}/publishers/google/models/#{@model}",
+            generationConfig: { responseModalities: ["AUDIO"], speechConfig: speech_config }.compact,
+            systemInstruction: ({ parts: [{ text: @system }] } if @system),
+            tools: ([{ functionDeclarations: @tools.map { |tool| declaration(tool) } }] if @tools.any?),
+            inputAudioTranscription: ({} if @transcription),
+            outputAudioTranscription: ({} if @transcription),
+            realtimeInputConfig: realtime_input_config,
+            contextWindowCompression: context_window_compression,
+            sessionResumption: session_resumption,
+          }.compact,
+        }
+      end
+
+      # @param tool [OmniAI::Tool]
+      # @return [Hash]
+      def declaration(tool)
+        behavior = @tool_behavior.is_a?(Hash) ? @tool_behavior.fetch(tool.name, :blocking) : @tool_behavior
+        Chat::ToolSerializer.serialize(tool).merge(behavior: BEHAVIORS.fetch(behavior.to_sym))
+      end
+
+      # @return [Hash, nil]
+      def speech_config
+        { voiceConfig: { prebuiltVoiceConfig: { voiceName: @voice } } } if @voice
+      end
+
+      # @return [Hash, nil]
+      def realtime_input_config
+        return unless @vad
+
+        detection = {
+          disabled: @vad[:disabled],
+          startOfSpeechSensitivity: sensitivity("START", @vad[:start_sensitivity]),
+          endOfSpeechSensitivity: sensitivity("END", @vad[:end_sensitivity]),
+          prefixPaddingMs: @vad[:prefix_padding_ms],
+          silenceDurationMs: @vad[:silence_ms],
+        }.compact
+        { automaticActivityDetection: detection }
+      end
+
+      # @return [String, nil] e.g. "START_SENSITIVITY_HIGH"
+      def sensitivity(edge, level)
+        "#{edge}_SENSITIVITY_#{level.to_s.upcase}" if level
+      end
+
+      # @return [Hash, nil]
+      def context_window_compression
+        return unless @compression
+
+        options = @compression.is_a?(Hash) ? @compression : {}
+        {
+          triggerTokens: options[:trigger_tokens],
+          slidingWindow: { targetTokens: options[:target_tokens] }.compact,
+        }.compact
+      end
+
+      # @return [Hash, nil]
+      def session_resumption
+        case @resumption
+        when true then {}
+        when String then { handle: @resumption }
+        end
+      end
+
+      # @param value [String, nil] e.g. "0.200s"
+      # @return [Float, nil]
+      def seconds(value)
+        value&.delete_suffix("s")&.to_f
+      end
+
+      # @return [String] e.g. "wss://aiplatform.us.rep.googleapis.com/ws/..."
+      def url
+        "#{host.sub(/\Ahttp/, 'ws')}#{PATH}"
+      end
+
+      # @return [String]
+      def host
+        @client.instance_variable_get(:@host)
+      end
+
+      # @return [String]
+      def project_id
+        @client.instance_variable_get(:@project_id) || raise(ArgumentError, "project_id is required for Live")
+      end
+
+      # @return [String]
+      def location_id
+        @client.instance_variable_get(:@location_id) || raise(ArgumentError, "location_id is required for Live")
+      end
+
+      # @param message [String] ids, codes and classes only
+      def log(message)
+        @client.logger&.info(message)
+      end
+    end
+  end
+end

data/lib/omniai/google/transcribe/gemini.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Google
+    class Transcribe
+      # Transcribes with a Gemini transcribe model (e.g. `gemini-3.5-transcribe`). Unlike Chirp (Cloud Speech-to-Text),
+      # these are served by Vertex `generateContent` with the audio as the only part.
+      #
+      # Usage:
+      #
+      #   client.transcribe("interview.wav", model: "gemini-3.5-transcribe", diarization: true)
+      class Gemini
+        include TranscribeHelpers
+
+        INLINE_LIMIT = 10_000_000 # bytes; larger audio goes through GCS
+
+        # Leading bytes of the audio containers Gemini accepts. `generateContent` requires a mimeType.
+        SIGNATURES = {
+          "RIFF" => "audio/wav",
+          "ID3" => "audio/mpeg",
+          "\xFF\xFB".b => "audio/mpeg",
+          "\xFF\xF3".b => "audio/mpeg",
+          "\xFF\xF2".b => "audio/mpeg",
+          "fLaC" => "audio/flac",
+          "OggS" => "audio/ogg",
+          "\x1A\x45\xDF\xA3".b => "audio/webm",
+          "FORM" => "audio/aiff",
+        }.freeze
+
+        EXTENSIONS = {
+          ".wav" => "audio/wav", ".mp3" => "audio/mpeg", ".flac" => "audio/flac", ".ogg" => "audio/ogg",
+          ".opus" => "audio/ogg", ".webm" => "audio/webm", ".m4a" => "audio/mp4", ".mp4" => "audio/mp4",
+          ".aac" => "audio/aac", ".aif" => "audio/aiff", ".aiff" => "audio/aiff",
+        }.freeze
+
+        # @param model [String]
+        # @return [Boolean]
+        def self.model?(model)
+          String(model).start_with?("gemini-")
+        end
+
+        def self.process!(...)
+          new(...).process!
+        end
+
+        # @param io [String, Pathname, IO] a file path, IO or `gs://` URI
+        # @param client [OmniAI::Google::Client] must use Vertex credentials
+        # @param model [String]
+        # @param language [String, Array<String>, nil] optional - auto-detected when omitted
+        # @param format [String, nil] optional - `verbose_json` adds per-utterance segments
+        # @param diarization [Boolean] optional - speaker labels per segment (experimental)
+        # @param word_timestamps [Boolean] optional - word times (experimental; can drop speech, see README)
+        # @param vocabulary [Array<String>, nil] optional - custom vocabulary (up to 1,000 terms)
+        def initialize(io, client:, model:, language: nil, format: nil, diarization: false, word_timestamps: false,
+          vocabulary: nil)
+          @io = io
+          @client = client.for_model(model)
+          @model = model
+          @language = language
+          @format = format || OmniAI::Transcribe::Format::JSON
+          @diarization = diarization
+          @word_timestamps = word_timestamps
+          @vocabulary = vocabulary
+        end
+
+        # @raise [OmniAI::HTTPError, OmniAI::Error]
+        #
+        # @return [OmniAI::Transcribe::Transcription]
+        def process!
+          raise ArgumentError, "#{@model} requires Vertex credentials" unless @client.credentials?
+
+          response = request!
+          raise HTTPError, response unless response.status.ok?
+
+          OmniAI::Transcribe::Transcription.parse(model: @model, format: @format, data: parse(response.parse))
+        ensure
+          cleanup_gcs_file(@uploaded_gcs_uri) if @uploaded_gcs_uri
+          @uploaded_gcs_uri = nil
+        end
+
+      private
+
+        # @return [HTTP::Response]
+        def request!
+          HTTP.persistent(host)
+            .timeout(http_timeout_options)
+            .accept(:json)
+            .auth(@client.send(:auth))
+            .post(path, json: payload)
+        end
+
+        # Served from the global endpoint and the us/eu multi-regions, never a single region, so a zonal Vertex
+        # location_id maps to its multi-region (same rule as Chirp 3); `us` is the default.
+        #
+        # A location from `locations` is used as given.
+        #
+        # @return [String] "global", "us" or "eu", unless mapped
+        def gemini_location_id
+          return @client.instance_variable_get(:@location_id) if @client.located?
+
+          case @client.instance_variable_get(:@location_id)
+          when "global" then "global"
+          when /\A(eu|europe)/i then "eu"
+          else "us"
+          end
+        end
+
+        # @return [String]
+        def host
+          Vertex.host(gemini_location_id)
+        end
+
+        # @return [String]
+        def path
+          "/v1/projects/#{project_id}/locations/#{gemini_location_id}/publishers/google/models/" \
+            "#{@model}:generateContent"
+        end
+
+        # @return [Hash]
+        def payload
+          config = {
+            languageCodes: language_codes,
+            diarization: (true if @diarization),
+            wordTimestamp: (true if @word_timestamps),
+            customVocabulary: @vocabulary,
+          }.compact
+
+          payload = { contents: [{ role: "user", parts: [audio_part] }] }
+          payload[:generationConfig] = { audioTranscriptionConfig: config } if config.any?
+          payload
+        end
+
+        # @return [Hash]
+        def audio_part
+          return file_data(@io, EXTENSIONS.fetch(File.extname(@io).downcase, "audio/wav")) if gcs_uri?
+
+          bytes = audio_bytes
+          mime_type = sniff(bytes)
+          return { inlineData: { mimeType: mime_type, data: Base64.strict_encode64(bytes) } } if inline?(bytes)
+
+          @uploaded_gcs_uri = Bucket.process!(client: @client, io: StringIO.new(bytes))
+          file_data(@uploaded_gcs_uri, mime_type)
+        end
+
+        # @param bytes [String]
+        # @return [Boolean]
+        def inline?(bytes)
+          bytes.bytesize <= INLINE_LIMIT
+        end
+
+        # @return [Hash]
+        def file_data(uri, mime_type)
+          { fileData: { fileUri: uri, mimeType: mime_type } }
+        end
+
+        # @return [Boolean]
+        def gcs_uri?
+          @io.is_a?(String) && @io.start_with?("gs://")
+        end
+
+        # @return [String]
+        def audio_bytes
+          case @io
+          when String, Pathname then File.binread(@io)
+          when IO, StringIO
+            @io.rewind if @io.respond_to?(:rewind)
+            @io.read.b
+          else raise ArgumentError, "unsupported input type: #{@io.class}"
+          end
+        end
+
+        # @param bytes [String]
+        # @return [String]
+        def sniff(bytes)
+          return "audio/mp4" if bytes.byteslice(4, 4) == "ftyp"
+
+          SIGNATURES.each { |signature, mime_type| return mime_type if bytes.start_with?(signature.b) }
+          raise ArgumentError, "unrecognised audio format (expected wav, mp3, flac, ogg, webm, m4a or aiff)"
+        end
+
+        # @param data [Hash]
+        # @return [Hash]
+        def parse(data)
+          candidate = data.dig("candidates", 0) || {}
+          parts = candidate.dig("content", "parts")
+          if parts.nil? || parts.empty?
+            raise OmniAI::Error, "#{@model} returned no content (finish reason #{candidate['finishReason']})"
+          end
+
+          segments = parts.map.with_index { |part, index| segment(part, index) }
+          result = { "text" => segments.map { |segment| segment["text"] }.join(" ") }
+          result["segments"] = segments if @format == OmniAI::Transcribe::Format::VERBOSE_JSON
+          result
+        end
+
+        # @param part [Hash]
+        # @param index [Integer]
+        # @return [Hash]
+        def segment(part, index)
+          transcription = part["audioTranscription"] || {}
+          words = transcription["words"]&.map do |word|
+            { "word" => word["word"], "start" => parse_duration(word["startOffset"]),
+              "end" => parse_duration(word["endOffset"]), }
+          end
+
+          {
+            "id" => index,
+            "text" => transcription["text"] || part["text"],
+            "speaker" => transcription["speakerLabel"],
+            "start" => words&.first&.fetch("start"),
+            "end" => words&.last&.fetch("end"),
+            "words" => words,
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/omniai/google/transcribe.rb

@@ -12,6 +12,7 @@ module OmniAI
       include TranscribeHelpers
 
       module Model
+        GEMINI_3_5_TRANSCRIBE = "gemini-3.5-transcribe"
         CHIRP_3 = "chirp_3"
         CHIRP_2 = "chirp_2"
         CHIRP = "chirp"
@@ -32,6 +33,27 @@ module OmniAI
         # No custom deserializers needed - let base class handle parsing
       end
 
+      GEMINI_OPTIONS = %i[diarization word_timestamps vocabulary].freeze
+
+      # Gemini transcribe models (`gemini-*`) take a separate path; every Chirp / Speech-to-Text model is unchanged.
+      #
+      # @return [OmniAI::Transcribe::Transcription]
+      def self.process!(io, model:, **options)
+        return Gemini.process!(io, model:, **options) if Gemini.model?(model)
+
+        unsupported = options.keys & GEMINI_OPTIONS
+        if unsupported.any?
+          raise ArgumentError, "#{unsupported.join(', ')} only supported by Gemini transcribe models, not #{model}"
+        end
+
+        super
+      end
+
+      # `client` is swapped for `client.for_model(model)`, so `locations` routes the request.
+      def initialize(io, client:, model:, **)
+        super(io, client: client.for_model(model), model:, **)
+      end
+
       # @raise [HTTPError]
       #
       # @return [OmniAI::Transcribe::Transcription]

data/lib/omniai/google/transcribe_helpers.rb

@@ -12,8 +12,12 @@ module OmniAI
           raise(ArgumentError, "project_id is required for transcription")
       end
 
+      # A location from `locations` is used as given; otherwise it is derived per model.
+      #
       # @return [String]
       def location_id
+        return @client.instance_variable_get(:@location_id) if @client.located?
+
         case @model
         when "chirp_2"
           "us-central1"

data/lib/omniai/google/unknown_location_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Google
+    # Raised before any request when `locations` is configured but has no entry for the model.
+    class UnknownLocationError < OmniAI::Error
+      # @return [String]
+      attr_reader :model
+
+      # @param model [String]
+      def initialize(model)
+        @model = model
+        super("no location configured for model #{model.inspect}")
+      end
+    end
+  end
+end