llm.rb 8.0.0 → 8.1.0

data/data/deepseek.json

@@ -29,13 +29,13 @@
       },
       "open_weights": true,
       "cost": {
-        "input": 0.28,
-        "output": 0.42,
+        "input": 0.14,
+        "output": 0.28,
         "cache_read": 0.028
       },
       "limit": {
-        "context": 131072,
-        "output": 8192
+        "context": 1000000,
+        "output": 384000
       }
     },
     "deepseek-reasoner": {
@@ -62,13 +62,13 @@
       },
       "open_weights": true,
       "cost": {
-        "input": 0.28,
-        "output": 0.42,
+        "input": 0.14,
+        "output": 0.28,
         "cache_read": 0.028
       },
       "limit": {
-        "context": 128000,
-        "output": 64000
+        "context": 1000000,
+        "output": 384000
       }
     },
     "deepseek-v4-flash": {

data/data/openai.json

@@ -230,8 +230,8 @@
       },
       "limit": {
         "context": 1050000,
-        "input": 920000,
-        "output": 130000
+        "input": 922000,
+        "output": 128000
       },
       "experimental": {
         "modes": {
@@ -1554,6 +1554,43 @@
         "output": 0
       }
     },
+    "gpt-5.5-pro": {
+      "id": "gpt-5.5-pro",
+      "name": "GPT-5.5 Pro",
+      "family": "gpt-pro",
+      "attachment": true,
+      "reasoning": true,
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2025-12-01",
+      "release_date": "2026-04-23",
+      "last_updated": "2026-04-23",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "cost": {
+        "input": 30,
+        "output": 180,
+        "context_over_200k": {
+          "input": 60,
+          "output": 270
+        }
+      },
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      }
+    },
     "gpt-4.1": {
       "id": "gpt-4.1",
       "name": "GPT-4.1",

data/data/xai.json

@@ -68,6 +68,41 @@
         "output": 4096
       }
     },
+    "grok-4.3": {
+      "id": "grok-4.3",
+      "name": "Grok 4.3",
+      "family": "grok",
+      "attachment": true,
+      "reasoning": true,
+      "tool_call": true,
+      "temperature": true,
+      "release_date": "2026-05-01",
+      "last_updated": "2026-05-01",
+      "modalities": {
+        "input": [
+          "text",
+          "image"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "cost": {
+        "input": 1.25,
+        "output": 2.5,
+        "cache_read": 0.2,
+        "context_over_200k": {
+          "input": 2.5,
+          "output": 5,
+          "cache_read": 0.4
+        }
+      },
+      "limit": {
+        "context": 1000000,
+        "output": 30000
+      }
+    },
     "grok-3-mini-fast": {
       "id": "grok-3-mini-fast",
       "name": "Grok 3 Mini Fast",

data/data/zai.json

@@ -10,7 +10,7 @@
   "models": {
     "glm-5v-turbo": {
       "id": "glm-5v-turbo",
-      "name": "glm-5v-turbo",
+      "name": "GLM-5V-Turbo",
       "family": "glm",
       "attachment": true,
       "reasoning": true,

data/lib/llm/object.rb

@@ -60,6 +60,14 @@ class LLM::Object < BasicObject
     @h.each(&)
   end
 
+  ##
+  # In-place transform of values with a block.
+  # @yieldparam [Object] v
+  # @return [Hash]
+  def transform_values!(&)
+    @h.transform_values!(&)
+  end
+
   ##
   # @param [Symbol, #to_sym] k
   # @return [Object]

data/lib/llm/provider/transport/http/execution.rb

@@ -92,7 +92,7 @@ module LLM::Provider::Transport
         if stream
           http.request(request) do |res|
             if Net::HTTPSuccess === res
-              parser = StreamDecoder.new(stream_parser.new(stream))
+              parser = stream_decoder.new(stream_parser.new(stream))
               res.read_body(parser)
               body = parser.body
               res.body = (Hash === body || Array === body) ? LLM::Object.from(body) : body

data/lib/llm/provider.rb

@@ -399,6 +399,13 @@ class LLM::Provider
     raise NotImplementedError
   end
 
+  ##
+  # @return [Class]
+  #  Returns the class responsible for decoding streamed response bodies
+  def stream_decoder
+    LLM::Provider::Transport::HTTP::StreamDecoder
+  end
+
   ##
   # Resolves tools to their function representations
   # @param [Array<LLM::Function, LLM::Tool>] tools

data/lib/llm/providers/bedrock/error_handler.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class LLM::Bedrock
+  ##
+  # Handles Bedrock API error responses.
+  #
+  # Bedrock errors come as JSON with:
+  #   { "message" => "...", "__type" => "..." }
+  # or as standard HTTP status codes.
+  #
+  # @api private
+  class ErrorHandler
+    ##
+    # @return [Net::HTTPResponse]
+    attr_reader :res
+
+    ##
+    # @return [Object, nil]
+    attr_reader :span
+
+    ##
+    # @param [LLM::Tracer] tracer
+    # @param [Object, nil] span
+    # @param [Net::HTTPResponse] res
+    # @return [LLM::Bedrock::ErrorHandler]
+    def initialize(tracer, span, res)
+      @tracer = tracer
+      @span = span
+      @res = res
+    end
+
+    ##
+    # @raise [LLM::Error]
+    def raise_error!
+      ex = error
+      @tracer.on_request_error(ex:, span:)
+    ensure
+      raise(ex) if ex
+    end
+
+    private
+
+    ##
+    # @return [LLM::Error]
+    def error
+      message = extract_message
+      case res
+      when Net::HTTPServerError
+        LLM::ServerError.new(message).tap { _1.response = res }
+      when Net::HTTPUnauthorized
+        LLM::UnauthorizedError.new(message).tap { _1.response = res }
+      when Net::HTTPForbidden
+        LLM::UnauthorizedError.new(message).tap { _1.response = res }
+      when Net::HTTPTooManyRequests
+        LLM::RateLimitError.new(message).tap { _1.response = res }
+      when Net::HTTPNotFound
+        LLM::Error.new("Bedrock model not found: #{message}").tap { _1.response = res }
+      else
+        LLM::Error.new(message).tap { _1.response = res }
+      end
+    end
+
+    ##
+    # @return [String]
+    def extract_message
+      body = parse_body
+      body["message"] || body["Message"] || body["__type"] || "Unexpected error"
+    end
+
+    ##
+    # @return [Hash]
+    def parse_body
+      return {} if res.body.nil? || res.body.empty?
+      parsed = LLM.json.load(res.body.dup.force_encoding(Encoding::UTF_8).scrub)
+      Hash === parsed ? parsed : {}
+    rescue *LLM.json.parser_error
+      {}
+    end
+  end
+end

data/lib/llm/providers/bedrock/models.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class LLM::Bedrock
+  ##
+  # The {LLM::Bedrock::Models} class provides a model object for
+  # interacting with [AWS Bedrock's ListFoundationModels API](
+  # https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListFoundationModels.html).
+  #
+  # Unlike the Converse API (which lives on `bedrock-runtime.<region>.amazonaws.com`),
+  # the models endpoint lives on the control plane at
+  # `bedrock.<region>.amazonaws.com`. This class manages its own HTTP
+  # connection since the provider's transport is pinned to the runtime host.
+  #
+  # @example
+  #   llm = LLM.bedrock(
+  #     access_key_id: ENV["AWS_ACCESS_KEY_ID"],
+  #     secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"],
+  #     region: "us-east-1"
+  #   )
+  #   llm.models.all.each { |m| puts m.id }
+  class Models
+    ##
+    # @param [LLM::Bedrock] provider
+    # @return [LLM::Bedrock::Models]
+    def initialize(provider)
+      @provider = provider
+    end
+
+    ##
+    # List all foundation models available in the configured region.
+    #
+    # @note
+    #  This calls AWS Bedrock's ListFoundationModels API which returns
+    #  all models available in the region, not just the ones the
+    #  current account is subscribed to.
+    #
+    # @param [Hash] params Optional query parameters
+    #  (e.g. `byProvider: "Anthropic"`, `byInferenceType: "ON_DEMAND"`)
+    # @return [LLM::Response]
+    def all(**params)
+      host = credentials.host
+      handle_response http(host).request(build_request(host, params))
+    end
+
+    private
+
+    ##
+    # @param [String] host
+    # @return [Net::HTTP]
+    def http(host)
+      http = Net::HTTP.new(host, 443)
+      http.use_ssl = true
+      http.read_timeout = timeout
+      http
+    end
+
+    ##
+    # @param [String] host
+    # @param [Hash] params
+    # @return [Net::HTTP::Get]
+    def build_request(host, params)
+      path = "/foundation-models"
+      query = URI.encode_www_form(params) unless params.empty?
+      path = "#{path}?#{query}" if query && !query.empty?
+      body = ""
+      req = Net::HTTP::Get.new(path, {"Content-Type" => "application/json", "Accept" => "application/json"})
+      req.tap { sign!(req, body, host, query) }
+    end
+
+    ##
+    # @param [Net::HTTPResponse] res
+    # @return [LLM::Response]
+    # @raise [LLM::Error]
+    def handle_response(res)
+      case res
+      when Net::HTTPSuccess
+        res.body = LLM::Object.from(LLM.json.load(res.body || "{}"))
+        LLM::Bedrock::ResponseAdapter.adapt(res, type: :models)
+      else
+        body = +""
+        res.read_body { body << _1 } if res.body.nil?
+        LLM::Bedrock::ErrorHandler.new(tracer, nil, res).raise_error!
+      end
+    end
+
+    ##
+    # @param [Net::HTTPRequest] req
+    # @param [String] body
+    # @param [String] host
+    # @param [String, nil] query
+    # @return [Net::HTTPRequest]
+    def sign!(req, body, host = credentials.host, query = nil)
+      creds = credentials.tap { _1.host = host }
+      Signature.new(credentials: creds, method: "GET", path: "/foundation-models", query:, body:).sign!(req)
+    end
+
+    ##
+    # @return [LLM::Object]
+    def credentials
+      LLM::Object.from(@provider.send(:credentials).to_h).tap do
+        _1.host = "bedrock.#{_1.aws_region}.amazonaws.com"
+      end
+    end
+
+    [:timeout, :tracer].each do |m|
+      define_method(m) { @provider.send(m) }
+    end
+  end
+end

data/lib/llm/providers/bedrock/request_adapter/completion.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module LLM::Bedrock::RequestAdapter
+  ##
+  # Adapts a single message to Bedrock Converse content blocks.
+  #
+  # Bedrock Converse content blocks include:
+  #   - {text: "..."}
+  #   - {image: {format: "png", source: {bytes: "..."}}}
+  #   - {document: {format: "pdf", name: "...", source: {bytes: "..."}}}
+  #   - {toolUse: {toolUseId: "...", name: "...", input: {...}}}
+  #   - {toolResult: {toolUseId: "...", content: [{text: "..."}]}}
+  #
+  # @api private
+  class Completion
+    ##
+    # @param [LLM::Message, Hash] message
+    def initialize(message)
+      @message = message
+    end
+
+    ##
+    # Adapts the message for the Bedrock Converse API
+    # @return [Hash, nil]
+    def adapt
+      catch(:abort) do
+        if Hash === message
+          {role: message[:role], content: adapt_content(message[:content])}
+        else
+          adapt_message
+        end
+      end
+    end
+
+    private
+
+    def adapt_message
+      if message.tool_call?
+        blocks = [*adapt_tool_calls]
+        blocks.unshift(*adapt_content(content)) unless String === content && content.empty?
+        {role: "assistant", content: blocks}
+      else
+        {role: message.role, content: adapt_content(content)}
+      end
+    end
+
+    def adapt_tool_calls
+      message.extra[:tool_calls].filter_map do |tool|
+        next unless tool[:id] && tool[:name]
+        {
+          toolUse: {
+            toolUseId: tool[:id],
+            name: tool[:name],
+            input: parse_tool_input(tool[:arguments])
+          }
+        }
+      end
+    end
+
+    ##
+    # @param [String, Array, LLM::Object, LLM::Function::Return] content
+    # @return [Array<Hash>, nil]
+    def adapt_content(content)
+      case content
+      when Hash
+        content.empty? ? throw(:abort, nil) : [content]
+      when Array
+        content.empty? ? throw(:abort, nil) : content.flat_map { adapt_content(_1) }
+      when LLM::Object
+        adapt_object(content)
+      when String
+        [{text: content}]
+      when LLM::Response
+        adapt_remote_file(content)
+      when LLM::Message
+        adapt_content(content.content)
+      when LLM::Function::Return
+        [{toolResult: {toolUseId: content.id, content: [{text: LLM.json.dump(content.value)}]}}]
+      else
+        prompt_error!(content)
+      end
+    end
+
+    def adapt_object(object)
+      case object.kind
+      when :image_url
+        [{image: {format: detect_format(object.value.to_s),
+                  source: {url: object.value.to_s}}}]
+      when :local_file
+        adapt_local_file(object.value)
+      when :remote_file
+        adapt_remote_file(object.value)
+      else
+        prompt_error!(object)
+      end
+    end
+
+    def adapt_local_file(file)
+      if file.image?
+        [{image: {format: file.format,
+                  source: {bytes: file.to_b64}}}]
+      elsif file.pdf?
+        name = sanitize_name(file.basename)
+        [{document: {format: "pdf", name:,
+                     source: {bytes: file.to_b64}}}]
+      else
+        raise LLM::PromptError,
+              "The #{file.class} is not an image or PDF, " \
+              "and not supported by the Bedrock API"
+      end
+    end
+
+    def adapt_remote_file(file)
+      prompt_error!(file) unless file.file?
+      [{file.file_type => {source: {file_id: file.id}}}]
+    end
+
+    def detect_format(url)
+      case url
+      when /\.png/i then "png"
+      when /\.jpe?g/i then "jpeg"
+      when /\.gif/i then "gif"
+      when /\.webp/i then "webp"
+      else "png"
+      end
+    end
+
+    def sanitize_name(name)
+      name.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
+    end
+
+    def parse_tool_input(input)
+      case input
+      when Hash then input
+      when String
+        parsed = LLM.json.load(input)
+        Hash === parsed ? parsed : {}
+      when nil then {}
+      else input.respond_to?(:to_h) ? input.to_h : {}
+      end
+    rescue *LLM.json.parser_error
+      {}
+    end
+
+    def prompt_error!(content)
+      raise LLM::PromptError,
+            "#{content.class} is not supported by the Bedrock API"
+    end
+
+    def message = @message
+    def content = message.content
+  end
+end

data/lib/llm/providers/bedrock/request_adapter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class LLM::Bedrock
+  ##
+  # Adapts llm.rb internal message format to Bedrock Converse API format.
+  #
+  # Bedrock Converse uses:
+  #   - system: [{text: "..."}]  (top-level, separate from messages)
+  #   - messages: [{role: "user"|"assistant", content: [{...}, ...]}]
+  #   - Content blocks: text, image, document, toolUse, toolResult
+  #   - toolConfig: {tools: [{toolSpec: {name:, description:, inputSchema: {json: ...}}}]}
+  #
+  # @api private
+  module RequestAdapter
+    ##
+    # @param [Array<LLM::Message>] messages
+    # @return [Hash]
+    def adapt(messages, mode: nil)
+      payload = {messages: [], system: []}
+      messages.each do |message|
+        adapted = Completion.new(message).adapt
+        next if adapted.nil?
+        if system?(message)
+          payload[:system].concat Array(adapted[:content])
+        else
+          payload[:messages] << adapted
+        end
+      end
+      payload.delete(:system) if payload[:system].empty?
+      payload
+    end
+
+    private
+
+    ##
+    # @param [Hash] params
+    # @return [Hash]
+    def adapt_schema(params)
+      return {} unless params&.key?(:schema)
+      schema = params.delete(:schema)
+      schema = schema.respond_to?(:object) ? schema.object : schema
+      cleaned = schema.respond_to?(:to_h) ? schema.to_h : schema
+      [:strict, "strict", :$schema, "$schema"].each { cleaned.delete(_1) }
+      {
+        outputConfig: {
+          textFormat: {
+            type: "json_schema",
+            structure: {
+              jsonSchema: {
+                name: "response",
+                schema: LLM.json.dump(cleaned)
+              }
+            }
+          }
+        }
+      }
+    end
+
+    ##
+    # @param [Array<LLM::Function>] tools
+    # @return [Hash]
+    def adapt_tools(tools)
+      return {} unless tools&.any?
+      {toolConfig: {tools: tools.map { |t| adapt_tool(t) }}}
+    end
+
+    ##
+    # @param [LLM::Function] tool
+    # @return [Hash]
+    def adapt_tool(tool)
+      function = tool.respond_to?(:function) ? tool.function : tool
+      {
+        toolSpec: {
+          name: function.name,
+          description: function.description,
+          inputSchema: {
+            json: function.params || default_input_schema
+          }
+        }
+      }
+    end
+
+    def default_input_schema
+      {"type" => "object", "properties" => {}, "required" => []}
+    end
+
+    def system?(message)
+      if message.respond_to?(:system?)
+        message.system?
+      else
+        Hash === message && message[:role].to_s == "system"
+      end
+    end
+  end
+end