turnkit 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af637ae31bf82bcdaaf638f4adc5b8aca0273b61a87e79783f257c792c4d7f1d
-  data.tar.gz: b25b5adc0626e1eea3643aed4a71ae5829df105c9d6c6296739ad2b7913ade67
+  metadata.gz: 74d8be12d139ca9356ce9040853c4e78a1900f57d78428987e9e8ef930dde9c8
+  data.tar.gz: 88311f1061514d6afbd6484d497118718cf0ca95cec7757b9552db026efa8d70
 SHA512:
-  metadata.gz: 6318b5bdab01bb9c81668a817b91b60e314ef60d64608a7a8cc30a3ef5caeb931aa501231cde114538cd821d45dcf41aaee2f238fe6871f4f4f6cc22e553b70f
-  data.tar.gz: f2a801c4cb643e67078b71f18c9814ee38ca9353255b7ca6cbf0294f558a2688790b349daf0015ae48e6777ea6b03b237d089ee98cc77ac92aad1690f11ef0a5
+  metadata.gz: 595dc6ea8bdea14f84c5844d5b8fb29769e7ec8dd8d14674af4ae81f4c897446fcf3a3afd2528c2dd3af847f708f312c5ca5d314b4229260b411c93ffe8276ba
+  data.tar.gz: d8d9f658f19f538297c9670494a71d7c5e02f086d5980c116053de8f4c17bd336d3970a95b1443b878bbaf74b1f2746af4325020d4db76869c2470c42bd879e5

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.10.1 - 2026-10-13
+
+- Validate against stable RubyLLM 2.1.1 while retaining the 1.16 compatibility bundle.
+- Scope opaque provider replay to the originating requested model and matching
+  protocol. Older records without model provenance fall back to portable text
+  and tool calls; signed continuation state is not reused across model changes.
+- Forward media provider/protocol selection, leave omitted image sizes to the
+  provider, and classify SDK configuration errors as TurnKit configuration errors.
+- Preserve unknown registry costs when prices are incomplete, including after
+  serialization and aggregation.
+
 ## 0.10.0 - 2026-09-19
 
 - Add `Adapters::OpenRouterJev` for the non-chat Decisions alpha endpoint, reusing

data/README.md

@@ -13,7 +13,7 @@ plan. `turn.pause!`/`resume!` preserve progress and release background workers;
 use `descendants: :cascade` for a research subtree. See
 [interactive research](docs/interactive-research.md) for exact interruption
 boundaries, durable receipts, approval gates, and Rails integration.
-For GPT-6 Astra tools, opt into the pinned RubyLLM 2 release candidate and
+For GPT-6 Astra tools, use stable RubyLLM 2.1.1 and the
 [Responses protocol](docs/interactive-research.md#gpt-6-astra-and-provider-continuation-state).
 The [live validation app](examples/interactive_validation/README.md) exercises
 these controls with Rails 8.1, PostgreSQL, Sidekiq, and actual Astra/xhigh requests.

data/lib/turnkit/adapters/ruby_llm.rb

@@ -18,7 +18,7 @@ module TurnKit
         ensure_ruby_llm!
         raise ModelAccessError, "model is required" if model.to_s.empty?
         if @protocol && !::RubyLLM::Chat.method_defined?(:generate)
-          raise ConfigError, "protocol selection requires RubyLLM 2.0 (currently 2.0.0.rc2)"
+          raise ConfigError, "protocol selection requires RubyLLM >= 2.0"
         end
 
         configure_from_environment
@@ -58,7 +58,7 @@ module TurnKit
           chat.respond_to?(:with_tool) ? chat.with_tool(ruby_llm_tool(tool)) : chat.with_tools(ruby_llm_tool(tool))
         end
         tool_names = {}
-        Array(messages).each { |message| add_message(chat, message, provider: chat.model.provider, tool_names: tool_names) }
+        Array(messages).each { |message| add_message(chat, message, provider: chat.model.provider, model: model, tool_names: tool_names) }
         # The runtime supplies durable snapshots in messages. Direct adapter
         # callers must preserve this message themselves on subsequent calls.
         if context_in_history && !dynamic_instructions.to_s.empty?
@@ -69,6 +69,8 @@ module TurnKit
         normalize_response(response, model: model)
       rescue ConfigError
         raise
+      rescue ::RubyLLM::ConfigurationError => error
+        raise ConfigError, error.message
       rescue ::RubyLLM::Error, ::RubyLLM::ModelNotFoundError => error
         # Provider failures (after RubyLLM's own retries) are task failures,
         # not worker crashes to be replayed by durable reconciliation.
@@ -83,14 +85,16 @@ module TurnKit
           model: model,
           provider: provider,
           assume_model_exists: assume_model_exists || false,
-          size: size || "1024x1024",
+          size: size,
           with: input_images,
           mask: mask,
           **{ (::RubyLLM::Chat.method_defined?(:generate) ? :provider_options : :params) => params || {} }
         )
-        normalize_image_response(image, model: model, provider: provider, params: { "size" => size || "1024x1024" }.merge(params || {}), metadata: metadata)
+        normalize_image_response(image, model: model, provider: provider, params: { "size" => size }.compact.merge(params || {}), metadata: metadata)
       rescue ConfigError
         raise
+      rescue ::RubyLLM::ConfigurationError => error
+        raise ConfigError, error.message
       rescue ::RubyLLM::Error, ::RubyLLM::ModelNotFoundError => error
         raise ModelError, "#{error.class}: #{error.message}"
       end
@@ -100,7 +104,8 @@ module TurnKit
         configure_from_environment
         media_input = MediaInput.wrap(media)
 
-        chat = ::RubyLLM.chat(model: model)
+        validate!(model: model) if @protocol
+        chat = ::RubyLLM.chat(**{ model: model, provider: provider, protocol: @protocol }.compact)
         chat.with_schema(normalize_schema(output_schema)) if output_schema
         if params && !params.empty?
           if ::RubyLLM::Chat.method_defined?(:generate)
@@ -122,6 +127,8 @@ module TurnKit
         normalize_media_analysis_response(response, media: media_input, model: model, provider: provider, params: params || {}, metadata: metadata)
       rescue ConfigError
         raise
+      rescue ::RubyLLM::ConfigurationError => error
+        raise ConfigError, error.message
       rescue ::RubyLLM::Error, ::RubyLLM::ModelNotFoundError => error
         raise ModelError, "#{error.class}: #{error.message}"
       end
@@ -185,11 +192,23 @@ module TurnKit
           chat.send(:provider_completion)
         end
 
-        def add_message(chat, message, provider: nil, tool_names: {})
+        def add_message(chat, message, provider: nil, model: nil, tool_names: {})
           role = (message[:role] || message["role"]).to_sym
           content = message[:content] || message["content"] || ""
           kind = { "openai" => "openai_responses", "anthropic" => "anthropic", "gemini" => "gemini" }[provider.to_s]
-          replay = Array(message[:provider_parts] || message["provider_parts"]).find { |part| part["kind"] == kind } if kind
+          protocol = { "openai" => :responses, "anthropic" => :anthropic, "gemini" => :gemini }[provider.to_s]
+          if chat.respond_to?(:provider) && chat.provider.respond_to?(:protocol_for) && protocol
+            # Honor SDK configuration and per-model routing as well as our override.
+            configured = chat.provider.config.public_send("#{provider}_protocol")
+            selected = @protocol || configured
+            codec = selected ? chat.provider.protocols[selected.to_sym] : chat.provider.protocol_for(chat.model)
+            kind = nil unless codec == chat.provider.protocols[protocol]
+          elsif @protocol && @protocol.to_s != protocol.to_s
+            kind = nil
+          end
+          replay = Array(message[:provider_parts] || message["provider_parts"]).find do |part|
+            part["kind"] == kind && model && part["model"] == model
+          end if kind
           calls = ruby_llm_tool_calls(message[:tool_calls] || message["tool_calls"])
           raw_content = replay&.fetch("data")
           if raw_content && %w[anthropic gemini].include?(kind) && !::RubyLLM::Chat.method_defined?(:generate)
@@ -292,7 +311,7 @@ module TurnKit
           )
           Result.new(
             text: response_text(response),
-            parts: response_parts(response, tool_calls: tool_calls),
+            parts: response_parts(response, tool_calls: tool_calls, model: model),
             output_data: response_data(response),
             tool_calls: tool_calls,
             usage: usage,
@@ -300,7 +319,7 @@ module TurnKit
           )
         end
 
-        def response_parts(response, tool_calls:)
+        def response_parts(response, tool_calls:, model:)
           content = response.respond_to?(:content) ? response.content : response
           parts = case content
           when Array
@@ -313,11 +332,11 @@ module TurnKit
           end.compact
           raw = response.raw.body if response.respond_to?(:raw) && response.raw.respond_to?(:body)
           if raw.is_a?(Hash) && raw["object"] == "response"
-            parts << { "type" => "provider", "kind" => "openai_responses", "data" => raw.fetch("output") }
+            parts << { "type" => "provider", "kind" => "openai_responses", "model" => model, "data" => raw.fetch("output") }
           elsif raw.is_a?(Hash) && raw["type"] == "message" && raw["role"] == "assistant"
-            parts << { "type" => "provider", "kind" => "anthropic", "data" => raw.fetch("content") }
+            parts << { "type" => "provider", "kind" => "anthropic", "model" => model, "data" => raw.fetch("content") }
           elsif raw.is_a?(Hash) && raw.dig("candidates", 0, "content", "parts")
-            parts << { "type" => "provider", "kind" => "gemini", "data" => raw.dig("candidates", 0, "content", "parts") }
+            parts << { "type" => "provider", "kind" => "gemini", "model" => model, "data" => raw.dig("candidates", 0, "content", "parts") }
           end
           parts + Array(tool_calls).map { |call| { "type" => "tool_call", "id" => call.id, "name" => call.name, "arguments" => call.arguments } }
         end

data/lib/turnkit/cost.rb

@@ -91,7 +91,8 @@ module TurnKit
         ::RubyLLM::Tokens.new(input: usage.input_tokens, output: usage.output_tokens,
           cached: usage.cached_tokens, cache_creation: usage.cache_write_tokens, thinking: usage.thinking_tokens)
       end
-      from_hash(::RubyLLM::Cost.new(tokens: tokens, model: model_info).to_h)
+      cost = ::RubyLLM::Cost.new(tokens: tokens, model: model_info)
+      from_hash(cost.to_h.merge(unknown: cost.total.nil?))
     rescue ::RubyLLM::ModelNotFoundError
       new
     end

data/lib/turnkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TurnKit
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turnkit
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Sam Couch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies: []
 description: TurnKit is a Ruby/Rails agent runtime for durable AI conversations, application
   runs, orchestrator agents, tool calling, skills, sub-agents, context compaction,