google-adk 0.1.0

data/lib/google/adk/agents/workflow_agents/sequential_agent.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Google
+  module ADK
+    # Agent that executes sub-agents sequentially
+    class SequentialAgent < BaseAgent
+      attr_reader :agents
+
+      # Initialize a sequential agent
+      #
+      # @param name [String] Agent name
+      # @param description [String] Agent description (optional)
+      # @param agents [Array<BaseAgent>] Agents to execute in order
+      # @param before_agent_callback [Proc] Callback before agent execution
+      # @param after_agent_callback [Proc] Callback after agent execution
+      # @raise [ArgumentError] If no agents provided
+      def initialize(name:, agents:, description: nil,
+                     before_agent_callback: nil, after_agent_callback: nil)
+        raise ArgumentError, "Sequential agent requires at least one agent" if agents.empty?
+
+        super(
+          name: name,
+          description: description || "Executes #{agents.length} agents sequentially",
+          sub_agents: agents,
+          before_agent_callback: before_agent_callback,
+          after_agent_callback: after_agent_callback
+        )
+
+        @agents = agents
+      end
+
+      # Run agents sequentially
+      #
+      # @param message [String] Initial message
+      # @param context [InvocationContext] Invocation context
+      # @yield [Event] Events during execution
+      def run_async(message, context: nil)
+        Enumerator.new do |yielder|
+          invocation_id = context&.invocation_id || "seq-#{SecureRandom.uuid}"
+
+          # Yield start event
+          start_event = Event.new(
+            invocation_id: invocation_id,
+            author: @name,
+            content: "Starting sequential execution with #{@agents.length} agents"
+          )
+          yielder << start_event
+
+          # Execute each agent in sequence
+          current_input = message
+          @agents.each_with_index do |agent, index|
+            begin
+              # Yield progress event
+              progress_event = Event.new(
+                invocation_id: invocation_id,
+                author: @name,
+                content: "Executing agent #{index + 1}/#{@agents.length}: #{agent.name}"
+              )
+              yielder << progress_event
+
+              # Run the agent
+              agent_output = nil
+              if agent.respond_to?(:run_async)
+                agent.run_async(current_input, context: context).each do |event|
+                  yielder << event
+                  # Capture last content as output for next agent
+                  agent_output = event.content if event.content
+                end
+              else
+                # For agents that don't implement run_async
+                error_event = Event.new(
+                  invocation_id: invocation_id,
+                  author: @name,
+                  content: "Agent #{agent.name} does not implement run_async"
+                )
+                yielder << error_event
+                agent_output = current_input
+              end
+
+              # Use this agent's output as next agent's input
+              current_input = agent_output || current_input
+
+            rescue StandardError => e
+              # Handle errors gracefully
+              error_event = Event.new(
+                invocation_id: invocation_id,
+                author: @name,
+                content: "Error in agent #{agent.name}: #{e.message}"
+              )
+              yielder << error_event
+              
+              # Continue with original input if agent failed
+              current_input = message
+            end
+          end
+
+          # Yield completion event
+          end_event = Event.new(
+            invocation_id: invocation_id,
+            author: @name,
+            content: "Completed sequential execution. Final output: #{current_input}"
+          )
+          yielder << end_event
+        end
+      end
+    end
+  end
+end

data/lib/google/adk/clients/gemini_client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Google
+  module ADK
+    # Client for interacting with Google's Gemini API
+    class GeminiClient
+      API_BASE_URL = "https://generativelanguage.googleapis.com"
+      
+      attr_reader :api_key
+
+      def initialize(api_key: nil)
+        @api_key = api_key || ENV["GEMINI_API_KEY"]
+        raise ConfigurationError, "GEMINI_API_KEY not set" unless @api_key
+        
+        @client = Faraday.new(API_BASE_URL) do |conn|
+          conn.request :json
+          conn.response :json
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      # Generate content using Gemini API
+      #
+      # @param model [String] Model name (e.g., "gemini-2.0-flash")
+      # @param messages [Array<Hash>] Conversation messages
+      # @param tools [Array<Hash>] Available tools (optional)
+      # @param system_instruction [String] System instruction (optional)
+      # @return [Hash] API response
+      def generate_content(model:, messages:, tools: nil, system_instruction: nil)
+        url = "/v1beta/models/#{model}:generateContent"
+        
+        payload = {
+          contents: format_messages(messages),
+          generationConfig: {
+            temperature: 0.7,
+            topK: 40,
+            topP: 0.95,
+            maxOutputTokens: 8192
+          }
+        }
+        
+        payload[:systemInstruction] = { parts: [{ text: system_instruction }] } if system_instruction
+        payload[:tools] = [{ functionDeclarations: tools }] if tools && !tools.empty?
+        
+        response = @client.post("#{url}?key=#{@api_key}") do |req|
+          req.body = payload
+        end
+        
+        handle_response(response)
+      end
+
+      private
+
+      # Format messages for Gemini API
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg[:parts]
+            # Already formatted
+            msg
+          else
+            # Convert simple text messages
+            {
+              role: msg[:role] == "assistant" ? "model" : msg[:role],
+              parts: [{ text: msg[:content] }]
+            }
+          end
+        end
+      end
+
+      # Handle API response
+      def handle_response(response)
+        case response.status
+        when 200
+          response.body
+        when 400
+          raise Error, "Bad request: #{response.body.dig('error', 'message') || response.body}"
+        when 401
+          raise ConfigurationError, "Invalid API key"
+        when 429
+          raise Error, "Rate limit exceeded"
+        else
+          raise Error, "API error (#{response.status}): #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/google/adk/context.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Google
+  module ADK
+    # Configuration for context caching
+    class ContextCacheConfig
+      attr_accessor :min_tokens, :ttl_seconds, :cache_intervals
+
+      # Initialize cache configuration
+      #
+      # @param min_tokens [Integer] Minimum tokens to cache (default: 1024)
+      # @param ttl_seconds [Integer] Cache TTL in seconds (default: 300)
+      # @param cache_intervals [Array<Integer>] Cache intervals (default: [])
+      def initialize(min_tokens: 1024, ttl_seconds: 300, cache_intervals: [])
+        @min_tokens = min_tokens
+        @ttl_seconds = ttl_seconds
+        @cache_intervals = cache_intervals
+      end
+    end
+
+    # Configuration for agent run
+    class RunConfig
+      attr_accessor :max_tokens, :temperature, :context_window_compression,
+                    :max_steps, :timeout_seconds
+
+      # Initialize run configuration
+      #
+      # @param max_tokens [Integer] Maximum tokens for response (optional)
+      # @param temperature [Float] LLM temperature (default: 0.7)
+      # @param context_window_compression [Boolean] Enable compression (default: false)
+      # @param max_steps [Integer] Maximum execution steps (optional)
+      # @param timeout_seconds [Integer] Execution timeout (optional)
+      def initialize(max_tokens: nil, temperature: 0.7,
+                     context_window_compression: false,
+                     max_steps: nil, timeout_seconds: nil)
+        @max_tokens = max_tokens
+        @temperature = temperature
+        @context_window_compression = context_window_compression
+        @max_steps = max_steps
+        @timeout_seconds = timeout_seconds
+      end
+    end
+
+    # Read-only context for accessing state
+    class ReadonlyContext
+      attr_reader :invocation_id, :agent_name, :state
+
+      # Initialize readonly context
+      #
+      # @param invocation_id [String] Unique invocation ID
+      # @param agent_name [String] Current agent name
+      # @param state [Hash] Current state (will be frozen)
+      def initialize(invocation_id:, agent_name:, state:)
+        @invocation_id = invocation_id
+        @agent_name = agent_name
+        @state = state.freeze
+      end
+    end
+
+    # Context for callbacks with mutable state
+    class CallbackContext < ReadonlyContext
+      attr_reader :session
+
+      # Initialize callback context
+      #
+      # @param invocation_id [String] Unique invocation ID
+      # @param agent_name [String] Current agent name
+      # @param session [Object] Session object with state
+      def initialize(invocation_id:, agent_name:, session:)
+        @invocation_id = invocation_id
+        @agent_name = agent_name
+        @session = session
+      end
+
+      # Get mutable state from session
+      #
+      # @return [Hash] Mutable state hash
+      def state
+        @session.state
+      end
+
+      # Update multiple state values
+      #
+      # @param updates [Hash] Key-value pairs to update
+      def update_state(updates)
+        state.merge!(updates)
+      end
+    end
+
+    # Context for tool execution
+    class ToolContext < CallbackContext
+      attr_reader :auth_service, :artifact_service, :memory_service
+
+      # Initialize tool context
+      #
+      # @param invocation_id [String] Unique invocation ID
+      # @param agent_name [String] Current agent name
+      # @param session [Object] Session object
+      # @param auth_service [Object] Authentication service (optional)
+      # @param artifact_service [Object] Artifact service (optional)
+      # @param memory_service [Object] Memory service (optional)
+      def initialize(invocation_id:, agent_name:, session:,
+                     auth_service: nil, artifact_service: nil, memory_service: nil)
+        super(invocation_id: invocation_id, agent_name: agent_name, session: session)
+        @auth_service = auth_service
+        @artifact_service = artifact_service
+        @memory_service = memory_service
+      end
+
+      # Request authentication
+      #
+      # @param auth_type [String] Type of authentication
+      # @param options [Hash] Authentication options
+      def request_auth(auth_type, **options)
+        raise AgentError, "Auth service not available" unless @auth_service
+
+        @auth_service.request_auth(auth_type, options)
+      end
+
+      # List artifacts
+      #
+      # @return [Array] List of artifacts
+      def list_artifacts
+        return [] unless @artifact_service
+
+        @artifact_service.list_artifacts
+      end
+
+      # Search memory
+      #
+      # @param query [String] Search query
+      # @return [Array] Search results
+      def search_memory(query)
+        return [] unless @memory_service
+
+        @memory_service.search(query)
+      end
+    end
+
+    # Full invocation context for agent execution
+    class InvocationContext
+      attr_reader :session, :agent, :invocation_id, :session_service,
+                  :artifact_service, :memory_service, :agent_states,
+                  :context_cache_config, :run_config
+
+      # Initialize invocation context
+      #
+      # @param session [Object] Current session
+      # @param agent [BaseAgent] Current agent
+      # @param invocation_id [String] Unique invocation ID
+      # @param session_service [Object] Session service
+      # @param artifact_service [Object] Artifact service (optional)
+      # @param memory_service [Object] Memory service (optional)
+      # @param context_cache_config [ContextCacheConfig] Cache config (optional)
+      # @param run_config [RunConfig] Run configuration (optional)
+      def initialize(session:, agent:, invocation_id:, session_service:,
+                     artifact_service: nil, memory_service: nil,
+                     context_cache_config: nil, run_config: nil)
+        @session = session
+        @agent = agent
+        @invocation_id = invocation_id
+        @session_service = session_service
+        @artifact_service = artifact_service
+        @memory_service = memory_service
+        @agent_states = {}
+        @context_cache_config = context_cache_config || ContextCacheConfig.new
+        @run_config = run_config || RunConfig.new
+      end
+
+      # Get agent state
+      #
+      # @param agent_name [String] Agent name
+      # @return [Hash] Agent state or empty hash
+      def get_agent_state(agent_name)
+        @agent_states[agent_name] || {}
+      end
+
+      # Update agent state
+      #
+      # @param agent_name [String] Agent name
+      # @param state [Hash] New state
+      def update_agent_state(agent_name, state)
+        @agent_states[agent_name] = state
+      end
+
+      # Get current session state
+      #
+      # @return [Hash] Session state
+      def state
+        @session.state
+      end
+
+      # Update session state
+      #
+      # @param updates [Hash] State updates
+      def update_state(updates)
+        @session.state.merge!(updates)
+      end
+
+      # Add event to session
+      #
+      # @param event [Event] Event to add
+      def add_event(event)
+        @session.events << event
+      end
+
+      # Get conversation history
+      #
+      # @return [Array<Event>] Event history
+      def events
+        @session.events
+      end
+
+      # Create callback context
+      #
+      # @return [CallbackContext] Callback context
+      def to_callback_context
+        CallbackContext.new(
+          invocation_id: @invocation_id,
+          agent_name: @agent.name,
+          session: @session
+        )
+      end
+
+      # Create tool context
+      #
+      # @param auth_service [Object] Auth service (optional)
+      # @return [ToolContext] Tool context
+      def to_tool_context(auth_service: nil)
+        ToolContext.new(
+          invocation_id: @invocation_id,
+          agent_name: @agent.name,
+          session: @session,
+          auth_service: auth_service,
+          artifact_service: @artifact_service,
+          memory_service: @memory_service
+        )
+      end
+    end
+  end
+end

data/lib/google/adk/events.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "set"
+
+module Google
+  module ADK
+    # Represents a function call in an event
+    class FunctionCall
+      attr_reader :id, :name, :arguments
+
+      # Initialize a function call
+      #
+      # @param id [String] Unique identifier for the call (optional)
+      # @param name [String] Function name
+      # @param arguments [Hash] Function arguments
+      def initialize(id: nil, name:, arguments:)
+        @id = id || "call-#{SecureRandom.uuid}"
+        @name = name
+        @arguments = arguments
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          arguments: @arguments
+        }
+      end
+    end
+
+    # Represents a function response in an event
+    class FunctionResponse
+      attr_reader :id, :name, :response, :is_error
+
+      # Initialize a function response
+      #
+      # @param id [String] ID of the function call this responds to
+      # @param name [String] Function name
+      # @param response [Hash] Function response
+      # @param is_error [Boolean] Whether this is an error response
+      def initialize(id:, name:, response:, is_error: false)
+        @id = id
+        @name = name
+        @response = response
+        @is_error = is_error
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          response: @response,
+          is_error: @is_error
+        }
+      end
+    end
+
+    # Manages agent actions and state changes
+    class EventActions
+      attr_accessor :state_delta, :agent_state, :artifact_delta,
+                    :transfer_to_agent, :escalate, :skip_summarization,
+                    :end_of_agent, :requested_auth_configs,
+                    :requested_tool_confirmations, :rewind_before_invocation_id,
+                    :compaction
+
+      # Initialize event actions
+      #
+      # @param state_delta [Hash] State changes (optional)
+      # @param agent_state [Hash] Agent-specific state (optional)
+      # @param artifact_delta [Hash] Artifact changes (optional)
+      # @param transfer_to_agent [String] Agent to transfer to (optional)
+      # @param escalate [Boolean] Whether to escalate to parent (optional)
+      # @param skip_summarization [Boolean] Skip LLM summarization (optional)
+      # @param end_of_agent [Boolean] End agent lifecycle (optional)
+      def initialize(state_delta: {}, agent_state: nil, artifact_delta: {},
+                     transfer_to_agent: nil, escalate: false,
+                     skip_summarization: false, end_of_agent: false,
+                     requested_auth_configs: nil, requested_tool_confirmations: nil,
+                     rewind_before_invocation_id: nil, compaction: nil)
+        @state_delta = state_delta
+        @agent_state = agent_state
+        @artifact_delta = artifact_delta
+        @transfer_to_agent = transfer_to_agent
+        @escalate = escalate
+        @skip_summarization = skip_summarization
+        @end_of_agent = end_of_agent
+        @requested_auth_configs = requested_auth_configs
+        @requested_tool_confirmations = requested_tool_confirmations
+        @rewind_before_invocation_id = rewind_before_invocation_id
+        @compaction = compaction
+      end
+
+      # Convert to hash, excluding nil and empty values
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        result = {}
+        result[:state_delta] = @state_delta unless @state_delta.empty?
+        result[:agent_state] = @agent_state unless @agent_state.nil?
+        result[:artifact_delta] = @artifact_delta unless @artifact_delta.empty?
+        result[:transfer_to_agent] = @transfer_to_agent unless @transfer_to_agent.nil?
+        result[:escalate] = @escalate if @escalate
+        result[:skip_summarization] = @skip_summarization if @skip_summarization
+        result[:end_of_agent] = @end_of_agent if @end_of_agent
+        result[:requested_auth_configs] = @requested_auth_configs unless @requested_auth_configs.nil?
+        result[:requested_tool_confirmations] = @requested_tool_confirmations unless @requested_tool_confirmations.nil?
+        result[:rewind_before_invocation_id] = @rewind_before_invocation_id unless @rewind_before_invocation_id.nil?
+        result[:compaction] = @compaction unless @compaction.nil?
+        result
+      end
+    end
+
+    # Represents an event in agent-user conversation
+    class Event
+      attr_reader :id, :invocation_id, :author, :timestamp, :content,
+                  :function_calls, :function_responses, :long_running_tool_ids,
+                  :branch, :actions
+
+      # Initialize an event
+      #
+      # @param id [String] Unique event identifier (optional)
+      # @param invocation_id [String] Invocation ID
+      # @param author [String] Event author (user or agent name)
+      # @param timestamp [Time] Event timestamp (optional)
+      # @param content [String] Event content (optional)
+      # @param function_calls [Array<FunctionCall>] Function calls (optional)
+      # @param function_responses [Array<FunctionResponse>] Function responses (optional)
+      # @param long_running_tool_ids [Set] Long-running tool IDs (optional)
+      # @param branch [String] Conversation branch (optional)
+      # @param actions [EventActions] Event actions (optional)
+      def initialize(invocation_id:, author:, id: nil, timestamp: nil,
+                     content: nil, function_calls: [], function_responses: [],
+                     long_running_tool_ids: nil, branch: nil, actions: nil)
+        @id = id || self.class.new_id
+        @invocation_id = invocation_id
+        @author = author
+        @timestamp = timestamp || Time.now
+        @content = content
+        @function_calls = function_calls
+        @function_responses = function_responses
+        @long_running_tool_ids = long_running_tool_ids || Set.new
+        @branch = branch
+        @actions = actions
+      end
+
+      # Check if this is a final response
+      #
+      # @return [Boolean] True if final response
+      def is_final_response?
+        return true if @author == "user"
+        return true if @actions.nil?
+
+        @actions.transfer_to_agent.nil?
+      end
+
+      # Generate a new event ID
+      #
+      # @return [String] New UUID-based ID
+      def self.new_id
+        SecureRandom.uuid
+      end
+
+      # Convert to hash representation
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        result = {
+          id: @id,
+          invocation_id: @invocation_id,
+          author: @author,
+          timestamp: @timestamp.iso8601,
+          content: @content,
+          function_calls: @function_calls.map(&:to_h),
+          function_responses: @function_responses.map(&:to_h),
+          long_running_tool_ids: @long_running_tool_ids.to_a
+        }
+        result[:branch] = @branch unless @branch.nil?
+        result[:actions] = @actions.to_h if @actions
+        result
+      end
+    end
+  end
+end