llm_gateway 0.4.0 → 0.6.0

data/lib/llm_gateway/adapters/structs.rb

@@ -9,35 +9,6 @@ class BaseStruct < Dry::Struct
   transform_keys(&:to_sym)
 end
 
-class AssistantStreamEvent < BaseStruct
-  EventType = Types::Coercible::Symbol.enum(:text_start, :text_delta, :text_end, :tool_start, :tool_delta, :tool_end, :reasoning_start, :reasoning_delta, :reasoning_end)
-
-  attribute :type, EventType
-  attribute :delta, Types::Coercible::String.default { "" }
-  attribute :content_index, Types::Integer
-end
-
-
-class AssistantToolStartEvent < AssistantStreamEvent
-  attribute :id, Types::String
-  attribute :name, Types::String
-  attribute :content_index, Types::Integer
-end
-
-
-class AssistantStreamReasoningEvent < AssistantStreamEvent
-  attribute :signature, Types::Coercible::String.default { "" }
-  attribute :content_index, Types::Integer
-end
-
-class AssistantStreamMessageEvent < BaseStruct
-  EventType = Types::Coercible::Symbol.enum(:message_start, :message_delta, :message_end)
-
-  attribute :type, EventType
-  attribute :delta, Types::Coercible::Hash.default { {} }
-  attribute :usage_increment, Types::Coercible::Hash.default { {} }
-end
-
 class TextContent < BaseStruct
   attribute :type, Types::String.enum("text")
   attribute :text, Types::String
@@ -87,12 +58,101 @@ class ToolResult < BaseStruct
   attribute :content, Types::String
 end
 
-class AssistantMessage < BaseStruct
+class PartialAssistantMessage < BaseStruct
   ContentBlock =
     Types.Instance(TextContent) |
     Types.Instance(ReasoningContent) |
     Types.Instance(ToolCall)
 
+  attribute? :id, Types::String.optional
+  attribute? :model, Types::String.optional
+  attribute? :role, Types::String.enum("assistant").optional
+  attribute :timestamp, Types::Integer
+  attribute? :stop_reason, Types::String.enum("stop", "length", "tool_use", "toolUse", "error", "aborted").optional
+  attribute? :content, Types::Array.of(ContentBlock).optional
+
+  def self.new(attributes = {})
+    attrs = attributes.to_h.transform_keys(&:to_sym)
+    attrs[:content] = Array(attrs[:content]).map { |block| build_content_block(block) } if attrs.key?(:content)
+    super(attrs)
+  end
+
+  def self.build_content_block(block)
+    return block if block.is_a?(TextContent) || block.is_a?(ReasoningContent) || block.is_a?(ToolCall)
+
+    case block[:type] || block["type"]
+    when "text"
+      TextContent.new(block)
+    when "reasoning"
+      ReasoningContent.new(block)
+    when "thinking"
+      ReasoningContent.new(
+        type: "reasoning",
+        reasoning: block[:thinking] || block["thinking"] || block[:reasoning] || block["reasoning"],
+        signature: block[:signature] || block["signature"]
+      )
+    when "tool_use"
+      ToolCall.new(block)
+    else
+      raise ArgumentError, "Unsupported content block type: #{block[:type] || block['type']}"
+    end
+  end
+
+  private_class_method :build_content_block
+end
+
+class AssistantStreamEvent < BaseStruct
+  EventType = Types::Coercible::Symbol.enum(:text_start, :text_delta, :text_end, :tool_start, :tool_delta, :tool_end, :reasoning_start, :reasoning_delta, :reasoning_end)
+
+  attribute :type, EventType
+  attribute :delta, Types::Coercible::String.default { "" }
+  attribute :content_index, Types::Integer
+  attribute :partial, Types.Instance(PartialAssistantMessage)
+
+  def content
+    case type
+    when :text_end
+      finalized_content_block&.text
+    when :reasoning_end
+      finalized_content_block&.reasoning
+    when :tool_end
+      finalized_content_block
+    end
+  end
+
+  def text
+    content if type == :text_end
+  end
+
+  def reasoning
+    content if type == :reasoning_end
+  end
+
+  def tool_call
+    finalized_content_block if type == :tool_end
+  end
+
+  alias tool tool_call
+
+  private
+
+  def finalized_content_block
+    partial.content&.[](content_index)
+  end
+end
+
+class AssistantToolStartEvent < AssistantStreamEvent
+  attribute :id, Types::String
+  attribute :name, Types::String
+  attribute :content_index, Types::Integer
+end
+
+class AssistantStreamReasoningEvent < AssistantStreamEvent
+  attribute :signature, Types::Coercible::String.default { "" }
+  attribute :content_index, Types::Integer
+end
+
+class AssistantMessage < PartialAssistantMessage
   attribute :id, Types::String
   attribute :model, Types::String
   attribute :usage, Types::Hash
@@ -103,12 +163,6 @@ class AssistantMessage < BaseStruct
   attribute? :error_message, Types::String.optional
   attribute :content, Types::Array.of(ContentBlock)
 
-  def self.new(attributes)
-    attrs = attributes.to_h.transform_keys(&:to_sym)
-    attrs[:content] = Array(attrs[:content]).map { |block| build_content_block(block) }
-    super(attrs)
-  end
-
   def to_h
     result = {
       id: id,
@@ -120,26 +174,22 @@ class AssistantMessage < BaseStruct
       api: api,
       content: content.map(&:to_h)
     }
+    result[:timestamp] = timestamp unless timestamp.nil?
     result[:error_message] = error_message unless error_message.nil?
     result
   end
+end
 
-  def self.build_content_block(block)
-    return block if block.is_a?(TextContent) || block.is_a?(ReasoningContent) || block.is_a?(ToolCall)
+class AssistantStreamMessageEvent < BaseStruct
+  EventType = Types::Coercible::Symbol.enum(:message_start, :message_delta)
 
-    case block[:type] || block["type"]
-    when "text"
-      TextContent.new(block)
-    when "reasoning"
-      ReasoningContent.new(block)
-    when "thinking"
-      ReasoningContent.new(type: "reasoning", reasoning: block[:thinking] || block["thinking"] || block[:reasoning] || block["reasoning"], signature: block[:signature] || block["signature"])
-    when "tool_use"
-      ToolCall.new(block)
-    else
-      raise ArgumentError, "Unsupported content block type: #{block[:type] || block['type']}"
-    end
-  end
+  attribute :type, EventType
+  attribute :delta, Types::Coercible::Hash.default { {} }
+  attribute :usage, Types::Coercible::Hash.default { {} }
+  attribute :partial, Types.Instance(PartialAssistantMessage)
+end
 
-  private_class_method :build_content_block
+class AssistantStreamMessageEndEvent < BaseStruct
+  attribute :type, Types::Coercible::Symbol.enum(:message_end)
+  attribute :message, Types.Instance(AssistantMessage)
 end

data/lib/llm_gateway/base_client.rb

@@ -6,11 +6,9 @@ require "json"
 
 module LlmGateway
   class BaseClient
-    attr_accessor
-    attr_reader :api_key, :model_key, :base_endpoint
+    attr_reader :api_key, :base_endpoint
 
-    def initialize(model_key:, api_key:)
-      @model_key = model_key
+    def initialize(api_key:)
       @api_key = api_key
     end
 

data/lib/llm_gateway/client.rb

@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 
+
 module LlmGateway
   class Client
-    def self.chat(model, message, tools: nil, system: nil, api_key: nil, refresh_token: nil, expires_at: nil, **options)
-      adapter = build_adapter_from_model(model, api_key: api_key, refresh_token: refresh_token, expires_at: expires_at)
-      adapter.chat(message, tools: tools, system: system, **options)
-    end
-
-    def self.responses(model, message, tools: nil, system: nil, api_key: nil, **options)
-      adapter = build_adapter_from_model(model, api_key: api_key, api: "responses")
-      adapter.chat(message, tools: tools, system: system, **options)
-    end
-
-    def self.build_client(provider, api_key:, model: "none")
-      adapter = LlmGateway.build_provider(
-        provider: provider,
-        api_key: api_key,
-        model_key: model
-      )
-      adapter.client
+    def self.provider_id_from_client(client)
+      case client
+      when LlmGateway::Clients::Anthropic
+        "anthropic"
+      when LlmGateway::Clients::OpenAI
+        "openai"
+      when LlmGateway::Clients::Groq
+        "groq"
+      end
     end
 
     def self.upload_file(provider, **kwargs)
@@ -38,54 +31,5 @@ module LlmGateway
       )
       adapter.download_file(**kwargs)
     end
-
-    def self.provider_from_model(model)
-      return "anthropic" if model.start_with?("claude")
-      return "groq" if model.start_with?("llama")
-      return "openai" if model.start_with?("gpt") ||
-                         model.start_with?("o4-") ||
-                         model.start_with?("openai")
-
-      raise LlmGateway::Errors::UnsupportedModel, model
-    end
-
-    def self.provider_id_from_client(client)
-      case client
-      when LlmGateway::Clients::Anthropic
-        "anthropic"
-      when LlmGateway::Clients::OpenAI
-        "openai"
-      when LlmGateway::Clients::Groq
-        "groq"
-      else
-        client.class.name.downcase
-      end
-    end
-
-    # --- private helpers ---
-
-    def self.build_adapter_from_model(model, api_key: nil, refresh_token: nil, expires_at: nil, api: nil)
-      provider = provider_from_model(model)
-
-      if api == "responses"
-        config = {
-          provider: "#{provider}_responses",
-          model_key: model
-        }
-        config[:api_key] = api_key if api_key
-        LlmGateway.build_provider(config)
-      else
-        provider_key = case provider
-        when "anthropic" then "anthropic_messages"
-        when "openai" then "openai_completions"
-        when "groq" then "groq_completions"
-        end
-        config = { provider: provider_key, model_key: model }
-        config[:api_key] = api_key if api_key
-        LlmGateway.build_provider(config)
-      end
-    end
-
-    private_class_method :build_adapter_from_model
   end
 end

data/lib/llm_gateway/clients/anthropic.rb

@@ -9,10 +9,11 @@ module LlmGateway
   module Clients
     class Anthropic < BaseClient
       CLAUDE_CODE_VERSION = "2.1.2"
+      DEFAULT_MODEL = "claude-3-7-sonnet-20250219"
 
-      def initialize(model_key: "claude-3-7-sonnet-20250219", api_key: ENV["ANTHROPIC_API_KEY"])
+      def initialize(api_key: ENV["ANTHROPIC_API_KEY"])
         @base_endpoint = "https://api.anthropic.com/v1"
-        super(model_key: model_key, api_key: api_key)
+        super(api_key: api_key)
       end
 
       def chat(messages, **kwargs)
@@ -44,11 +45,11 @@ module LlmGateway
 
       private
 
-      def build_body(messages, tools: nil, system: [], cache_retention: nil, **options)
+      def build_body(messages, tools: nil, system: [], cache_retention: nil, model: DEFAULT_MODEL, **options)
         cache_control = anthropic_cache_control_for(cache_retention)
 
         body = {
-          model: model_key,
+          model: model,
           messages: messages
         }
 

data/lib/llm_gateway/clients/groq.rb

@@ -5,14 +5,16 @@ require_relative "../base_client"
 module LlmGateway
   module Clients
     class Groq < BaseClient
-      def initialize(model_key: "openai/gpt-oss-20b", api_key: ENV["GROQ_API_KEY"])
+      DEFAULT_MODEL = "openai/gpt-oss-120b"
+
+      def initialize(api_key: ENV["GROQ_API_KEY"])
         @base_endpoint = "https://api.groq.com/openai/v1"
-        super(model_key: model_key, api_key: api_key)
+        super(api_key: api_key)
       end
 
-      def chat(messages, tools: nil, system: [], **options)
+      def chat(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options)
         body = {
-          model: model_key,
+          model: model,
           messages: system + messages,
           tools: tools
         }
@@ -21,6 +23,18 @@ module LlmGateway
         post("chat/completions", body)
       end
 
+      def stream(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options, &block)
+        body = {
+          model: model,
+          messages: system + messages,
+          tools: tools,
+          stream_options: { include_usage: true }
+        }
+        body.merge!(options)
+
+        post_stream("chat/completions", body, &block)
+      end
+
       private
 
       def build_headers

data/lib/llm_gateway/clients/openai.rb

@@ -6,18 +6,20 @@ module LlmGateway
   module Clients
     class OpenAI < BaseClient
       CODEX_BASE_ENDPOINT = "https://chatgpt.com/backend-api/codex"
+      DEFAULT_MODEL = "gpt-4o"
+      DEFAULT_EMBEDDINGS_MODEL = "text-embedding-3-small"
 
       attr_reader :account_id
 
-      def initialize(model_key: "gpt-4o", api_key: ENV["OPENAI_API_KEY"], account_id: nil)
+      def initialize(api_key: ENV["OPENAI_API_KEY"], account_id: nil)
         @base_endpoint = "https://api.openai.com/v1"
         @account_id = account_id
-        super(model_key: model_key, api_key: api_key)
+        super(api_key: api_key)
       end
 
-      def chat(messages, tools: nil, system: [], **options)
+      def chat(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options)
         body = {
-          model: model_key,
+          model: model,
           messages: system + messages
         }
         body[:tools] = tools if tools
@@ -26,9 +28,9 @@ module LlmGateway
         post("chat/completions", body)
       end
 
-      def stream(messages, tools: nil, system: [], **options, &block)
+      def stream(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options, &block)
         body = {
-          model: model_key,
+          model: model,
           messages: system + messages
         }
         body[:tools] = tools if tools
@@ -38,9 +40,9 @@ module LlmGateway
         post_stream("chat/completions", body, &block)
       end
 
-      def responses(messages, tools: nil, system: [], **options)
+      def responses(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options)
         body = {
-          model: model_key,
+          model: model,
           input: messages.flatten
         }
         body[:instructions] = system[0][:content] if system.any?
@@ -50,9 +52,9 @@ module LlmGateway
         post("responses", body)
       end
 
-      def stream_responses(messages, tools: nil, system: [], **options, &block)
+      def stream_responses(messages, tools: nil, system: [], model: DEFAULT_MODEL, **options, &block)
         body = {
-          model: model_key,
+          model: model,
           input: messages.flatten
         }
         body[:instructions] = system[0][:content] if system.any?
@@ -74,8 +76,8 @@ module LlmGateway
         token_manager.access_token
       end
 
-      def chat_codex(messages, tools: nil, system: [], account_id: nil, **options)
-        body = build_codex_body(messages, system, tools, **options)
+      def chat_codex(messages, tools: nil, system: [], account_id: nil, model: DEFAULT_MODEL, **options)
+        body = build_codex_body(messages, system, tools, model: model, **options)
 
         completed_response = nil
         post_codex_stream("responses", body, account_id: account_id) do |raw_sse|
@@ -87,8 +89,8 @@ module LlmGateway
         completed_response
       end
 
-      def stream_codex(messages, tools: nil, system: [], account_id: nil, **options, &block)
-        body = build_codex_body(messages, system, tools, **options)
+      def stream_codex(messages, tools: nil, system: [], account_id: nil, model: DEFAULT_MODEL, **options, &block)
+        body = build_codex_body(messages, system, tools, model: model, **options)
         post_codex_stream("responses", body, account_id: account_id, &block)
       end
 
@@ -96,10 +98,10 @@ module LlmGateway
         get("files/#{file_id}/content")
       end
 
-      def generate_embeddings(input)
+      def generate_embeddings(input, model: DEFAULT_EMBEDDINGS_MODEL)
         body = {
           input:,
-          model: model_key
+          model: model
         }
         post("embeddings", body)
       end
@@ -110,12 +112,12 @@ module LlmGateway
 
       private
 
-      def build_codex_body(messages, system, tools, **options)
+      def build_codex_body(messages, system, tools, model:, **options)
         instructions = Array(system).filter_map { |s| s.is_a?(Hash) ? s[:content] : s }.join("\n")
         instructions = "You are a helpful assistant." if instructions.empty?
 
         body = {
-          model: model_key,
+          model: model,
           instructions: instructions,
           input: messages,
           store: false,

data/lib/llm_gateway/prompt.rb

@@ -2,7 +2,29 @@
 
 module LlmGateway
   class Prompt
-    attr_reader :model
+    UNSET = Object.new.freeze
+
+    attr_reader :provider, :model
+
+    class << self
+      def provider(value = UNSET)
+        @provider = value unless value.equal?(UNSET)
+        @provider
+      end
+
+      def provider=(value)
+        @provider = value
+      end
+
+      def model(value = UNSET)
+        @model = value unless value.equal?(UNSET)
+        @model
+      end
+
+      def model=(value)
+        @model = value
+      end
+    end
 
     def self.before_execute(*methods, &block)
       before_execute_callbacks.concat(methods)
@@ -26,23 +48,19 @@ module LlmGateway
       super
       subclass.instance_variable_set(:@before_execute_callbacks, before_execute_callbacks.dup)
       subclass.instance_variable_set(:@after_execute_callbacks, after_execute_callbacks.dup)
+      subclass.provider = provider
+      subclass.model = model
     end
 
-    def initialize(model)
-      @model = model
-      @connection = if model.is_a?(String)
-        LlmGateway.configured_clients.values.find do |client|
-          client.client.model_key == model
-        end
-      else
-        model
-      end
+    def initialize(provider = nil, model = nil)
+      @provider = provider || self.class.provider
+      @model = model || self.class.model
     end
 
     def run
       run_callbacks(:before_execute, prompt)
 
-      response = post
+      response = stream
 
       response_content = if respond_to?(:extract_response)
         extract_response(response)
@@ -61,12 +79,12 @@ module LlmGateway
       result
     end
 
-    def post
-      if @connection
-        @connection.chat(prompt, tools: tools, system: system_prompt)
-      else
-        LlmGateway::Client.chat(model, prompt, tools: tools, system: system_prompt)
-      end
+    def stream(provider: nil, model: nil, **options)
+      stream_provider = provider || self.provider
+      stream_model = model || self.model
+      options[:model] = stream_model if stream_model
+
+      stream_provider.stream(prompt, tools: tools, system: system_prompt, **options)
     end
 
     def tools

data/lib/llm_gateway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmGateway
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/llm_gateway.rb

@@ -21,17 +21,17 @@ require_relative "llm_gateway/clients/groq"
 require_relative "llm_gateway/adapters/option_mapper"
 require_relative "llm_gateway/adapters/anthropic_option_mapper"
 require_relative "llm_gateway/adapters/structs"
+require_relative "llm_gateway/adapters/stream_mapper"
 
 require_relative "llm_gateway/adapters/anthropic/input_mapper"
 require_relative "llm_gateway/adapters/anthropic/output_mapper"
 require_relative "llm_gateway/adapters/openai/file_output_mapper"
 require_relative "llm_gateway/adapters/openai/prompt_cache_option_mapper"
 require_relative "llm_gateway/adapters/openai/chat_completions/input_mapper"
-require_relative "llm_gateway/adapters/openai/chat_completions/output_mapper"
 require_relative "llm_gateway/adapters/openai/chat_completions/option_mapper"
+require_relative "llm_gateway/adapters/openai/chat_completions/stream_mapper"
 require_relative "llm_gateway/adapters/openai/file_output_mapper"
 require_relative "llm_gateway/adapters/openai/responses/input_mapper"
-require_relative "llm_gateway/adapters/openai/responses/output_mapper"
 require_relative "llm_gateway/adapters/openai/responses/option_mapper"
 
 # Load adapter classes
@@ -48,10 +48,6 @@ require_relative "llm_gateway/provider_registry"
 module LlmGateway
   class Error < StandardError; end
 
-  # Direction constants for message mappers
-  DIRECTION_IN = :in
-  DIRECTION_OUT = :out
-
   # Backward-compatible aliases for renamed clients/adapters
   module Clients
     Claude = Anthropic
@@ -63,9 +59,7 @@ module LlmGateway
       Client = LlmGateway::Clients::Anthropic
       MessagesAdapter = LlmGateway::Adapters::Anthropic::MessagesAdapter
       InputMapper = LlmGateway::Adapters::Anthropic::InputMapper
-      OutputMapper = LlmGateway::Adapters::Anthropic::OutputMapper
       StreamMapper = LlmGateway::Adapters::Anthropic::StreamMapper
-      BidirectionalMessageMapper = LlmGateway::Adapters::Anthropic::BidirectionalMessageMapper
       FileOutputMapper = LlmGateway::Adapters::Anthropic::FileOutputMapper
     end
 
@@ -106,6 +100,9 @@ module LlmGateway
   def self.build_provider(config)
     config = config.transform_keys(&:to_sym)
     provider_name = config.delete(:provider)
+    if config.key?(:model_key)
+      raise ArgumentError, "model_key is no longer a provider option; pass model: to chat/stream instead"
+    end
     entry = ProviderRegistry.resolve(provider_name)
 
     client = entry[:client].new(**config)
@@ -159,25 +156,4 @@ module LlmGateway
   ProviderRegistry.register("openai_codex",
     client: Clients::OpenAI,
     adapter: Adapters::OpenAICodex::ResponsesAdapter)
-
-  # Backward-compatible aliases (deprecated)
-  ProviderRegistry.register("anthropic_apikey_messages",
-    client: Clients::Anthropic,
-    adapter: Adapters::Anthropic::MessagesAdapter)
-
-  ProviderRegistry.register("openai_apikey_completions",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAI::ChatCompletionsAdapter)
-
-  ProviderRegistry.register("openai_apikey_responses",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAI::ResponsesAdapter)
-
-  ProviderRegistry.register("groq_apikey_completions",
-    client: Clients::Groq,
-    adapter: Adapters::Groq::ChatCompletionsAdapter)
-
-  ProviderRegistry.register("openai_oauth_codex",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAICodex::ResponsesAdapter)
 end