openrouter_client 0.1.0

data/rbi/openrouter/completion.rbi

@@ -0,0 +1,152 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Completion
+    COMPLETIONS_PATH = T.let(T.unsafe(nil), String)
+
+    module Role
+      SYSTEM = T.let(T.unsafe(nil), String)
+      USER = T.let(T.unsafe(nil), String)
+      ASSISTANT = T.let(T.unsafe(nil), String)
+      TOOL = T.let(T.unsafe(nil), String)
+    end
+
+    module FinishReason
+      STOP = T.let(T.unsafe(nil), String)
+      LENGTH = T.let(T.unsafe(nil), String)
+      TOOL_CALLS = T.let(T.unsafe(nil), String)
+      CONTENT_FILTER = T.let(T.unsafe(nil), String)
+      ERROR = T.let(T.unsafe(nil), String)
+    end
+
+    sig { returns(String) }
+    def id; end
+
+    sig { returns(String) }
+    def model; end
+
+    sig { returns(Integer) }
+    def created; end
+
+    sig { returns(String) }
+    def object; end
+
+    sig { returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+    def choices; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def usage; end
+
+    sig { returns(T.nilable(String)) }
+    def system_fingerprint; end
+
+    sig { params(attributes: T.untyped, client: OpenRouter::Client).void }
+    def initialize(attributes, client: OpenRouter.client); end
+
+    class << self
+      sig do
+        params(
+          messages: T::Array[T::Hash[T.untyped, T.untyped]],
+          model: T.nilable(String),
+          temperature: T.nilable(Float),
+          max_tokens: T.nilable(Integer),
+          top_p: T.nilable(Float),
+          top_k: T.nilable(Integer),
+          frequency_penalty: T.nilable(Float),
+          presence_penalty: T.nilable(Float),
+          repetition_penalty: T.nilable(Float),
+          stop: T.nilable(T.any(String, T::Array[String])),
+          seed: T.nilable(Integer),
+          tools: T.nilable(T::Array[T::Hash[T.untyped, T.untyped]]),
+          tool_choice: T.nilable(T.any(String, T::Hash[T.untyped, T.untyped])),
+          response_format: T.nilable(T::Hash[T.untyped, T.untyped]),
+          transforms: T.nilable(T::Array[String]),
+          models: T.nilable(T::Array[String]),
+          route: T.nilable(String),
+          provider: T.nilable(T::Hash[T.untyped, T.untyped]),
+          client: OpenRouter::Client,
+          options: T.untyped
+        ).returns(OpenRouter::Completion)
+      end
+      def create!(messages:, model: nil, temperature: nil, max_tokens: nil, top_p: nil,
+                  top_k: nil, frequency_penalty: nil, presence_penalty: nil, repetition_penalty: nil,
+                  stop: nil, seed: nil, tools: nil, tool_choice: nil, response_format: nil,
+                  transforms: nil, models: nil, route: nil, provider: nil, client: OpenRouter.client, **options); end
+
+      sig do
+        params(
+          messages: T::Array[T::Hash[T.untyped, T.untyped]],
+          model: T.nilable(String),
+          temperature: T.nilable(Float),
+          max_tokens: T.nilable(Integer),
+          top_p: T.nilable(Float),
+          top_k: T.nilable(Integer),
+          frequency_penalty: T.nilable(Float),
+          presence_penalty: T.nilable(Float),
+          repetition_penalty: T.nilable(Float),
+          stop: T.nilable(T.any(String, T::Array[String])),
+          seed: T.nilable(Integer),
+          tools: T.nilable(T::Array[T::Hash[T.untyped, T.untyped]]),
+          tool_choice: T.nilable(T.any(String, T::Hash[T.untyped, T.untyped])),
+          response_format: T.nilable(T::Hash[T.untyped, T.untyped]),
+          transforms: T.nilable(T::Array[String]),
+          models: T.nilable(T::Array[String]),
+          route: T.nilable(String),
+          provider: T.nilable(T::Hash[T.untyped, T.untyped]),
+          client: OpenRouter::Client,
+          options: T.untyped,
+          block: T.nilable(T.proc.params(arg0: T::Hash[T.untyped, T.untyped]).void)
+        ).returns(OpenRouter::Completion)
+      end
+      def stream!(messages:, model: nil, temperature: nil, max_tokens: nil, top_p: nil,
+                  top_k: nil, frequency_penalty: nil, presence_penalty: nil, repetition_penalty: nil,
+                  stop: nil, seed: nil, tools: nil, tool_choice: nil, response_format: nil,
+                  transforms: nil, models: nil, route: nil, provider: nil, client: OpenRouter.client, **options, &block); end
+    end
+
+    sig { returns(T.nilable(String)) }
+    def content; end
+
+    sig { returns(T.nilable(String)) }
+    def role; end
+
+    sig { returns(T.nilable(String)) }
+    def finish_reason; end
+
+    sig { returns(T.nilable(T::Array[T::Hash[T.untyped, T.untyped]])) }
+    def tool_calls; end
+
+    sig { returns(T.nilable(T::Array[T::Hash[T.untyped, T.untyped]])) }
+    def images; end
+
+    sig { returns(T::Boolean) }
+    def images?; end
+
+    sig { returns(T.nilable(Integer)) }
+    def prompt_tokens; end
+
+    sig { returns(T.nilable(Integer)) }
+    def completion_tokens; end
+
+    sig { returns(T.nilable(Integer)) }
+    def total_tokens; end
+
+    sig { returns(T::Boolean) }
+    def stopped?; end
+
+    sig { returns(T::Boolean) }
+    def truncated?; end
+
+    sig { returns(T::Boolean) }
+    def tool_calls?; end
+
+    sig { returns(T::Boolean) }
+    def has_tool_calls?; end
+
+    private
+
+    sig { params(attributes: T.untyped).void }
+    def reset_attributes(attributes); end
+  end
+end

data/rbi/openrouter/credit.rbi

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Credit
+    CREDITS_PATH = T.let(T.unsafe(nil), String)
+
+    sig { returns(T.nilable(Float)) }
+    def total_credits; end
+
+    sig { returns(Float) }
+    def total_usage; end
+
+    sig { returns(Float) }
+    def remaining; end
+
+    sig { params(attributes: T.untyped, client: OpenRouter::Client).void }
+    def initialize(attributes, client: OpenRouter.client); end
+
+    class << self
+      sig { params(client: OpenRouter::Client).returns(OpenRouter::Credit) }
+      def fetch(client: OpenRouter.client); end
+
+      sig { params(client: OpenRouter::Client).returns(Float) }
+      def remaining(client: OpenRouter.client); end
+    end
+
+    sig { returns(T::Boolean) }
+    def low?; end
+
+    sig { returns(T::Boolean) }
+    def exhausted?; end
+
+    sig { returns(T.nilable(Float)) }
+    def usage_percentage; end
+
+    private
+
+    sig { params(attributes: T.untyped).void }
+    def reset_attributes(attributes); end
+  end
+end

data/rbi/openrouter/generation.rbi

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Generation
+    GENERATION_PATH = T.let(T.unsafe(nil), String)
+
+    sig { returns(String) }
+    def id; end
+
+    sig { returns(T.nilable(String)) }
+    def model; end
+
+    sig { returns(T.nilable(Integer)) }
+    def total_time; end
+
+    sig { returns(T.nilable(Integer)) }
+    def time_to_first_token; end
+
+    sig { returns(T.nilable(Integer)) }
+    def native_prompt_tokens; end
+
+    sig { returns(T.nilable(Integer)) }
+    def native_completion_tokens; end
+
+    sig { returns(T.nilable(Integer)) }
+    def native_total_tokens; end
+
+    sig { returns(T.nilable(Float)) }
+    def total_cost; end
+
+    sig { returns(T.nilable(String)) }
+    def provider; end
+
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def raw; end
+
+    sig { params(attributes: T.untyped, client: OpenRouter::Client).void }
+    def initialize(attributes, client: OpenRouter.client); end
+
+    class << self
+      sig { params(id: String, client: OpenRouter::Client).returns(T.nilable(OpenRouter::Generation)) }
+      def find_by(id:, client: OpenRouter.client); end
+    end
+
+    sig { returns(T.nilable(Float)) }
+    def prompt_cost; end
+
+    sig { returns(T.nilable(Float)) }
+    def completion_cost; end
+
+    sig { returns(T.nilable(Float)) }
+    def tokens_per_second; end
+
+    sig { returns(T::Boolean) }
+    def complete?; end
+
+    sig { returns(T::Boolean) }
+    def failed?; end
+
+    private
+
+    sig { params(attributes: T.untyped).void }
+    def reset_attributes(attributes); end
+  end
+end

data/rbi/openrouter/model.rbi

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Model
+    MODELS_PATH = T.let(T.unsafe(nil), String)
+
+    sig { returns(String) }
+    def id; end
+
+    sig { returns(T.nilable(String)) }
+    def name; end
+
+    sig { returns(T.nilable(String)) }
+    def description; end
+
+    sig { returns(T.nilable(Integer)) }
+    def context_length; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def pricing; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def top_provider; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def architecture; end
+
+    sig { returns(T.nilable(T::Array[String])) }
+    def supported_parameters; end
+
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    def per_request_limits; end
+
+    sig { returns(T.nilable(String)) }
+    def created; end
+
+    sig { params(attributes: T.untyped, client: OpenRouter::Client).void }
+    def initialize(attributes, client: OpenRouter.client); end
+
+    sig { returns(T.nilable(Float)) }
+    def input_price; end
+
+    sig { returns(T.nilable(Float)) }
+    def output_price; end
+
+    sig { returns(T.nilable(Float)) }
+    def image_price; end
+
+    sig { returns(T::Boolean) }
+    def free?; end
+
+    sig { params(messages: T::Array[T::Hash[T.untyped, T.untyped]], options: T.untyped).returns(OpenRouter::Completion) }
+    def complete(messages:, **options); end
+
+    class << self
+      sig { params(id: String, client: OpenRouter::Client).returns(OpenRouter::Model) }
+      def find(id, client: OpenRouter.client); end
+
+      sig { params(id: String, client: OpenRouter::Client).returns(T.nilable(OpenRouter::Model)) }
+      def find_by(id:, client: OpenRouter.client); end
+
+      sig { params(id: String, client: OpenRouter::Client).returns(OpenRouter::Model) }
+      def find_by!(id:, client: OpenRouter.client); end
+
+      sig do
+        params(
+          client: OpenRouter::Client,
+          block: T.proc.params(arg0: OpenRouter::Model).void
+        ).void
+      end
+      def each(client: OpenRouter.client, &block); end
+
+      sig { params(client: OpenRouter::Client).returns(T::Array[OpenRouter::Model]) }
+      def all(client: OpenRouter.client); end
+
+      sig { params(query: String, client: OpenRouter::Client).returns(T::Array[OpenRouter::Model]) }
+      def search(query:, client: OpenRouter.client); end
+
+      sig { params(provider: String, client: OpenRouter::Client).returns(T::Array[OpenRouter::Model]) }
+      def by_provider(provider:, client: OpenRouter.client); end
+
+      sig { params(client: OpenRouter::Client).returns(T::Array[OpenRouter::Model]) }
+      def free(client: OpenRouter.client); end
+    end
+
+    private
+
+    sig { params(attributes: T.untyped).void }
+    def reset_attributes(attributes); end
+  end
+end

data/rbi/openrouter/openrouter.rbi

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Error < StandardError; end
+  class UnauthorizedError < Error; end
+  class NotFoundError < Error; end
+  class ServerError < Error; end
+  class ConfigurationError < Error; end
+  class ForbiddenError < Error; end
+  class RateLimitError < Error; end
+  class BadRequestError < Error; end
+  class PaymentRequiredError < Error; end
+
+  class Configuration
+    DEFAULT_API_BASE = T.let(T.unsafe(nil), String)
+    DEFAULT_REQUEST_TIMEOUT = T.let(T.unsafe(nil), Integer)
+
+    # api_key
+    sig { returns(T.nilable(String)) }
+    def api_key; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def api_key=(value); end
+
+    # api_base
+    sig { returns(String) }
+    def api_base; end
+
+    sig { params(value: String).returns(String) }
+    def api_base=(value); end
+
+    # request_timeout
+    sig { returns(Integer) }
+    def request_timeout; end
+
+    sig { params(value: Integer).returns(Integer) }
+    def request_timeout=(value); end
+
+    # site_url
+    sig { returns(T.nilable(String)) }
+    def site_url; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def site_url=(value); end
+
+    # site_name
+    sig { returns(T.nilable(String)) }
+    def site_name; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def site_name=(value); end
+
+    sig { void }
+    def initialize; end
+  end
+
+  class << self
+    sig { returns(OpenRouter::Configuration) }
+    def configuration; end
+
+    sig { params(value: OpenRouter::Configuration).returns(OpenRouter::Configuration) }
+    def configuration=(value); end
+
+    sig { params(block: T.proc.params(arg0: OpenRouter::Configuration).void).void }
+    def configure(&block); end
+
+    sig { returns(OpenRouter::Client) }
+    def client; end
+
+    sig { void }
+    def reset_client!; end
+
+    sig { params(object: T.untyped).returns(T.untyped) }
+    def deep_symbolize_keys(object); end
+  end
+end

data/rbi/openrouter/stream.rbi

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  class Stream
+    sig { returns(String) }
+    def path; end
+
+    sig do
+      params(
+        path: String,
+        input: T.untyped,
+        client: OpenRouter::Client
+      ).void
+    end
+    def initialize(path:, input:, client: OpenRouter.client); end
+
+    sig do
+      params(block: T.proc.params(arg0: T::Hash[T.untyped, T.untyped]).void).void
+    end
+    def each(&block); end
+
+    class SSEDecoder
+      sig { void }
+      def initialize; end
+
+      sig { params(line: String).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+      def decode(line); end
+
+      private
+
+      sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+      def flush_event; end
+
+      sig { returns(NilClass) }
+      def reset_state; end
+    end
+  end
+end

data/rbi/openrouter/version.rbi

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenRouter
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir=rbi/
+--ignore=test/

data/sorbet/rbi/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: openrouter_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Player
+bindir: exe
+cert_chain: []
+date: 2026-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A comprehensive Ruby client for the OpenRouter API, providing access
+  to hundreds of AI models through a unified interface.
+email:
+- dylan@851.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.example"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/openrouter.rb
+- lib/openrouter/api_key.rb
+- lib/openrouter/client.rb
+- lib/openrouter/completion.rb
+- lib/openrouter/credit.rb
+- lib/openrouter/generation.rb
+- lib/openrouter/model.rb
+- lib/openrouter/stream.rb
+- lib/openrouter/version.rb
+- openrouter_client.gemspec
+- rbi/openrouter/api_key.rbi
+- rbi/openrouter/client.rbi
+- rbi/openrouter/completion.rbi
+- rbi/openrouter/credit.rbi
+- rbi/openrouter/generation.rbi
+- rbi/openrouter/model.rbi
+- rbi/openrouter/openrouter.rbi
+- rbi/openrouter/stream.rbi
+- rbi/openrouter/version.rbi
+- sorbet/config
+- sorbet/rbi/.gitignore
+homepage: https://github.com/851-labs/openrouter_client
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/851-labs/openrouter_client
+  source_code_uri: https://github.com/851-labs/openrouter_client
+  changelog_uri: https://github.com/851-labs/openrouter_client/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Ruby client for OpenRouter API.
+test_files: []