google-adk 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78caa57a75d4badbe474b02fd6b459273ebf517a7a1feb90e054cf196765a860
-  data.tar.gz: 84fa8230dbc09c97e6c6ab69d48a97f54b7f236cb44a3e6c2b948bdf9b094d57
+  metadata.gz: 7339ca51f7b62eca3faef04fa0bc1270a1b2e2aa62e69450b7d24af003bee3e7
+  data.tar.gz: d7439e8f961885e1e65acc2300606ccf6c5ff0a7c04a5121d85eecf577f09024
 SHA512:
-  metadata.gz: acd4e17b57c786a64e6589945cbd1ebd41dfa5acf9df76a6b57610fe6c6281e9e83cb0d4f9923f1a86283749c95fc3a6902b52b354cd1c677f180b1b587487a7
-  data.tar.gz: a4aeaf187766bcd5764ce79845a44017fe5520fa018b1824c192e850e750a3ac1b36e386e5f928efb92e615e8444f81a3fce8821ef13e8eda0e12f7bad9fe13b
+  metadata.gz: 45a536e4605ad80cc478b307150b90e0d12a1a5137a754735e4125451adbc4da4448331428ac5f61f71964359c3e77ed6644093354c65ec21885cc6deba593d9
+  data.tar.gz: 13269dd0e75c90145cb8b731a312a2338e6f31149dff3b10c75eb8f61007c6731b7b6ae3af8c3725b1c8f8c0ae016bcbe0d29a29c17005beddfe1842b593d5c5

data/README.md

@@ -3,7 +3,6 @@
 Ruby implementation of Google's Agent Development Kit for building AI agents.
 
 [![Gem Version](https://badge.fury.io/rb/google-adk.svg)](https://badge.fury.io/rb/google-adk)
-[![Build Status](https://github.com/yourusername/google-adk-ruby/workflows/CI/badge.svg)](https://github.com/yourusername/google-adk-ruby/actions)
 
 > **⚠️ DISCLAIMER: This is an UNOFFICIAL Ruby port of Google's Agent Development Kit (ADK). This gem is not affiliated with, endorsed by, or maintained by Google. It is a community-driven implementation based on the public Python ADK repository. Use at your own risk.**
 
@@ -190,4 +189,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/yourus
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/google/adk/agents/llm_agent.rb

@@ -5,6 +5,8 @@ require_relative "../tools/base_tool"
 require_relative "../tools/function_tool"
 require_relative "../tools/agent_tool"
 require_relative "../clients/gemini_client"
+require_relative "../clients/anthropic_client"
+require_relative "../clients/openrouter_client"
 
 module Google
   module ADK
@@ -119,8 +121,8 @@ module Google
       def run_async(message, context: nil)
         Enumerator.new do |yielder|
           begin
-            # Initialize Gemini client
-            client = GeminiClient.new
+            # Initialize appropriate client based on model
+            client = create_client_for_model(canonical_model)
             
             # Build simple message for now
             messages = [{ role: "user", content: message }]
@@ -211,13 +213,21 @@ module Google
             
           rescue => e
             # Error handling
-            puts "[DEBUG] Gemini error: #{e.message}" if ENV["DEBUG"]
+            puts "[DEBUG] LLM error: #{e.message}" if ENV["DEBUG"]
             puts "[DEBUG] Backtrace: #{e.backtrace.first(3).join(', ')}" if ENV["DEBUG"]
             
+            api_key_msg = if canonical_model.to_s.downcase.include?("openrouter") || ENV["USE_OPENROUTER"]
+                            "Please check your OPENROUTER_API_KEY."
+                          elsif canonical_model.to_s.downcase.include?("claude") || ENV["USE_ANTHROPIC"]
+                            "Please check your ANTHROPIC_API_KEY."
+                          else
+                            "Please check your GEMINI_API_KEY or GOOGLE_API_KEY."
+                          end
+            
             event = Event.new(
               invocation_id: context&.invocation_id || "inv-#{SecureRandom.uuid}",
               author: @name,
-              content: "Error calling Gemini API: #{e.message}. Please check your GEMINI_API_KEY."
+              content: "Error calling LLM API: #{e.message}. #{api_key_msg}"
             )
             yielder << event
             context&.add_event(event) if context
@@ -303,6 +313,20 @@ module Google
         end
       end
 
+      # Create appropriate client based on model name
+      #
+      # @param model [String] Model name
+      # @return [GeminiClient, AnthropicClient, OpenRouterClient] Appropriate client instance
+      def create_client_for_model(model)
+        if model.to_s.downcase.include?("openrouter") || ENV["USE_OPENROUTER"]
+          OpenRouterClient.new
+        elsif model.to_s.downcase.include?("claude") || ENV["USE_ANTHROPIC"]
+          AnthropicClient.new
+        else
+          GeminiClient.new
+        end
+      end
+
       # Extract a reasonable name from a callable
       #
       # @param callable [Proc, Method] Callable object

data/lib/google/adk/agents/simple_llm_agent.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../clients/gemini_client"
+require_relative "../clients/anthropic_client"
 require "securerandom"
 
 module Google
@@ -14,7 +15,7 @@ module Google
         @name = name
         @instructions = instructions
         @tools = tools
-        @client = GeminiClient.new
+        @client = create_client_for_model(model)
       end
 
       # Simple synchronous call to Gemini
@@ -62,6 +63,20 @@ module Google
           end
         end
       end
+
+      private
+
+      # Create appropriate client based on model name
+      #
+      # @param model [String] Model name
+      # @return [GeminiClient, AnthropicClient] Appropriate client instance
+      def create_client_for_model(model)
+        if model.to_s.downcase.include?("claude") || ENV["USE_ANTHROPIC"]
+          AnthropicClient.new
+        else
+          GeminiClient.new
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "securerandom"
+
+module Google
+  module ADK
+    # Client for interacting with Anthropic's Claude API
+    class AnthropicClient
+      API_BASE_URL = "https://api.anthropic.com"
+      API_VERSION = "2023-06-01"
+      DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
+      
+      attr_reader :api_key
+
+      def initialize(api_key: nil)
+        @api_key = api_key || ENV["ANTHROPIC_API_KEY"]
+        raise ConfigurationError, "ANTHROPIC_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 Anthropic API
+      #
+      # @param model [String] Model name (e.g., "claude-3-5-sonnet-20241022")
+      # @param messages [Array<Hash>] Conversation messages
+      # @param tools [Array<Hash>] Available tools (optional)
+      # @param system_instruction [String] System instruction (optional)
+      # @return [Hash] API response formatted to match Gemini response structure
+      def generate_content(model:, messages:, tools: nil, system_instruction: nil)
+        url = "/v1/messages"
+        
+        # Convert messages to Anthropic format
+        anthropic_messages = format_messages(messages)
+        
+        # Adjust max_tokens based on model
+        max_tokens = case model
+        when /haiku/
+          4096
+        when /sonnet/
+          4096
+        when /opus/
+          4096
+        else
+          4096  # Safe default for Claude models
+        end
+        
+        payload = {
+          model: model || DEFAULT_MODEL,
+          messages: anthropic_messages,
+          max_tokens: max_tokens,
+          temperature: 0.7
+        }
+        
+        # Add system instruction if provided
+        payload[:system] = system_instruction if system_instruction
+        
+        # Add tools if provided
+        if tools && !tools.empty?
+          payload[:tools] = format_tools(tools)
+        end
+        
+        response = @client.post(url) do |req|
+          req.headers["x-api-key"] = @api_key
+          req.headers["anthropic-version"] = API_VERSION
+          req.headers["content-type"] = "application/json"
+          req.body = payload
+        end
+        
+        handle_response(response)
+      end
+
+      private
+
+      # Format messages for Anthropic API
+      def format_messages(messages)
+        @tool_id_map ||= {}
+        
+        messages.map do |msg|
+          if msg[:parts]
+            # Handle Gemini-formatted messages
+            convert_gemini_message(msg)
+          else
+            # Simple text messages
+            {
+              role: normalize_role(msg[:role]),
+              content: msg[:content]
+            }
+          end
+        end
+      end
+
+      # Convert Gemini-formatted message to Anthropic format
+      def convert_gemini_message(msg)
+        role = msg[:role] == "model" ? "assistant" : normalize_role(msg[:role])
+        
+        # Handle different part types
+        content = msg[:parts].map do |part|
+          # Handle both symbol and string keys
+          text = part[:text] || part["text"]
+          function_call = part[:functionCall] || part["functionCall"]
+          function_response = part[:functionResponse] || part["functionResponse"]
+          
+          if text
+            # Text part
+            { type: "text", text: text }
+          elsif function_call
+            # Tool use request - ensure name is a string and handle nested keys
+            fc_name = function_call[:name] || function_call["name"]
+            fc_args = function_call[:args] || function_call["args"] || {}
+            
+            # Generate and store tool ID
+            tool_id = "tool_#{SecureRandom.hex(8)}"
+            @tool_id_map[fc_name.to_s] = tool_id
+            
+            {
+              type: "tool_use",
+              id: tool_id,
+              name: fc_name.to_s,
+              input: fc_args
+            }
+          elsif function_response
+            # Tool result
+            fr_name = function_response[:name] || function_response["name"]
+            fr_response = function_response[:response] || function_response["response"]
+            
+            # Retrieve the tool ID for this function
+            tool_id = @tool_id_map[fr_name.to_s] || "tool_#{SecureRandom.hex(8)}"
+            
+            {
+              type: "tool_result",
+              tool_use_id: tool_id,
+              content: JSON.generate(fr_response)
+            }
+          else
+            # Default to text
+            { type: "text", text: part.to_s }
+          end
+        end.flatten
+        
+        # Anthropic expects content as array for complex messages, string for simple
+        content = content.first[:text] if content.length == 1 && content.first[:type] == "text"
+        
+        { role: role, content: content }
+      end
+
+      # Normalize role names
+      def normalize_role(role)
+        case role.to_s
+        when "model", "assistant"
+          "assistant"
+        when "function", "tool"
+          "user" # Anthropic treats tool responses as user messages
+        else
+          "user"
+        end
+      end
+
+      # Format tools for Anthropic API
+      def format_tools(tools)
+        tools.map do |tool|
+          {
+            name: tool["name"],
+            description: tool["description"],
+            input_schema: tool["parameters"] || {
+              type: "object",
+              properties: {},
+              required: []
+            }
+          }
+        end
+      end
+
+      # Handle API response and convert to Gemini format
+      def handle_response(response)
+        case response.status
+        when 200
+          convert_to_gemini_format(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
+
+      # Convert Anthropic response to Gemini format for compatibility
+      def convert_to_gemini_format(anthropic_response)
+        # Build parts from content
+        parts = []
+        
+        content = anthropic_response["content"]
+        content = [content] unless content.is_a?(Array)
+        
+        content.each do |item|
+          if item.is_a?(String)
+            # Simple text response
+            parts << { "text" => item }
+          elsif item.is_a?(Hash)
+            case item["type"]
+            when "text"
+              parts << { "text" => item["text"] }
+            when "tool_use"
+              # Convert tool use to function call
+              parts << {
+                "functionCall" => {
+                  "name" => item["name"].to_s,
+                  "args" => item["input"]
+                }
+              }
+            end
+          end
+        end
+        
+        # Format as Gemini response
+        {
+          "candidates" => [
+            {
+              "content" => {
+                "parts" => parts,
+                "role" => "model"
+              }
+            }
+          ]
+        }
+      end
+    end
+  end
+end

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

@@ -12,8 +12,8 @@ module Google
       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
+        @api_key = api_key || ENV["GEMINI_API_KEY"] || ENV["GOOGLE_API_KEY"]
+        raise ConfigurationError, "GEMINI_API_KEY or GOOGLE_API_KEY not set" unless @api_key
         
         @client = Faraday.new(API_BASE_URL) do |conn|
           conn.request :json

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "securerandom"
+
+module Google
+  module ADK
+    # Client for interacting with OpenRouter's OpenAI-compatible API
+    class OpenRouterClient
+      API_BASE_URL = "https://openrouter.ai/api/v1"
+      DEFAULT_MODEL = "openrouter/auto"
+      
+      attr_reader :api_key
+
+      def initialize(api_key: nil)
+        @api_key = api_key || ENV["OPENROUTER_API_KEY"]
+        raise ConfigurationError, "OPENROUTER_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 OpenRouter API
+      #
+      # @param model [String] Model name (e.g., "openrouter/auto", "anthropic/claude-3-haiku")
+      # @param messages [Array<Hash>] Conversation messages
+      # @param tools [Array<Hash>] Available tools (optional)
+      # @param system_instruction [String] System instruction (optional)
+      # @return [Hash] API response formatted to match Gemini response structure
+      def generate_content(model:, messages:, tools: nil, system_instruction: nil)
+        url = "/chat/completions"
+        
+        # Convert messages to OpenAI format
+        openai_messages = format_messages(messages)
+        
+        # Add system message if provided
+        if system_instruction
+          openai_messages.unshift({
+            role: "system",
+            content: system_instruction
+          })
+        end
+        
+        payload = {
+          model: model || DEFAULT_MODEL,
+          messages: openai_messages,
+          max_tokens: 8192,
+          temperature: 0.7,
+          top_p: 0.95
+        }
+        
+        # Add tools if provided
+        if tools && !tools.empty?
+          payload[:tools] = format_tools(tools)
+          payload[:tool_choice] = "auto"
+        end
+        
+        response = @client.post(url) do |req|
+          req.headers["Authorization"] = "Bearer #{@api_key}"
+          req.headers["Content-Type"] = "application/json"
+          req.headers["HTTP-Referer"] = "https://github.com/google-adk"
+          req.headers["X-Title"] = "Google ADK Client"
+          req.body = payload
+        end
+        
+        handle_response(response)
+      end
+
+      private
+
+      # Format messages for OpenRouter/OpenAI API
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg[:parts]
+            # Handle Gemini-formatted messages
+            convert_gemini_message(msg)
+          else
+            # Simple text messages
+            {
+              role: normalize_role(msg[:role]),
+              content: msg[:content]
+            }
+          end
+        end.flatten.compact
+      end
+
+      # Convert Gemini-formatted message to OpenAI format
+      def convert_gemini_message(msg)
+        role = msg[:role] == "model" ? "assistant" : normalize_role(msg[:role])
+        
+        # Handle different part types
+        msg[:parts].map do |part|
+          if part[:text]
+            # Text part
+            { role: role, content: part[:text] }
+          elsif part[:functionCall]
+            # Tool call - OpenAI format uses tool_calls array
+            {
+              role: "assistant",
+              content: nil,
+              tool_calls: [{
+                id: "call_#{SecureRandom.hex(8)}",
+                type: "function",
+                function: {
+                  name: part[:functionCall][:name],
+                  arguments: JSON.generate(part[:functionCall][:args] || {})
+                }
+              }]
+            }
+          elsif part[:functionResponse]
+            # Tool response
+            {
+              role: "tool",
+              content: JSON.generate(part[:functionResponse][:response]),
+              tool_call_id: "call_#{SecureRandom.hex(8)}" # Would need to track this properly
+            }
+          else
+            # Default to text
+            { role: role, content: part.to_s }
+          end
+        end
+      end
+
+      # Normalize role names
+      def normalize_role(role)
+        case role.to_s
+        when "model", "assistant"
+          "assistant"
+        when "function"
+          "tool"
+        else
+          role.to_s
+        end
+      end
+
+      # Format tools for OpenRouter/OpenAI API
+      def format_tools(tools)
+        tools.map do |tool|
+          {
+            type: "function",
+            function: {
+              name: tool["name"],
+              description: tool["description"],
+              parameters: tool["parameters"] || {
+                type: "object",
+                properties: {},
+                required: []
+              }
+            }
+          }
+        end
+      end
+
+      # Handle API response and convert to Gemini format
+      def handle_response(response)
+        case response.status
+        when 200
+          convert_to_gemini_format(response.body)
+        when 400
+          error_msg = response.body.dig("error", "message") || response.body["error"] || response.body
+          raise Error, "Bad request: #{error_msg}"
+        when 401
+          raise ConfigurationError, "Invalid API key"
+        when 402
+          raise Error, "Insufficient credits. Please add credits to your OpenRouter account."
+        when 429
+          raise Error, "Rate limit exceeded"
+        when 503
+          raise Error, "Model provider temporarily unavailable"
+        else
+          error_msg = response.body.dig("error", "message") || response.body["error"] || response.body
+          raise Error, "API error (#{response.status}): #{error_msg}"
+        end
+      end
+
+      # Convert OpenRouter/OpenAI response to Gemini format for compatibility
+      def convert_to_gemini_format(openai_response)
+        # Get the first choice (OpenAI returns array of choices)
+        choice = openai_response["choices"]&.first
+        return empty_response unless choice
+        
+        message = choice["message"]
+        parts = []
+        
+        # Handle text content
+        if message["content"]
+          parts << { "text" => message["content"] }
+        end
+        
+        # Handle tool calls
+        if message["tool_calls"]
+          message["tool_calls"].each do |tool_call|
+            if tool_call["type"] == "function"
+              parts << {
+                "functionCall" => {
+                  "name" => tool_call["function"]["name"],
+                  "args" => JSON.parse(tool_call["function"]["arguments"])
+                }
+              }
+            end
+          end
+        end
+        
+        # Format as Gemini response
+        {
+          "candidates" => [
+            {
+              "content" => {
+                "parts" => parts,
+                "role" => "model"
+              }
+            }
+          ]
+        }
+      end
+
+      def empty_response
+        {
+          "candidates" => [
+            {
+              "content" => {
+                "parts" => [{ "text" => "" }],
+                "role" => "model"
+              }
+            }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/google/adk/version.rb

@@ -2,6 +2,6 @@
 
 module Google
   module ADK
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/google/adk.rb

@@ -18,6 +18,8 @@ require_relative "adk/tools/base_tool"
 require_relative "adk/tools/function_tool"
 require_relative "adk/tools/agent_tool"
 require_relative "adk/clients/gemini_client"
+require_relative "adk/clients/anthropic_client"
+require_relative "adk/clients/openrouter_client"
 require_relative "adk/runner"
 
 module Google

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-adk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Landon Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-15 00:00:00.000000000 Z
+date: 2025-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -213,7 +213,9 @@ files:
 - lib/google/adk/agents/workflow_agents/loop_agent.rb
 - lib/google/adk/agents/workflow_agents/parallel_agent.rb
 - lib/google/adk/agents/workflow_agents/sequential_agent.rb
+- lib/google/adk/clients/anthropic_client.rb
 - lib/google/adk/clients/gemini_client.rb
+- lib/google/adk/clients/openrouter_client.rb
 - lib/google/adk/context.rb
 - lib/google/adk/events.rb
 - lib/google/adk/runner.rb