llm_gateway 0.3.0 → 0.5.0

data/scripts/create_anthropic_credentials.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "fileutils"
+require_relative "../lib/llm_gateway"
+
+module Scripts
+  class CreateAnthropicCredentials
+    def initialize(argv)
+      @options = {
+        client_id: LlmGateway::Clients::ClaudeCode::OAuthFlow::CLIENT_ID,
+        scopes: LlmGateway::Clients::ClaudeCode::OAuthFlow::DEFAULT_SCOPES,
+        output: File.expand_path(ENV.fetch("LLM_GATEWAY_AUTH_FILE", "~/.config/llm_gateway/auth.json"))
+      }
+      parse_options(argv)
+    end
+
+    def run
+      flow = LlmGateway::Clients::ClaudeCode::OAuthFlow.new(
+        client_id: @options[:client_id],
+        scopes: @options[:scopes]
+      )
+
+      auth = flow.start
+
+      puts "Anthropic OAuth setup"
+      puts "Redirect URI: #{flow.redirect_uri}"
+      puts ""
+      puts "Open this URL in your browser:"
+      puts auth[:authorization_url]
+      puts ""
+      puts "After authenticating, paste either:"
+      puts "- the full callback URL"
+      puts "- or the legacy code#state value"
+      print "> "
+
+      callback_value = $stdin.gets.to_s.strip
+      tokens = flow.exchange_code(callback_value, auth[:code_verifier], state: auth[:state])
+
+      credentials = {
+        client_id: flow.client_id,
+        access_token: tokens[:access_token],
+        refresh_token: tokens[:refresh_token],
+        expires_at: tokens[:expires_at]&.iso8601
+      }
+
+      persist_credentials("anthropic", credentials)
+
+      puts "Credentials:"
+      puts JSON.pretty_generate(credentials)
+      puts ""
+      puts "Environment exports:"
+      puts "export ANTHROPIC_ACCESS_TOKEN=#{shell_escape(tokens[:access_token])}"
+      puts "export ANTHROPIC_REFRESH_TOKEN=#{shell_escape(tokens[:refresh_token])}"
+      puts "export ANTHROPIC_EXPIRES_AT=#{shell_escape(tokens[:expires_at]&.iso8601.to_s)}"
+    rescue Interrupt
+      warn "Aborted."
+      exit 1
+    end
+
+    private
+
+    def parse_options(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ruby scripts/create_anthropic_credentials.rb [options]"
+
+        opts.on("--client-id ID", "Anthropic OAuth client id") do |value|
+          @options[:client_id] = value
+        end
+
+        opts.on("--scopes SCOPES", "OAuth scopes") do |value|
+          @options[:scopes] = value
+        end
+
+        opts.on("--output PATH", "Write credentials JSON to PATH") do |value|
+          @options[:output] = value
+        end
+      end.parse!(argv)
+    end
+
+    def persist_credentials(provider, credentials)
+      output_path = File.expand_path(@options[:output])
+      FileUtils.mkdir_p(File.dirname(output_path))
+
+      existing = if File.exist?(output_path)
+        JSON.parse(File.read(output_path))
+      else
+        {}
+      end
+
+      existing[provider] = credentials
+      File.write(output_path, JSON.pretty_generate(existing) + "\n")
+      puts "Credentials written to #{output_path}"
+    end
+
+    def shell_escape(value)
+      return "''" if value.nil? || value.empty?
+
+      "'#{value.to_s.gsub("'", %q('\''))}'"
+    end
+  end
+end
+
+Scripts::CreateAnthropicCredentials.new(ARGV).run

data/scripts/create_openai_codex_credentials.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "fileutils"
+require_relative "../lib/llm_gateway"
+
+module Scripts
+  class CreateOpenAiCodexCredentials
+    def initialize(argv)
+      @options = {
+        client_id: LlmGateway::Clients::OpenAi::OAuthFlow::CLIENT_ID,
+        redirect_uri: LlmGateway::Clients::OpenAi::OAuthFlow::REDIRECT_URI,
+        scope: LlmGateway::Clients::OpenAi::OAuthFlow::SCOPE,
+        output: File.expand_path(ENV.fetch("LLM_GATEWAY_AUTH_FILE", "~/.config/llm_gateway/auth.json"))
+      }
+      parse_options(argv)
+    end
+
+    def run
+      flow = LlmGateway::Clients::OpenAi::OAuthFlow.new(
+        client_id: @options[:client_id],
+        redirect_uri: @options[:redirect_uri],
+        scope: @options[:scope]
+      )
+
+      auth = flow.start
+
+      puts "OpenAI Codex OAuth setup"
+      puts "Redirect URI: #{flow.redirect_uri}"
+      puts ""
+      puts "Open this URL in your browser:"
+      puts auth[:authorization_url]
+      puts ""
+      puts "After authenticating, the browser will redirect to localhost (the page won't load)."
+      puts "Paste either:"
+      puts "  - the full callback URL  (http://localhost:1455/auth/callback?code=...)"
+      puts "  - or just the code"
+      print "> "
+
+      callback_value = $stdin.gets.to_s.strip
+      tokens = flow.exchange_code(callback_value, auth[:code_verifier], expected_state: auth[:state])
+
+      credentials = {
+        client_id: flow.client_id,
+        account_id: tokens[:account_id],
+        access_token: tokens[:access_token],
+        refresh_token: tokens[:refresh_token],
+        expires_at: tokens[:expires_at]&.iso8601
+      }
+
+      persist_credentials("openai", credentials)
+
+      puts ""
+      puts "Credentials:"
+      puts JSON.pretty_generate(credentials)
+      puts ""
+      puts "Environment exports:"
+      puts "export OPENAI_CODEX_ACCOUNT_ID=#{shell_escape(tokens[:account_id].to_s)}"
+      puts "export OPENAI_CODEX_ACCESS_TOKEN=#{shell_escape(tokens[:access_token])}"
+      puts "export OPENAI_CODEX_REFRESH_TOKEN=#{shell_escape(tokens[:refresh_token])}"
+      puts "export OPENAI_CODEX_EXPIRES_AT=#{shell_escape(tokens[:expires_at]&.iso8601.to_s)}"
+    rescue Interrupt
+      warn "Aborted."
+      exit 1
+    end
+
+    private
+
+    def parse_options(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ruby scripts/create_openai_codex_credentials.rb [options]"
+
+        opts.on("--client-id ID", "OpenAI OAuth client id") do |value|
+          @options[:client_id] = value
+        end
+
+        opts.on("--redirect-uri URI", "OAuth redirect URI") do |value|
+          @options[:redirect_uri] = value
+        end
+
+        opts.on("--scope SCOPE", "OAuth scopes (space-separated)") do |value|
+          @options[:scope] = value
+        end
+
+        opts.on("--output PATH", "Write credentials JSON to PATH") do |value|
+          @options[:output] = value
+        end
+      end.parse!(argv)
+    end
+
+    def persist_credentials(provider, credentials)
+      output_path = File.expand_path(@options[:output])
+      FileUtils.mkdir_p(File.dirname(output_path))
+
+      existing = if File.exist?(output_path)
+        JSON.parse(File.read(output_path))
+      else
+        {}
+      end
+
+      existing[provider] = credentials
+      File.write(output_path, JSON.pretty_generate(existing) + "\n")
+      puts "Credentials written to #{output_path}"
+    end
+
+    def shell_escape(value)
+      return "''" if value.nil? || value.empty?
+
+      "'#{value.to_s.gsub("'", %q('\''))}'"
+    end
+  end
+end
+
+Scripts::CreateOpenAiCodexCredentials.new(ARGV).run

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
-dependencies: []
+date: 2026-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: LlmGateway provides a consistent Ruby interface for multiple LLM providers
   including Claude, OpenAI, and Groq. Features include unified response formatting,
   error handling, and fluent data mapping.
@@ -19,45 +33,64 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".pi/skills/live-provider-testing/SKILL.md"
+- ".pi/skills/options-development/SKILL.md"
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/migration-guide.md
 - lib/llm_gateway.rb
-- lib/llm_gateway/adapters/claude/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/claude/client.rb
-- lib/llm_gateway/adapters/claude/input_mapper.rb
-- lib/llm_gateway/adapters/claude/output_mapper.rb
-- lib/llm_gateway/adapters/groq/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/groq/client.rb
+- lib/llm_gateway/adapters/adapter.rb
+- lib/llm_gateway/adapters/anthropic/acts_like_messages.rb
+- lib/llm_gateway/adapters/anthropic/input_mapper.rb
+- lib/llm_gateway/adapters/anthropic/messages_adapter.rb
+- lib/llm_gateway/adapters/anthropic/output_mapper.rb
+- lib/llm_gateway/adapters/anthropic/stream_mapper.rb
+- lib/llm_gateway/adapters/anthropic_option_mapper.rb
+- lib/llm_gateway/adapters/groq/chat_completions_adapter.rb
 - lib/llm_gateway/adapters/groq/input_mapper.rb
-- lib/llm_gateway/adapters/groq/output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/input_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/client.rb
-- lib/llm_gateway/adapters/open_ai/file_output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/input_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/output_mapper.rb
+- lib/llm_gateway/adapters/groq/option_mapper.rb
+- lib/llm_gateway/adapters/input_message_sanitizer.rb
+- lib/llm_gateway/adapters/normalized_stream_accumulator.rb
+- lib/llm_gateway/adapters/openai/acts_like_chat_completions.rb
+- lib/llm_gateway/adapters/openai/acts_like_responses.rb
+- lib/llm_gateway/adapters/openai/chat_completions/input_mapper.rb
+- lib/llm_gateway/adapters/openai/chat_completions/input_message_sanitizer.rb
+- lib/llm_gateway/adapters/openai/chat_completions/option_mapper.rb
+- lib/llm_gateway/adapters/openai/chat_completions/stream_mapper.rb
+- lib/llm_gateway/adapters/openai/chat_completions_adapter.rb
+- lib/llm_gateway/adapters/openai/file_output_mapper.rb
+- lib/llm_gateway/adapters/openai/prompt_cache_option_mapper.rb
+- lib/llm_gateway/adapters/openai/responses/input_mapper.rb
+- lib/llm_gateway/adapters/openai/responses/option_mapper.rb
+- lib/llm_gateway/adapters/openai/responses/stream_mapper.rb
+- lib/llm_gateway/adapters/openai/responses_adapter.rb
+- lib/llm_gateway/adapters/openai_codex/input_mapper.rb
+- lib/llm_gateway/adapters/openai_codex/option_mapper.rb
+- lib/llm_gateway/adapters/openai_codex/responses_adapter.rb
+- lib/llm_gateway/adapters/option_mapper.rb
+- lib/llm_gateway/adapters/stream_mapper.rb
+- lib/llm_gateway/adapters/structs.rb
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
+- lib/llm_gateway/clients/anthropic.rb
+- lib/llm_gateway/clients/claude_code/oauth_flow.rb
+- lib/llm_gateway/clients/claude_code/token_manager.rb
+- lib/llm_gateway/clients/groq.rb
+- lib/llm_gateway/clients/openai.rb
+- lib/llm_gateway/clients/openai_codex/oauth_flow.rb
+- lib/llm_gateway/clients/openai_codex/token_manager.rb
 - lib/llm_gateway/errors.rb
 - lib/llm_gateway/prompt.rb
+- lib/llm_gateway/provider_registry.rb
 - lib/llm_gateway/tool.rb
 - lib/llm_gateway/utils.rb
 - lib/llm_gateway/version.rb
-- sample/claude_code_clone/agent.rb
-- sample/claude_code_clone/claude_code_clone.rb
-- sample/claude_code_clone/prompt.rb
-- sample/claude_code_clone/run.rb
-- sample/claude_code_clone/tools/bash_tool.rb
-- sample/claude_code_clone/tools/edit_tool.rb
-- sample/claude_code_clone/tools/grep_tool.rb
-- sample/claude_code_clone/tools/read_tool.rb
-- sample/claude_code_clone/tools/todowrite_tool.rb
+- scripts/create_anthropic_credentials.rb
+- scripts/create_openai_codex_credentials.rb
 - sig/llm_gateway.rbs
 homepage: https://github.com/Hyper-Unearthing/llm_gateway
 licenses:

data/lib/llm_gateway/adapters/claude/bidirectional_message_mapper.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class BidirectionalMessageMapper
-        attr_reader :direction
-
-        def initialize(direction)
-          @direction = direction
-        end
-
-        def map_content(content)
-          # Convert string content to text format
-          content = { type: "text", text: content } unless content.is_a?(Hash)
-
-          case content[:type]
-          when "text"
-            map_text_content(content)
-          when "file"
-            map_file_content(content)
-          when "image"
-            map_image_content(content)
-          when "tool_use"
-            map_tool_use_content(content)
-          when "tool_result"
-            map_tool_result_content(content)
-          else
-            content
-          end
-        end
-
-        private
-
-        def map_text_content(content)
-          {
-            type: "text",
-            text: content[:text]
-          }
-        end
-
-        def map_file_content(content)
-          {
-            type: "document",
-            source: {
-              data: content[:data],
-              type: "text",
-              media_type: content[:media_type]
-            }
-          }
-        end
-
-        def map_image_content(content)
-          {
-            type: "image",
-            source: {
-              data: content[:data],
-              type: "base64",
-              media_type: content[:media_type]
-            }
-          }
-        end
-
-        def map_tool_use_content(content)
-          {
-            type: "tool_use",
-            id: content[:id],
-            name: content[:name],
-            input: content[:input]
-          }
-        end
-
-        def map_tool_result_content(content)
-          {
-            type: "tool_result",
-            tool_use_id: content[:tool_use_id],
-            content: content[:content]
-          }
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/claude/client.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class Client < BaseClient
-        def initialize(model_key: "claude-3-7-sonnet-20250219", api_key: ENV["ANTHROPIC_API_KEY"])
-          @base_endpoint = "https://api.anthropic.com/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            max_tokens: max_completion_tokens,
-            messages: messages
-          }
-
-          body.merge!(tools: tools) if LlmGateway::Utils.present?(tools)
-          body.merge!(system: system) if LlmGateway::Utils.present?(system)
-
-          post("messages", body)
-        end
-
-        def download_file(file_id)
-          get("files/#{file_id}/content")
-        end
-
-        def upload_file(filename, content, mime_type = "application/octet-stream")
-          post_file("files", content, filename, mime_type: mime_type)
-        end
-
-        private
-
-        def build_headers
-          {
-            "anthropic-version" => "2023-06-01",
-            "content-type" => "application/json",
-            "x-api-key" => api_key,
-            "anthropic-beta" => "code-execution-2025-05-22,files-api-2025-04-14"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          case response.code.to_i
-          when 400
-            if error["message"]&.start_with?("prompt is too long")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error["type"])
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/claude/input_mapper.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class InputMapper
-        def self.map(data)
-          {
-            messages: map_messages(data[:messages]),
-            response_format: data[:response_format],
-            tools: data[:tools],
-            system: map_system(data[:system])
-          }
-        end
-
-        private
-
-        def self.map_messages(messages)
-          return messages unless messages
-
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
-
-          messages.map do |msg|
-            msg = msg.merge(role: "user") if msg[:role] == "developer"
-
-            content = if msg[:content].is_a?(Array)
-                msg[:content].map do |content|
-                  message_mapper.map_content(content)
-                end
-            else
-              [ message_mapper.map_content(msg[:content]) ]
-            end
-
-            {
-              role: msg[:role],
-              content: content
-            }
-          end
-        end
-
-        def self.map_system(system)
-          if !system || system.empty?
-            nil
-          elsif system.length == 1 && system.first[:role] == "system"
-            # If we have a single system message, convert to Claude format
-            [ { type: "text", text: system.first[:content] } ]
-          else
-            # For multiple messages or non-standard format, pass through
-            system
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/claude/output_mapper.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class FileOutputMapper
-        def self.map(data)
-          data.delete(:type) # Didnt see much value in this only option is "file"
-          data.merge(
-            expires_at: nil, # came from open ai api
-            purpose: "user_data",  # came from open ai api
-          )
-        end
-      end
-
-      class OutputMapper
-        def self.map(data)
-          {
-            id: data[:id],
-            model: data[:model],
-            usage: data[:usage],
-            choices: map_choices(data)
-          }
-        end
-
-        private
-
-        def self.map_choices(data)
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_OUT)
-
-          content = if data[:content].is_a?(Array)
-              data[:content].map do |content|
-                message_mapper.map_content(content)
-              end
-          else
-            data[:content] ? [ message_mapper.map_content(data[:content]) ] : []
-          end
-
-          # Claude returns content directly at root level, not in a choices array
-          # We need to construct the choices array from the full response data
-          [ {
-            content: content, # Use content directly from Claude response
-            finish_reason: data[:stop_reason],
-            role: "assistant"
-          } ]
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/bidirectional_message_mapper.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../open_ai/chat_completions/bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class BidirectionalMessageMapper < OpenAi::ChatCompletions::BidirectionalMessageMapper
-        private
-
-        def map_file_content(content)
-          # Groq doesn't support files, return as text
-          content[:text] || "[File: #{content[:name]}]"
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/client.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class Client < BaseClient
-        def initialize(model_key: "gemma2-9b-it", api_key: ENV["GROQ_API_KEY"])
-          @base_endpoint = "https://api.groq.com/openai/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            messages: system + messages,
-            temperature: 0,
-            max_completion_tokens: max_completion_tokens,
-            response_format: response_format,
-            tools: tools
-          }
-
-          post("chat/completions", body)
-        end
-
-        private
-
-        def build_headers
-          {
-            "content-type" => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          # Groq likely uses 'code' like OpenAI since it's OpenAI-compatible
-          error_code = error["code"]
-
-          case response.code.to_i
-
-          when 413
-            if error["message"]&.start_with?("Request too large")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          when 429
-            raise Errors::RateLimitError.new(error["type"], error_code) if error_code == "rate_limit_exceeded"
-
-            raise Errors::OverloadError.new(error["message"], error_code)
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error_code)
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/output_mapper.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class OutputMapper < LlmGateway::Adapters::OpenAi::ChatCompletions::OutputMapper
-      end
-    end
-  end
-end