llmshim 0.1.24

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ee5f94ef389e23139fc944ee4c2a4d378936629e4f3bc7cb3487308f2fd07e3
+  data.tar.gz: 4478f78641ed1a4104f3659524ee8da1eb1e028a68774d760b5830e1209d7d94
+SHA512:
+  metadata.gz: e8da5ef6535d958c9e3008f1ab4b4d5d51cbd92d3984bf520d2b1a6376a0700588fc3110372e10716fd7a4c5bd81bf0f36d9a30837cc515f16d6c12c03e1d18d
+  data.tar.gz: 7a69fda0d58fefecf63df339895cd0e277377639cd74088feaf1af674165e5448f85574ea5ebd65d6cfeb1f549de17903d4b36d734e81200638629ffb0f2789d

data/README.md

@@ -0,0 +1,189 @@
+# llmshim (Ruby client)
+
+A thin, dependency-free Ruby client for the [llmshim](https://github.com/sanjay920/llmshim)
+multi-provider LLM proxy. Send OpenAI-style chat requests to a running llmshim
+proxy and let it translate to OpenAI, Anthropic, Google Gemini, or xAI.
+
+This gem talks to a proxy over plain HTTP — it does **not** spawn the Rust
+binary. Start the proxy separately (`llmshim proxy`, default `http://localhost:3000`).
+
+- Standard library only (`net/http`, `json`, `uri`) — no runtime gem dependencies.
+- Non-streaming and SSE streaming chat, model listing, health check.
+- Typed responses and a typed `Llmshim::APIError`.
+
+## Install
+
+From RubyGems (once published):
+
+```bash
+gem install llmshim
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem "llmshim"
+```
+
+Or build locally from this directory:
+
+```bash
+gem build llmshim.gemspec
+gem install ./llmshim-*.gem
+```
+
+## Prerequisite: run the proxy
+
+```bash
+llmshim proxy            # listens on 0.0.0.0:3000 by default
+```
+
+Configure provider API keys for the proxy via `llmshim configure` or the
+`OPENAI_API_KEY` / `ANTHROPIC_API_KEY` / `GEMINI_API_KEY` / `XAI_API_KEY`
+environment variables. The Ruby client never sees your keys — the proxy holds them.
+
+## Quickstart
+
+```ruby
+require "llmshim"
+
+client = Llmshim::Client.new(base_url: "http://localhost:3000")
+
+resp = client.chat(model: "claude-sonnet-4-6", messages: "What is Rust?")
+puts resp.content                 # => "Rust is a systems programming language..."
+puts resp.provider                # => "anthropic"
+puts resp.usage.total_tokens
+```
+
+`messages:` accepts a single string (treated as one user message) or an array
+of message hashes:
+
+```ruby
+resp = client.chat(
+  model: "openai/gpt-5.5",
+  messages: [
+    { role: "system", content: "You are a pirate." },
+    { role: "user",   content: "Hello!" }
+  ],
+  max_tokens: 500,
+  temperature: 0.7,
+  reasoning_effort: "high"
+)
+```
+
+### Module-level convenience
+
+A shared default client (base URL from `LLMSHIM_BASE_URL`, else `http://localhost:3000`):
+
+```ruby
+require "llmshim"
+
+resp = Llmshim.chat(model: "gpt-5.5", messages: "Explain quicksort")
+puts resp.content
+```
+
+## Streaming
+
+`stream` yields a `Llmshim::StreamEvent` for each SSE event and stops after the
+`done` event. Event types: `content`, `reasoning`, `tool_call`, `usage`,
+`done`, `error`.
+
+```ruby
+client.stream(model: "claude-sonnet-4-6", messages: "Write a haiku") do |event|
+  case event.type
+  when "reasoning" then print event.text   # thinking tokens
+  when "content"   then print event.text   # answer tokens
+  when "tool_call" then puts "\n[tool] #{event.name}(#{event.arguments})"
+  when "usage"     then puts "\ntokens: #{event.usage.total_tokens}"
+  when "error"     then warn "error: #{event.message}"
+  end
+end
+```
+
+Predicate helpers are available too: `event.content?`, `event.reasoning?`,
+`event.tool_call?`, `event.usage?`, `event.done?`, `event.error?`.
+
+Called without a block, `stream` returns the collected array of events:
+
+```ruby
+events = client.stream(model: "gpt-5.5", messages: "Hi")
+text = events.select(&:content?).map(&:text).join
+```
+
+## Tools, provider passthrough, and fallback
+
+```ruby
+resp = client.chat(
+  model: "anthropic/claude-sonnet-4-6",
+  messages: "What's the weather in SF?",
+  tools: [
+    { type: "function",
+      function: { name: "get_weather",
+                  parameters: { type: "object",
+                                properties: { city: { type: "string" } } } } }
+  ],
+  tool_choice: "auto",
+  # Raw provider-specific JSON merged into the underlying request:
+  provider_config: { thinking: { type: "adaptive" } },
+  # Try these models if the primary fails with a retryable error:
+  fallback: ["openai/gpt-5.5", "gemini/gemini-3-flash-preview"]
+)
+
+resp.message.tool_calls.each do |tc|
+  puts "#{tc.name} -> #{tc.arguments}"
+end
+```
+
+`tools` and `tool_choice` are folded into `provider_config` (passed straight
+through to the provider). `max_tokens`, `temperature`, `top_p`, `top_k`,
+`stop`, and `reasoning_effort` are folded into the request `config`.
+
+## Models and health
+
+```ruby
+client.models.each { |m| puts "#{m.id} (#{m.provider})" }
+
+h = client.health
+puts h.status          # => "ok"
+puts h.providers       # => ["anthropic", "openai", ...]
+```
+
+## Error handling
+
+Any non-2xx response raises `Llmshim::APIError`, populated from the proxy's
+`ErrorResponse` body:
+
+```ruby
+begin
+  client.chat(model: "bogus/model", messages: "hi")
+rescue Llmshim::APIError => e
+  warn "#{e.status} #{e.code}: #{e.message}"
+end
+```
+
+`Llmshim::APIError` exposes `#status` (Integer), `#code` (String or nil),
+`#message`, and `#body` (raw response body).
+
+## Configuration
+
+`Llmshim::Client.new` options:
+
+| Option     | Default                  | Description                          |
+| ---------- | ------------------------ | ------------------------------------ |
+| `base_url` | `http://localhost:3000`  | Proxy base URL                       |
+| `headers`  | `{}`                     | Extra headers sent on every request  |
+| `timeout`  | `120`                    | Open/read timeout in seconds         |
+
+## Development
+
+```bash
+bundle install     # optional; only for dev tools
+rake test          # runs the mocked test suite (no network, no API keys)
+```
+
+Tests use a local WEBrick mock server returning canned JSON and SSE — they
+never contact a real provider and never require a running proxy.
+
+## License
+
+MIT

data/lib/llmshim/client.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "errors"
+require_relative "types"
+
+module Llmshim
+  # A thin, dependency-free HTTP client for a running llmshim proxy.
+  #
+  #   client = Llmshim::Client.new(base_url: "http://localhost:3000")
+  #   resp = client.chat(model: "claude-sonnet-4-6", messages: "Hello!")
+  #   puts resp.content
+  #
+  # All request/response shapes follow api/openapi.yaml. Only the Ruby
+  # standard library is used (net/http, json, uri).
+  class Client
+    DEFAULT_BASE_URL = "http://localhost:3000"
+    DEFAULT_TIMEOUT = 120
+
+    # Base URL of the proxy (without a trailing slash).
+    attr_reader :base_url
+    # Extra headers sent with every request (Hash).
+    attr_reader :headers
+    # Read/open timeout in seconds.
+    attr_reader :timeout
+
+    # @param base_url [String] proxy base URL (default http://localhost:3000)
+    # @param headers [Hash] extra headers merged into every request
+    # @param timeout [Numeric] read/open timeout in seconds
+    def initialize(base_url: DEFAULT_BASE_URL, headers: {}, timeout: DEFAULT_TIMEOUT)
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @headers = headers || {}
+      @timeout = timeout
+    end
+
+    # Send a non-streaming chat completion (POST /v1/chat).
+    #
+    # @param model [String] "provider/model" or a bare model name
+    # @param messages [String, Array<Hash>] a single user string or message hashes
+    # @param opts [Hash] see #build_body (max_tokens, temperature, top_p, top_k,
+    #   stop, reasoning_effort, config, provider_config, tools, tool_choice, fallback)
+    # @return [Llmshim::ChatResponse]
+    def chat(model:, messages:, **opts)
+      body = build_body(model, messages, opts)
+      hash = post_json("/v1/chat", body)
+      ChatResponse.from_hash(hash)
+    end
+
+    # Stream a chat completion (POST /v1/chat/stream).
+    #
+    # Yields a Llmshim::StreamEvent per SSE event. Iteration stops after a
+    # "done" event or on EOF. When no block is given, returns the collected
+    # array of events.
+    #
+    # @return [Array<Llmshim::StreamEvent>, nil]
+    def stream(model:, messages:, **opts)
+      body = build_body(model, messages, opts)
+      collected = block_given? ? nil : []
+      stream_sse("/v1/chat/stream", body) do |event|
+        if block_given?
+          yield event
+        else
+          collected << event
+        end
+      end
+      collected
+    end
+
+    # List available models (GET /v1/models).
+    #
+    # @return [Array<Llmshim::Model>]
+    def models
+      hash = get_json("/v1/models")
+      (hash["models"] || []).map { |m| Model.from_hash(m) }
+    end
+
+    # Health check (GET /health).
+    #
+    # @return [Llmshim::Health]
+    def health
+      Health.from_hash(get_json("/health"))
+    end
+
+    private
+
+    # Build the JSON request body from friendly keyword options.
+    #
+    # config-level opts (max_tokens, temperature, top_p, top_k, stop,
+    # reasoning_effort) are folded into +config+. tools / tool_choice are folded
+    # into +provider_config+ (the proxy passes them through to the provider).
+    def build_body(model, messages, opts)
+      msgs =
+        if messages.is_a?(String)
+          [{ "role" => "user", "content" => messages }]
+        else
+          messages
+        end
+
+      body = { "model" => model, "messages" => msgs }
+
+      config = stringify(opts[:config] || {})
+      %i[max_tokens temperature top_p top_k stop reasoning_effort].each do |key|
+        config[key.to_s] = opts[key] unless opts[key].nil?
+      end
+      body["config"] = config unless config.empty?
+
+      provider_config = stringify(opts[:provider_config] || {})
+      provider_config["tools"] = opts[:tools] unless opts[:tools].nil?
+      provider_config["tool_choice"] = opts[:tool_choice] unless opts[:tool_choice].nil?
+      body["provider_config"] = provider_config unless provider_config.empty?
+
+      body["fallback"] = opts[:fallback] unless opts[:fallback].nil?
+      body["stream"] = opts[:stream] unless opts[:stream].nil?
+
+      body
+    end
+
+    def stringify(hash)
+      hash.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v }
+    end
+
+    def get_json(path)
+      req = Net::HTTP::Get.new(uri_for(path))
+      apply_headers(req)
+      parse_json_response(perform(req))
+    end
+
+    def post_json(path, body)
+      req = Net::HTTP::Post.new(uri_for(path))
+      req["Content-Type"] = "application/json"
+      apply_headers(req)
+      req.body = JSON.generate(body)
+      parse_json_response(perform(req))
+    end
+
+    # Perform a streaming POST and yield typed StreamEvent objects.
+    def stream_sse(path, body)
+      uri = uri_for(path)
+      req = Net::HTTP::Post.new(uri)
+      req["Content-Type"] = "application/json"
+      req["Accept"] = "text/event-stream"
+      apply_headers(req)
+      req.body = JSON.generate(body)
+
+      with_http(uri) do |http|
+        http.request(req) do |res|
+          unless res.is_a?(Net::HTTPSuccess)
+            raise APIError.from_response(res.code.to_i, res.body)
+          end
+
+          # State carried across chunk boundaries. We read the full (finite)
+          # SSE body rather than aborting mid-stream — abandoning net/http's
+          # read_body leaves the socket in an inconsistent state. Once a "done"
+          # event is seen we simply stop forwarding further events.
+          state = { buffer: +"", event: nil, done: false }
+          res.read_body do |chunk|
+            next if state[:done]
+
+            state[:buffer] << chunk
+            while (idx = state[:buffer].index("\n"))
+              line = state[:buffer].slice!(0..idx).chomp
+              dispatch_sse_line(line, state) { |ev| yield ev }
+              break if state[:done]
+            end
+          end
+          # Flush any trailing line that arrived without a newline.
+          unless state[:done] || state[:buffer].empty?
+            dispatch_sse_line(state[:buffer].chomp, state) { |ev| yield ev }
+          end
+        end
+      end
+    end
+
+    # Process one SSE line, updating +state+ in place and yielding a
+    # StreamEvent for each complete data line until a "done" event is seen.
+    def dispatch_sse_line(line, state)
+      return if state[:done]
+      return if line.empty?
+      return if line.start_with?(":") # SSE comment / heartbeat
+
+      if line.start_with?("event:")
+        state[:event] = line.sub(/\Aevent:\s?/, "")
+      elsif line.start_with?("data:")
+        data = line.sub(/\Adata:\s?/, "")
+        return if data.empty?
+
+        parsed =
+          begin
+            JSON.parse(data)
+          rescue JSON::ParserError
+            {}
+          end
+        type = state[:event] || parsed["type"] || ""
+        event = StreamEvent.new(type, parsed)
+        yield event
+        state[:done] = true if event.done?
+      end
+    end
+
+    def uri_for(path)
+      URI.parse("#{@base_url}#{path}")
+    end
+
+    def apply_headers(req)
+      @headers.each { |k, v| req[k.to_s] = v }
+    end
+
+    def with_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+      http.start unless http.started?
+      begin
+        yield http
+      ensure
+        http.finish if http.started?
+      end
+    end
+
+    def perform(req)
+      uri = URI.parse("#{@base_url}#{req.path}")
+      with_http(uri) { |http| http.request(req) }
+    end
+
+    def parse_json_response(res)
+      unless res.is_a?(Net::HTTPSuccess)
+        raise APIError.from_response(res.code.to_i, res.body)
+      end
+
+      body = res.body.to_s
+      return {} if body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise Error, "Failed to parse response JSON: #{e.message}"
+    end
+  end
+end

data/lib/llmshim/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Llmshim
+  # Base class for all errors raised by this gem.
+  class Error < StandardError; end
+
+  # Raised when the proxy returns a non-2xx response.
+  #
+  # The proxy encodes errors as an +ErrorResponse+ object
+  # (+{ "error": { "code": ..., "message": ... } }+). When the body cannot
+  # be parsed, +code+ falls back to +nil+ and +message+ to the raw body.
+  class APIError < Error
+    # HTTP status code of the failed response (Integer).
+    attr_reader :status
+    # Machine-readable error code from the proxy (String or nil).
+    attr_reader :code
+    # Raw response body (String).
+    attr_reader :body
+
+    def initialize(message, status:, code: nil, body: nil)
+      @status = status
+      @code = code
+      @body = body
+      super(message)
+    end
+
+    # Build an APIError from an HTTP status and response body.
+    def self.from_response(status, body)
+      code = nil
+      message = nil
+      begin
+        parsed = JSON.parse(body.to_s)
+        err = parsed["error"]
+        if err.is_a?(Hash)
+          code = err["code"]
+          message = err["message"]
+        end
+      rescue JSON::ParserError
+        # fall through to raw body
+      end
+      message ||= (body.to_s.empty? ? "HTTP #{status}" : body.to_s)
+      new(message, status: status, code: code, body: body)
+    end
+  end
+end

data/lib/llmshim/types.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Llmshim
+  # Token accounting returned with a chat response or a usage stream event.
+  #
+  # Mirrors the +Usage+ schema in api/openapi.yaml.
+  Usage = Struct.new(
+    :input_tokens, :output_tokens, :reasoning_tokens, :total_tokens,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      new(
+        input_tokens: hash["input_tokens"],
+        output_tokens: hash["output_tokens"],
+        reasoning_tokens: hash["reasoning_tokens"],
+        total_tokens: hash["total_tokens"]
+      )
+    end
+  end
+
+  # A single tool call requested by the assistant.
+  #
+  # +function+ is a plain Hash with "name" and "arguments" (JSON-encoded string)
+  # to match the wire format exactly.
+  ToolCall = Struct.new(:id, :type, :function, keyword_init: true) do
+    def self.from_hash(hash)
+      new(id: hash["id"], type: hash["type"], function: hash["function"])
+    end
+
+    # Convenience accessor for the tool name.
+    def name
+      function && function["name"]
+    end
+
+    # Convenience accessor for the JSON-encoded arguments string.
+    def arguments
+      function && function["arguments"]
+    end
+  end
+
+  # The assistant message inside a ChatResponse.
+  ResponseMessage = Struct.new(:role, :content, :tool_calls, keyword_init: true) do
+    def self.from_hash(hash)
+      calls = (hash["tool_calls"] || []).map { |c| ToolCall.from_hash(c) }
+      new(role: hash["role"], content: hash["content"], tool_calls: calls)
+    end
+  end
+
+  # A non-streaming chat completion response (+ChatResponse+ schema).
+  #
+  # +raw+ retains the original parsed Hash for forward compatibility.
+  ChatResponse = Struct.new(
+    :id, :model, :provider, :message, :reasoning, :usage, :latency_ms, :raw,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        id: hash["id"],
+        model: hash["model"],
+        provider: hash["provider"],
+        message: ResponseMessage.from_hash(hash["message"] || {}),
+        reasoning: hash["reasoning"],
+        usage: Usage.from_hash(hash["usage"]),
+        latency_ms: hash["latency_ms"],
+        raw: hash
+      )
+    end
+
+    # Shortcut for the assistant text content.
+    def content
+      message&.content
+    end
+  end
+
+  # A single model entry from GET /v1/models.
+  Model = Struct.new(:id, :provider, :name, keyword_init: true) do
+    def self.from_hash(hash)
+      new(id: hash["id"], provider: hash["provider"], name: hash["name"])
+    end
+  end
+
+  # The GET /health response.
+  Health = Struct.new(:status, :providers, keyword_init: true) do
+    def self.from_hash(hash)
+      new(status: hash["status"], providers: hash["providers"] || [])
+    end
+  end
+
+  # A typed SSE event from POST /v1/chat/stream.
+  #
+  # +type+ is one of: "content", "reasoning", "tool_call", "usage", "done",
+  # "error". All variant fields are exposed through +raw+ and the helper
+  # accessors below; unknown fields remain reachable via +raw+.
+  class StreamEvent
+    # Event type string (String).
+    attr_reader :type
+    # Original parsed data Hash for this event.
+    attr_reader :raw
+
+    def initialize(type, raw)
+      @type = type
+      @raw = raw || {}
+    end
+
+    def content?
+      type == "content"
+    end
+
+    def reasoning?
+      type == "reasoning"
+    end
+
+    def tool_call?
+      type == "tool_call"
+    end
+
+    def usage?
+      type == "usage"
+    end
+
+    def done?
+      type == "done"
+    end
+
+    def error?
+      type == "error"
+    end
+
+    # content / reasoning events
+    def text
+      raw["text"]
+    end
+
+    # tool_call events
+    def id
+      raw["id"]
+    end
+
+    def name
+      raw["name"]
+    end
+
+    def arguments
+      raw["arguments"]
+    end
+
+    # usage events
+    def usage
+      return nil unless usage?
+
+      Usage.from_hash(raw)
+    end
+
+    # error events
+    def message
+      raw["message"]
+    end
+
+    def [](key)
+      raw[key.to_s]
+    end
+  end
+end

data/lib/llmshim/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Llmshim
+  VERSION = "0.1.24"
+end

data/lib/llmshim.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "llmshim/version"
+require_relative "llmshim/errors"
+require_relative "llmshim/types"
+require_relative "llmshim/client"
+
+# Ruby client for the llmshim multi-provider LLM proxy.
+#
+# Point it at a running proxy (default http://localhost:3000) and send
+# OpenAI-style chat requests; llmshim translates to the native provider API.
+#
+# Object API:
+#
+#   client = Llmshim::Client.new(base_url: "http://localhost:3000")
+#   resp = client.chat(model: "claude-sonnet-4-6", messages: "Hello!")
+#   puts resp.content
+#
+# Module convenience API (uses a shared default client):
+#
+#   Llmshim.chat(model: "gpt-5.5", messages: "Hello!")
+#   Llmshim.stream(model: "gpt-5.5", messages: "Hi") { |ev| print ev.text if ev.content? }
+#
+module Llmshim
+  class << self
+    # Base URL used by the module-level convenience methods.
+    # Defaults to the LLMSHIM_BASE_URL env var, then http://localhost:3000.
+    attr_writer :base_url
+
+    def base_url
+      @base_url ||= ENV.fetch("LLMSHIM_BASE_URL", Client::DEFAULT_BASE_URL)
+    end
+
+    # The shared default Client used by the convenience methods.
+    def default_client
+      @default_client ||= Client.new(base_url: base_url)
+    end
+
+    # Replace the shared default client (e.g. to pass custom headers/timeout).
+    attr_writer :default_client
+
+    # @see Client#chat
+    def chat(**kwargs, &block)
+      default_client.chat(**kwargs, &block)
+    end
+
+    # @see Client#stream
+    def stream(**kwargs, &block)
+      default_client.stream(**kwargs, &block)
+    end
+
+    # @see Client#models
+    def models
+      default_client.models
+    end
+
+    # @see Client#health
+    def health
+      default_client.health
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: llmshim
+version: !ruby/object:Gem::Version
+  version: 0.1.24
+platform: ruby
+authors:
+- Sanjay Nadhavajhala
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: |
+  A thin, dependency-free HTTP client for a running llmshim proxy. Send
+  OpenAI-style chat requests and let llmshim translate to OpenAI, Anthropic,
+  Google Gemini, or xAI. Supports non-streaming and SSE streaming, model
+  listing, and health checks. Standard library only.
+email:
+- sanjay@f2.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/llmshim.rb
+- lib/llmshim/client.rb
+- lib/llmshim/errors.rb
+- lib/llmshim/types.rb
+- lib/llmshim/version.rb
+homepage: https://github.com/sanjay920/llmshim
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sanjay920/llmshim
+  source_code_uri: https://github.com/sanjay920/llmshim
+  changelog_uri: https://github.com/sanjay920/llmshim/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby client for the llmshim multi-provider LLM proxy.
+test_files: []