ruby-gemini-api 0.1.7 → 1.1.0

data/lib/gemini/live/session.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+
+module Gemini
+  class Live
+    # Live API session manager
+    class Session
+      attr_reader :configuration, :last_resumption_token, :usage_metadata
+
+      def initialize(api_key:, configuration:)
+        @api_key = api_key
+        @configuration = configuration
+        @event_handlers = Hash.new { |h, k| h[k] = [] }
+        @connected = false
+        @setup_complete = false
+        @last_resumption_token = nil
+        @usage_metadata = nil
+        @connection = nil
+
+        setup_connection
+      end
+
+      # Register event handler
+      # Supported events:
+      #   :setup_complete - Session setup completed
+      #   :text           - Text response received (text)
+      #   :audio          - Audio data received (base64_data, mime_type)
+      #   :data           - Other inline data received (base64_data, mime_type)
+      #   :tool_call      - Tool call requested (function_calls)
+      #   :interrupted    - User interrupted the model
+      #   :turn_complete  - Model turn completed
+      #   :generation_complete - Generation completed
+      #   :usage_metadata - Token usage info received (metadata)
+      #   :session_resumption - Session resumption token updated (update)
+      #   :go_away        - Connection will close soon (info)
+      #   :error          - Error occurred (error)
+      #   :close          - Connection closed (code, reason)
+      def on(event, &block)
+        @event_handlers[event.to_sym] << block
+        self
+      end
+
+      # Send text message via clientContent.turns. This is the legacy form
+      # used by native-audio Live models. Newer models such as
+      # gemini-3.1-flash-live-preview reject this payload — use
+      # #send_realtime_text instead, which works on every Live model.
+      def send_text(text, turn_complete: true)
+        ensure_setup_complete!
+        message = MessageBuilder.client_content(
+          text: text,
+          turn_complete: turn_complete
+        )
+        @connection.send(message)
+      end
+
+      # Send text input via realtimeInput.text (universal form).
+      # Works with every currently-deployed Live model, including
+      # gemini-3.1-flash-live-preview and native-audio variants.
+      def send_realtime_text(text)
+        ensure_setup_complete!
+        @connection.send(MessageBuilder.realtime_text(text))
+      end
+
+      # Send audio data (Base64 encoded PCM)
+      def send_audio(audio_data, mime_type: "audio/pcm;rate=16000")
+        ensure_setup_complete!
+        encoded_data = audio_data.is_a?(String) && audio_data.encoding == Encoding::BINARY ?
+          Base64.strict_encode64(audio_data) : audio_data
+        message = MessageBuilder.realtime_input(
+          audio_data: encoded_data,
+          mime_type: mime_type
+        )
+        @connection.send(message)
+      end
+
+      # Send video/image data (Base64 encoded)
+      def send_video(image_data, mime_type: "image/jpeg")
+        ensure_setup_complete!
+        encoded_data = image_data.is_a?(String) && image_data.encoding == Encoding::BINARY ?
+          Base64.strict_encode64(image_data) : image_data
+        message = MessageBuilder.realtime_input(
+          video_data: encoded_data,
+          mime_type: mime_type
+        )
+        @connection.send(message)
+      end
+
+      # Send tool response
+      def send_tool_response(function_responses)
+        ensure_setup_complete!
+        message = MessageBuilder.tool_response(function_responses)
+        @connection.send(message)
+      end
+
+      # Manual VAD control - signal activity start
+      def activity_start
+        ensure_setup_complete!
+        @connection.send(MessageBuilder.activity_start)
+      end
+
+      # Manual VAD control - signal activity end
+      def activity_end
+        ensure_setup_complete!
+        @connection.send(MessageBuilder.activity_end)
+      end
+
+      # Close the session
+      def close
+        @connection&.close
+        @connected = false
+        @setup_complete = false
+      end
+
+      def connected?
+        @connected && @connection&.connected?
+      end
+
+      def setup_complete?
+        @setup_complete
+      end
+
+      private
+
+      def setup_connection
+        @connection = Connection.new(
+          api_key: @api_key,
+          on_message: method(:handle_message),
+          on_open: method(:handle_open),
+          on_error: method(:handle_error),
+          on_close: method(:handle_close)
+        )
+        @connection.connect
+        @connected = true
+      end
+
+      def handle_open
+        # Send setup message immediately after connection opens
+        setup_message = MessageBuilder.setup(@configuration)
+        @connection.send(setup_message)
+      end
+
+      def handle_message(data)
+        parsed = JSON.parse(data, symbolize_names: true)
+
+        if parsed[:setupComplete]
+          @setup_complete = true
+          emit(:setup_complete)
+        elsif parsed[:serverContent]
+          handle_server_content(parsed[:serverContent])
+        elsif parsed[:toolCall]
+          emit(:tool_call, parsed[:toolCall][:functionCalls])
+        elsif parsed[:usageMetadata]
+          @usage_metadata = parsed[:usageMetadata]
+          emit(:usage_metadata, parsed[:usageMetadata])
+        elsif parsed[:sessionResumptionUpdate]
+          handle_session_resumption(parsed[:sessionResumptionUpdate])
+        elsif parsed[:goAway]
+          emit(:go_away, parsed[:goAway])
+        end
+      rescue JSON::ParserError => e
+        emit(:error, e)
+      end
+
+      def handle_server_content(content)
+        # Check for interruption
+        if content[:interrupted]
+          emit(:interrupted)
+          return
+        end
+
+        # Check for generation complete
+        if content[:generationComplete]
+          emit(:generation_complete)
+        end
+
+        # Process model turn
+        model_turn = content[:modelTurn]
+        if model_turn
+          model_turn[:parts]&.each do |part|
+            if part[:text]
+              emit(:text, part[:text])
+            elsif part[:inlineData]
+              inline = part[:inlineData]
+              if inline[:mimeType]&.start_with?("audio/")
+                emit(:audio, inline[:data], inline[:mimeType])
+              else
+                emit(:data, inline[:data], inline[:mimeType])
+              end
+            end
+          end
+        end
+
+        # Check for turn complete
+        emit(:turn_complete) if content[:turnComplete]
+      end
+
+      def handle_session_resumption(update)
+        @last_resumption_token = update[:newHandle]
+        emit(:session_resumption, update)
+      end
+
+      def handle_error(error)
+        emit(:error, error)
+      end
+
+      def handle_close(code, reason)
+        @connected = false
+        @setup_complete = false
+        emit(:close, code, reason)
+      end
+
+      def emit(event, *args)
+        @event_handlers[event].each { |handler| handler.call(*args) }
+      end
+
+      def ensure_setup_complete!
+        raise Gemini::Error, "Session setup not complete. Wait for :setup_complete event." unless @setup_complete
+      end
+    end
+  end
+end

data/lib/gemini/live.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "live/configuration"
+require_relative "live/message_builder"
+require_relative "live/connection"
+require_relative "live/session"
+
+module Gemini
+  # Live API client for real-time audio/video/text interactions
+  #
+  # @example Basic text conversation
+  #   client = Gemini::Client.new(api_key)
+  #   session = client.live.connect(model: "gemini-2.5-flash-live-preview")
+  #
+  #   session.on(:setup_complete) { puts "Connected!" }
+  #   session.on(:text) { |text| puts "AI: #{text}" }
+  #   session.on(:error) { |e| puts "Error: #{e}" }
+  #
+  #   session.send_text("Hello!")
+  #   sleep 5
+  #   session.close
+  #
+  # @example Audio conversation
+  #   session = client.live.connect(
+  #     model: "gemini-2.5-flash-live-preview",
+  #     response_modality: "AUDIO",
+  #     voice_name: "Puck"
+  #   )
+  #
+  #   session.on(:audio) { |data, mime| play_audio(data) }
+  #   session.send_audio(pcm_data)  # 16-bit PCM, 16kHz, mono
+  #
+  # @example With block (auto-close)
+  #   client.live.connect(model: "gemini-2.5-flash-live-preview") do |session|
+  #     session.on(:text) { |text| puts text }
+  #     session.send_text("Hello!")
+  #     sleep 5
+  #   end  # session.close called automatically
+  #
+  class Live
+    def initialize(client:)
+      @client = client
+    end
+
+    # Establish a WebSocket connection and return a session
+    #
+    # @param model [String] Model to use (default: "gemini-2.5-flash-live-preview")
+    # @param response_modality [String] "TEXT" or "AUDIO" (default: "TEXT")
+    # @param voice_name [String] Voice for audio responses (Puck, Charon, Kore, etc.)
+    # @param system_instruction [String] System prompt
+    # @param tools [Array] Tool definitions for function calling
+    # @param context_window_compression [Hash] Compression settings for long sessions
+    # @param session_resumption [Hash] Session resumption settings
+    # @param automatic_activity_detection [Boolean] Enable/disable automatic VAD (default: true)
+    # @param media_resolution [String] Media resolution setting
+    # @param output_audio_transcription [Boolean] Enable audio transcription (default: false)
+    # @yield [session] If block given, yields the session and closes it when block returns
+    # @return [Gemini::Live::Session] The live session
+    #
+    def connect(
+      model: Configuration::DEFAULT_MODEL,
+      response_modality: "TEXT",
+      voice_name: nil,
+      system_instruction: nil,
+      tools: nil,
+      context_window_compression: nil,
+      session_resumption: nil,
+      automatic_activity_detection: true,
+      media_resolution: nil,
+      output_audio_transcription: false,
+      &block
+    )
+      config = Configuration.new(
+        model: model,
+        response_modality: response_modality,
+        voice_name: voice_name,
+        system_instruction: system_instruction,
+        tools: tools,
+        context_window_compression: context_window_compression,
+        session_resumption: session_resumption,
+        automatic_activity_detection: automatic_activity_detection,
+        media_resolution: media_resolution,
+        output_audio_transcription: output_audio_transcription
+      )
+
+      session = Session.new(
+        api_key: @client.api_key,
+        configuration: config
+      )
+
+      if block_given?
+        begin
+          yield session
+        ensure
+          session.close
+        end
+      else
+        session
+      end
+    end
+  end
+end

data/lib/gemini/response.rb

@@ -70,9 +70,49 @@ module Gemini
     
     # Check if response is valid
     def valid?
-      !@raw_data.nil? && 
-      ((@raw_data.key?("candidates") && !@raw_data["candidates"].empty?) || 
-       (@raw_data.key?("predictions") && !@raw_data["predictions"].empty?))
+      !@raw_data.nil? &&
+      ((@raw_data.key?("candidates") && !@raw_data["candidates"].empty?) ||
+       (@raw_data.key?("predictions") && !@raw_data["predictions"].empty?) ||
+       embedding_response?)
+    end
+
+    # Check if the raw response contains embedding data
+    def embedding_response?
+      return false if @raw_data.nil?
+      (@raw_data.key?("embedding") && !@raw_data["embedding"].nil?) ||
+        (@raw_data.key?("embeddings") && @raw_data["embeddings"].is_a?(Array) && !@raw_data["embeddings"].empty?)
+    end
+
+    # Get the embedding values as an Array of Floats.
+    # For single embedContent responses returns the values array.
+    # For batchEmbedContents responses returns the first embedding's values.
+    def embedding
+      return nil unless @raw_data
+      if @raw_data["embedding"].is_a?(Hash)
+        @raw_data["embedding"]["values"]
+      elsif @raw_data["embeddings"].is_a?(Array) && @raw_data["embeddings"].first.is_a?(Hash)
+        @raw_data["embeddings"].first["values"]
+      end
+    end
+
+    # Get all embedding value arrays for batch responses.
+    # Returns an Array of Arrays of Floats.
+    # For single embedContent responses, returns a single-element array.
+    def embeddings
+      return [] unless @raw_data
+      if @raw_data["embeddings"].is_a?(Array)
+        @raw_data["embeddings"].map { |e| e["values"] }.compact
+      elsif @raw_data["embedding"].is_a?(Hash) && @raw_data["embedding"]["values"]
+        [@raw_data["embedding"]["values"]]
+      else
+        []
+      end
+    end
+
+    # Get the dimensionality (length) of the first embedding vector
+    def embedding_dimension
+      values = embedding
+      values.is_a?(Array) ? values.length : 0
     end
     
     # Get error message if any
@@ -223,7 +263,52 @@ module Gemini
     def safety_ratings
       first_candidate&.dig("safetyRatings") || []
     end
-    
+
+    # Thinking関連メソッド
+
+    # 思考トークン数を取得
+    def thoughts_token_count
+      @raw_data.dig('usageMetadata', 'thoughtsTokenCount')
+    end
+
+    # Thought Signatureを取得（配列）
+    def thought_signatures
+      parts.filter_map { |p| p['thoughtSignature'] }
+    end
+
+    # 最初のThought Signatureを取得
+    def first_thought_signature
+      thought_signatures.first
+    end
+
+    # Signatureが存在するか
+    def has_thought_signature?
+      !thought_signatures.empty?
+    end
+
+    # モデルバージョンを取得
+    def model_version
+      @raw_data['modelVersion']
+    end
+
+    # Gemini 3系かどうか
+    def gemini_3?
+      model_version&.start_with?('gemini-3') || false
+    end
+
+    # 関数呼び出しにSignatureを付与してパーツを構築
+    def build_function_call_parts_with_signature
+      function_call_parts = parts.select { |p| p['functionCall'] }
+      signature = first_thought_signature
+
+      function_call_parts.map.with_index do |part, index|
+        fc_part = { functionCall: part['functionCall'] }
+        # 最初のパートにのみSignatureを付与
+        fc_part[:thoughtSignature] = signature if index == 0 && signature
+        fc_part
+      end
+    end
+
     # 画像生成結果から最初の画像を取得（Base64エンコード形式）
     def image
       images.first

data/lib/gemini/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gemini
-  VERSION = "0.1.7"
+  VERSION = "1.1.0"
 end

data/lib/gemini.rb

@@ -16,9 +16,11 @@ require_relative "gemini/audio"
 require_relative "gemini/files"
 require_relative "gemini/images"
 require_relative "gemini/response"
+require_relative "gemini/function_calling_helper"
 require_relative "gemini/documents"
 require_relative "gemini/cached_content"
 require_relative "gemini/video"
+require_relative "gemini/live"
 
 module Gemini
   class Error < StandardError; end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gemini-api
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 1.1.0
 platform: ruby
 authors:
 - rira100000000
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -52,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -153,9 +166,15 @@ files:
 - lib/gemini/documents.rb
 - lib/gemini/embeddings.rb
 - lib/gemini/files.rb
+- lib/gemini/function_calling_helper.rb
 - lib/gemini/http.rb
 - lib/gemini/http_headers.rb
 - lib/gemini/images.rb
+- lib/gemini/live.rb
+- lib/gemini/live/configuration.rb
+- lib/gemini/live/connection.rb
+- lib/gemini/live/message_builder.rb
+- lib/gemini/live/session.rb
 - lib/gemini/messages.rb
 - lib/gemini/models.rb
 - lib/gemini/response.rb
@@ -173,7 +192,6 @@ metadata:
   source_code_uri: https://github.com/rira100000000/ruby-gemini-api
   changelog_uri: https://github.com/rira100000000/ruby-gemini-api/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -188,8 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby client for Google's Gemini API
 test_files: []