llm.rb 12.2.0 → 12.3.0

data/data/openai.json

@@ -124,6 +124,99 @@
         "output": 168
       }
     },
+    "gpt-5.6": {
+      "id": "gpt-5.6",
+      "name": "GPT-5.6",
+      "description": "Frontier GPT-5.6 model for complex professional work, coding, and agentic workflows",
+      "family": "gpt",
+      "attachment": true,
+      "reasoning": true,
+      "reasoning_options": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ],
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2026-02-16",
+      "release_date": "2026-07-09",
+      "last_updated": "2026-07-09",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      },
+      "experimental": {
+        "modes": {
+          "fast": {
+            "cost": {
+              "input": 10,
+              "output": 60,
+              "cache_read": 1,
+              "cache_write": 12.5
+            },
+            "provider": {
+              "body": {
+                "service_tier": "priority"
+              }
+            }
+          },
+          "pro": {
+            "provider": {
+              "body": {
+                "reasoning": {
+                  "mode": "pro"
+                }
+              }
+            }
+          }
+        }
+      },
+      "cost": {
+        "input": 5,
+        "output": 30,
+        "cache_read": 0.5,
+        "cache_write": 6.25,
+        "tiers": [
+          {
+            "input": 10,
+            "output": 45,
+            "cache_read": 1,
+            "cache_write": 12.5,
+            "tier": {
+              "type": "context",
+              "size": 272000
+            }
+          }
+        ],
+        "context_over_200k": {
+          "input": 10,
+          "output": 45,
+          "cache_read": 1,
+          "cache_write": 12.5
+        }
+      }
+    },
     "gpt-5": {
       "id": "gpt-5",
       "name": "GPT-5",
@@ -930,6 +1023,99 @@
         "output": 0
       }
     },
+    "gpt-5.6-luna": {
+      "id": "gpt-5.6-luna",
+      "name": "GPT-5.6 Luna",
+      "description": "Cost-efficient GPT-5.6 model for fast, high-volume workloads",
+      "family": "gpt-nano",
+      "attachment": true,
+      "reasoning": true,
+      "reasoning_options": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ],
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2026-02-16",
+      "release_date": "2026-07-09",
+      "last_updated": "2026-07-09",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      },
+      "experimental": {
+        "modes": {
+          "fast": {
+            "cost": {
+              "input": 2,
+              "output": 12,
+              "cache_read": 0.2,
+              "cache_write": 2.5
+            },
+            "provider": {
+              "body": {
+                "service_tier": "priority"
+              }
+            }
+          },
+          "pro": {
+            "provider": {
+              "body": {
+                "reasoning": {
+                  "mode": "pro"
+                }
+              }
+            }
+          }
+        }
+      },
+      "cost": {
+        "input": 1,
+        "output": 6,
+        "cache_read": 0.1,
+        "cache_write": 1.25,
+        "tiers": [
+          {
+            "input": 2,
+            "output": 9,
+            "cache_read": 0.2,
+            "cache_write": 2.5,
+            "tier": {
+              "type": "context",
+              "size": 272000
+            }
+          }
+        ],
+        "context_over_200k": {
+          "input": 2,
+          "output": 9,
+          "cache_read": 0.2,
+          "cache_write": 2.5
+        }
+      }
+    },
     "gpt-5.1-codex-mini": {
       "id": "gpt-5.1-codex-mini",
       "name": "GPT-5.1 Codex mini",
@@ -974,6 +1160,149 @@
         "cache_read": 0.025
       }
     },
+    "gpt-realtime-2.1": {
+      "id": "gpt-realtime-2.1",
+      "name": "GPT-Realtime-2.1",
+      "description": "Realtime speech-to-speech model with configurable reasoning, tool use, and robust voice-agent behavior",
+      "family": "gpt",
+      "attachment": true,
+      "reasoning": true,
+      "reasoning_options": [
+        {
+          "type": "effort",
+          "values": [
+            "minimal",
+            "low",
+            "medium",
+            "high",
+            "xhigh"
+          ]
+        }
+      ],
+      "tool_call": true,
+      "structured_output": false,
+      "temperature": false,
+      "knowledge": "2024-09-30",
+      "release_date": "2026-07-06",
+      "last_updated": "2026-07-06",
+      "modalities": {
+        "input": [
+          "text",
+          "audio",
+          "image"
+        ],
+        "output": [
+          "text",
+          "audio"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 128000,
+        "input": 96000,
+        "output": 32000
+      },
+      "cost": {
+        "input": 4,
+        "output": 24,
+        "cache_read": 0.4,
+        "input_audio": 32,
+        "output_audio": 64
+      }
+    },
+    "gpt-5.6-terra": {
+      "id": "gpt-5.6-terra",
+      "name": "GPT-5.6 Terra",
+      "description": "Balanced GPT-5.6 model for capable, cost-efficient everyday work",
+      "family": "gpt-mini",
+      "attachment": true,
+      "reasoning": true,
+      "reasoning_options": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ],
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2026-02-16",
+      "release_date": "2026-07-09",
+      "last_updated": "2026-07-09",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      },
+      "experimental": {
+        "modes": {
+          "fast": {
+            "cost": {
+              "input": 5,
+              "output": 30,
+              "cache_read": 0.5,
+              "cache_write": 6.25
+            },
+            "provider": {
+              "body": {
+                "service_tier": "priority"
+              }
+            }
+          },
+          "pro": {
+            "provider": {
+              "body": {
+                "reasoning": {
+                  "mode": "pro"
+                }
+              }
+            }
+          }
+        }
+      },
+      "cost": {
+        "input": 2.5,
+        "output": 15,
+        "cache_read": 0.25,
+        "cache_write": 3.125,
+        "tiers": [
+          {
+            "input": 5,
+            "output": 22.5,
+            "cache_read": 0.5,
+            "cache_write": 6.25,
+            "tier": {
+              "type": "context",
+              "size": 272000
+            }
+          }
+        ],
+        "context_over_200k": {
+          "input": 5,
+          "output": 22.5,
+          "cache_read": 0.5,
+          "cache_write": 6.25
+        }
+      }
+    },
     "gpt-5.1-chat-latest": {
       "id": "gpt-5.1-chat-latest",
       "name": "GPT-5.1 Chat",
@@ -1851,6 +2180,99 @@
         "cache_read": 0.075
       }
     },
+    "gpt-5.6-sol": {
+      "id": "gpt-5.6-sol",
+      "name": "GPT-5.6 Sol",
+      "description": "Frontier GPT-5.6 model for complex professional work, coding, and agentic workflows",
+      "family": "gpt",
+      "attachment": true,
+      "reasoning": true,
+      "reasoning_options": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ],
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2026-02-16",
+      "release_date": "2026-07-09",
+      "last_updated": "2026-07-09",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      },
+      "experimental": {
+        "modes": {
+          "fast": {
+            "cost": {
+              "input": 10,
+              "output": 60,
+              "cache_read": 1,
+              "cache_write": 12.5
+            },
+            "provider": {
+              "body": {
+                "service_tier": "priority"
+              }
+            }
+          },
+          "pro": {
+            "provider": {
+              "body": {
+                "reasoning": {
+                  "mode": "pro"
+                }
+              }
+            }
+          }
+        }
+      },
+      "cost": {
+        "input": 5,
+        "output": 30,
+        "cache_read": 0.5,
+        "cache_write": 6.25,
+        "tiers": [
+          {
+            "input": 10,
+            "output": 45,
+            "cache_read": 1,
+            "cache_write": 12.5,
+            "tier": {
+              "type": "context",
+              "size": 272000
+            }
+          }
+        ],
+        "context_over_200k": {
+          "input": 10,
+          "output": 45,
+          "cache_read": 1,
+          "cache_write": 12.5
+        }
+      }
+    },
     "gpt-5-codex": {
       "id": "gpt-5-codex",
       "name": "GPT-5-Codex",

data/lib/llm/active_record/acts_as_agent.rb

@@ -75,6 +75,17 @@ module LLM::ActiveRecord
         @llm
       end
 
+      ##
+      # @note
+      #  This method does not persist to the database,
+      #  but it can inspect and alter runtime state in
+      #  a way that is temporary.
+      # @param (see LLM::Agent#repl)
+      # @return (see LLM::Agent#repl)
+      def repl(**params)
+        ctx.repl(**params)
+      end
+
       private
 
       ##

data/lib/llm/agent.rb

@@ -398,17 +398,25 @@ module LLM
     #  By default this method disables the tracer for
     #  the duration of the repl session, and restores
     #  it afterwards.
-    # @param [Boolean] trace
+    # @param [Boolean] tracer
     #  When true, the tracer is kept alive during the
     #  repl session. Default is false.
+    # @param [Array<LLM::Tool>] tools
+    #  Extra tools to attach for the repl session
+    # @param [Array<String>] skills
+    #  Extra skills to attach for the repl session
     # @return [void]
-    def repl(trace: false)
-      if !trace
-        previous    = tracer
+    def repl(tracer: false, trace: nil, tools: [], skills: [])
+      if trace != nil
+        warn "llm.rb: trace option is deprecated, use tracer instead"
+        tracer = trace
+      end
+      if !tracer
+        previous    = self.tracer
         self.tracer = nil
       end
       require_relative "repl" unless defined?(::LLM::Repl)
-      LLM::Repl.new(self).start
+      LLM::Repl.new(agent: self, tools:, skills:).start
     ensure
       if !trace
         self.tracer = previous
@@ -526,7 +534,7 @@ module LLM
         max = params.key?(:tool_attempts) ? params.delete(:tool_attempts) : 25
         max = Integer(max) if max
         stream = params[:stream] || @ctx.params[:stream]
-        stream.extra[:concurrency] = concurrency if LLM::Stream === stream
+        params[:stream] = LLM::Stream.try(stream, extra: {concurrency:})
         res = talk.call(apply_instructions(prompt), params)
         while @ctx.functions?
           if max

data/lib/llm/compactor.rb

@@ -71,13 +71,13 @@ class LLM::Compactor
     retention_window = [config[:retention_window], messages.size].min
     return nil unless messages.size > retention_window
     stream = ctx.params[:stream]
-    stream.on_compaction(ctx, self) if LLM::Stream === stream
+    stream.on_compaction(ctx, self)
     recent = retained_messages
     older = messages[0...(messages.size - recent.size)]
     summary = LLM::Message.new(ctx.llm.user_role, "[Previous conversation summary]\n\n#{summarize(older)}", {compaction: true})
     ctx.messages.replace([*ctx.messages.take_while(&:system?), summary, *recent])
     ctx.compacted = true
-    stream.on_compaction_finish(ctx, self) if LLM::Stream === stream
+    stream.on_compaction_finish(ctx, self)
     summary
   end
 

data/lib/llm/context.rb

@@ -92,6 +92,8 @@ module LLM
       @params[:tools] = tools unless tools.empty?
       @params[:store] ||= false if @mode == :responses
       @messages = LLM::Buffer.new(llm)
+      extra = @params.slice(:model, :tools).merge!(ctx: self, tracer:)
+      @params[:stream] = LLM::Stream.try(@params[:stream], extra:)
     end
 
     ##
@@ -310,10 +312,7 @@ module LLM
     #  A list of functions to exclude from the wait
     # @return [Array<LLM::Function::Return>]
     def wait(strategy, except: [])
-      if LLM::Stream === stream && !stream.queue.empty?
-        @queue = stream.queue
-        @queue.wait
-      else
+      if stream.queue.empty?
         tools  = except.empty? ? functions : functions - except
         guards = guarded_returns(tools:)
         return guards if guards
@@ -321,6 +320,9 @@ module LLM
         returns = @queue.wait
         emit_tool_returns(tools, returns)
         returns
+      else
+        @queue = stream.queue
+        @queue.wait
       end
     ensure
       @queue = nil
@@ -502,25 +504,11 @@ module LLM
 
     private
 
-    ##
-    # Binds runtime metadata onto an active stream.
-    # @api private
-    def bind!(stream, model, tools)
-      return unless LLM::Stream === stream
-      @stream = stream
-      stream.extra[:ctx] = self
-      stream.extra[:tracer] = tracer
-      stream.extra[:model] = model
-      stream.extra[:tools] = tools
-    end
-
     ##
     # Returns the bound stream queue, if available.
     # @api private
     def queue
-      [@queue, stream&.queue].compact.first
-    rescue NoMethodError
-      nil
+      [@queue, stream.queue].compact.first
     end
 
     ##
@@ -543,12 +531,13 @@ module LLM
     # Rewrites a prompt and params through the configured transformer.
     # @api private
     def transform(prompt, params)
+      transformer = self.transformer
       return [prompt, params] unless transformer
       stream = params[:stream]
-      stream.on_transform(self, transformer) if LLM::Stream === stream
+      stream.on_transform(self, transformer)
       transformer.call(self, prompt, params)
     ensure
-      stream.on_transform_finish(self, transformer) if LLM::Stream === stream
+      stream.on_transform_finish(self, transformer) if transformer
     end
 
     ##
@@ -556,8 +545,10 @@ module LLM
     # @api private
     def respond(prompt, params)
       params = @params.merge(params)
+      extra = params.slice(:model, :tools).merge!(ctx: self, tracer:)
+      params[:stream] = LLM::Stream.try(params[:stream], extra:)
       prompt, params = transform(prompt, params)
-      bind!(params[:stream], params[:model], params[:tools])
+      @stream = params[:stream]
       res_id = params[:store] == false ? nil : @messages.find(&:assistant?)&.response&.response_id
       input = res_id ? [] : @messages.to_a
       params = params.merge(previous_response_id: res_id, input:).compact
@@ -570,8 +561,10 @@ module LLM
     def complete(prompt, params)
       params = params.merge(messages: @messages.to_a)
       params = @params.merge(params)
+      extra = params.slice(:model, :tools).merge!(ctx: self, tracer:)
+      params[:stream] = LLM::Stream.try(params[:stream], extra:)
       prompt, params = transform(prompt, params)
-      bind!(params[:stream], params[:model], params[:tools])
+      @stream = params[:stream]
       [prompt, params, @llm.complete(prompt, params)]
     end
 
@@ -590,7 +583,6 @@ module LLM
     # Emits tool return callbacks for directly waited function work.
     # @api private
     def emit_tool_returns(tools, returns)
-      return unless LLM::Stream === stream
       returns.each_with_index { |result, index| stream.on_tool_return(tools[index], result) }
     end
 

data/lib/llm/object.rb

@@ -148,6 +148,19 @@ class LLM::Object < BasicObject
     SINGLETON.from @h.merge(other)
   end
 
+  ##
+  # @param [Hash, #to_h] other
+  #  The hash to merge in place
+  # @return [LLM::Object]
+  #  Returns self
+  def merge!(other = UNDEFINED)
+    return SINGLETON.get(@h, :merge!) if other.equal?(UNDEFINED)
+    other = ::Hash.try_convert(other)
+    raise TypeError, "#{other} cannot be coerced into a Hash" unless other
+    @h.merge!(other)
+    self
+  end
+
   ##
   # @param [#to_s, #to_sym] k
   #  The key name

data/lib/llm/provider.rb

@@ -71,6 +71,16 @@ class LLM::Provider
     raise NotImplementedError
   end
 
+  ##
+  # @note
+  #  This feature is not implemented by all providers,
+  #  and it will raise NotImplementedError for providers
+  #  that do not support it.
+  # @return [LLM::Response]
+  def ocr(...)
+    raise NotImplementedError
+  end
+
   ##
   # Provides an interface to the chat completions API
   # @example
@@ -332,13 +342,6 @@ class LLM::Provider
     transport.request_owner
   end
 
-  ##
-  # @param [Object] stream
-  # @return [Boolean]
-  def streamable?(stream)
-    LLM::Stream === stream || stream.respond_to?(:<<)
-  end
-
   ##
   # @return [Boolean]
   #  Returns true when an API key is configured

data/lib/llm/providers/anthropic.rb

@@ -151,9 +151,8 @@ module LLM
       params = {role: :user, model: default_model, max_tokens: 1024}.merge!(params)
       tools = resolve_tools(params.delete(:tools))
       params = [params, adapt_tools(tools)].inject({}, &:merge!).compact
-      role, stream = params.delete(:role), params.delete(:stream)
-      params[:stream] = true if streamable?(stream) || stream == true
-      [params, stream, tools, role]
+      role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))
+      [params.merge!(stream: stream.enabled?), stream, tools, role]
     end
 
     def build_complete_request(prompt, params, role)