fast-completions 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 296c0ef9c66b4933e440f14845ecca83e7ab18e96f125a572adda19e853be9b7
-  data.tar.gz: 12fe00808afa0c4c81a9b36dc3d898803c63dd570fcb29d86292d6c526b96557
+  metadata.gz: ca8f4d428afa218f2fdbec75c7f74206d3cb34d7a49234781ec1c1b4aba73cd1
+  data.tar.gz: 77bb70c53ed40fee638038da6996c39bd0d7231937fe4867f9e9e45a5c27a781
 SHA512:
-  metadata.gz: 63b785f46a6a15265ddf700f6039d920670059a5a0c39b4b40c92892462577fc9bc1b02c0dc33645be44a28fc991961bdbd437568ed32188081e6b62105f9ba4
-  data.tar.gz: c02fdca12bb4133152fc6f41a4c2c2157e011937b93f2eb2dff319c18bda3124836d2a588386ddf96a00022488f13b31b1623edb609c86b7f0c29ea0d77f33c8
+  metadata.gz: 28c2471eef9b43aab6067de99a68a994453b1a63dd4fbc02568a9a8ce753e20349c1e66b1ac9289547a3a3223c1ae8e7278ea03881dbc19273de9a522b7d2dd0
+  data.tar.gz: b21faba437020f06cb2267e7bd219911880794c8f7b31d9311151c95811c26a1092dd8ac0d3cf4b92f5628b0602927b2d4d79b75000061e5238d7e5e13c205e1

data/CHANGELOG.md

@@ -3,6 +3,39 @@
 Notable changes to the fast-completions gem. The format is prose-first,
 one section per released version, newest first.
 
+## 0.9.0 (2026-11-15)
+
+- Tool-args finalize honesty (I06): an arguments scratch that fails the
+  finalize whole-buffer parse — even after the control-character repair
+  walk — no longer degrades to a silent `arguments = {}` (pi's
+  partial-json last resort, which made a gateway double-emit look like
+  model incompetence: the muse-glimmer lineage). It now surfaces as the
+  loud in-band marker `{error: <message>, raw_arguments: <the raw
+  scratch>}` on the tool_call block's `:arguments` (and therefore on the
+  `:tool_call_end` event), constructed by
+  `Fast::Completions::ToolArgumentsFailure.marker(raw)` and detectable
+  with `ToolArgumentsFailure.marker?(value)`. The marker's keys are
+  SYMBOLS — `JSON.parse` only yields String keys — so it can never
+  collide with legitimate parsed arguments. Nothing raises:
+  `StreamAccumulator#finish` still returns, the stream outcome is
+  unchanged (a completed `tool_calls` stream still finalizes `[:done,
+  :tool_use]`), and consumers should turn the marker into an `{error:}`
+  tool result. Unchanged paths: an EMPTY scratch still finalizes `{}`
+  (the honest zero-arg / bytes-never-arrived case; the chunk-seam drop
+  path counts its own drops), a repairable control-char scratch still
+  repairs to valid arguments, and a well-formed stream is byte-for-byte
+  unchanged. The wire format is untouched. Consumers executing
+  arguments sight-unseen (tart pre-pin-bump) will now splat the marker's
+  symbol keys and fail loudly at the kwargs boundary instead of
+  executing a bogus zero-arg call — the intended honesty gain.
+
+## 0.8.0 (2026-10-30)
+
+- Ruby 3.3 support dropped: `required_ruby_version` moves from
+  `>= 3.3` to `>= 3.4`, and the monorepo CI matrix narrows to 3.4/4.0
+  to match. No other platform change — no new dependencies, no API
+  movement.
+
 ## 0.7.0 (2026-10-25)
 
 - Telemetry sink interface: `Client.new` accepts `telemetry:` — any

data/lib/fast/completions/errors.rb

@@ -59,6 +59,37 @@ module Fast
       end
     end
 
+    # I06 serving-stack tool honesty: the loud in-band failure surface
+    # for tool-call arguments that fail the finalize parse even after the
+    # control-character repair walk (Protocol.parse_streaming_json). NEVER
+    # raised — a raise out of StreamAccumulator#finish would kill
+    # consuming agent sessions (the pre-tart-#19 crash lineage); the
+    # marker rides block[:arguments] itself, so every surface that
+    # already reads arguments (message blocks, :tool_call_end events)
+    # carries it with no new block keys. Collision-proof by construction:
+    # the marker's keys are SYMBOLS, and JSON.parse only ever yields
+    # String keys — no legitimate arguments hash can contain :error or
+    # :raw_arguments.
+    module ToolArgumentsFailure
+      MESSAGE = "tool call arguments are unparseable JSON at stream finalize " \
+                "(duplicated or truncated arguments stream); the raw argument " \
+                "bytes are carried in raw_arguments"
+
+      module_function
+
+      # The marker Hash: {error: MESSAGE, raw_arguments: raw}.
+      def marker(raw)
+        {error: MESSAGE, raw_arguments: raw}
+      end
+
+      # The consumer-side predicate (tart's chat.rb): true only for the
+      # marker — legitimate parsed arguments have String keys and can
+      # never match.
+      def marker?(value)
+        value.is_a?(Hash) && value.key?(:error) && value.key?(:raw_arguments)
+      end
+    end
+
     class CancelledError < StandardError; end        # NOT < Error (D8)
 
     # I63 constrained sampling (pi api/constrained-sampling.ts). INTERNAL:

data/lib/fast/completions/protocol.rb

@@ -212,10 +212,16 @@ module Fast
       end
 
       # OQ-4: control-character repair (pi utils/json-parse.ts repairJson
-      # :20-77), {} as the last resort (pi's partial-json fallback). The
-      # repaired re-parse gets its OWN method — a rescue body's exception
-      # is not caught by a later rescue clause of the same method (the
-      # 0.4.0 leak: a delta boundary splitting an escape sequence left the
+      # :20-77); I06: a NON-EMPTY scratch that still fails the parse no
+      # longer degrades to pi's silent {} partial-json fallback — it
+      # surfaces the loud in-band ToolArgumentsFailure marker instead (a
+      # parse failure must never masquerade as a deliberate zero-arg
+      # call). An EMPTY scratch stays {}: the honest representation of a
+      # genuine zero-arg call (or argument bytes that never arrived —
+      # the chunk-seam drop path counts those separately). The repaired
+      # re-parse gets its OWN method — a rescue body's exception is not
+      # caught by a later rescue clause of the same method (the 0.4.0
+      # leak: a delta boundary splitting an escape sequence left the
       # scratch buffer mid-string with a trailing backslash; repair "fixed"
       # it, the re-parse raised, and the step died). pi's outer try/catch
       # absorbs this; so do we.
@@ -225,13 +231,15 @@ module Fast
         JSON.parse(partial)
       rescue JSON::ParserError
         repaired = repair_json(partial)
-        repaired == partial ? {} : parse_repaired_json(repaired)
+        repaired == partial ? ToolArgumentsFailure.marker(partial) : parse_repaired_json(repaired, partial)
       end
 
-      def parse_repaired_json(repaired)
+      # `raw` is the ORIGINAL scratch: the marker reports the bytes the
+      # wire delivered, never our own repair transform of them.
+      def parse_repaired_json(repaired, raw)
         JSON.parse(repaired)
       rescue JSON::ParserError
-        {}
+        ToolArgumentsFailure.marker(raw)
       end
 
       # Escape raw control characters inside strings; double backslashes
@@ -482,9 +490,11 @@ module Fast
               raw = streamer ? streamer.scratch : "" # no-fragment blocks finalize an empty scratch
               # Finalize is the SOLE authority (L9): one whole-buffer parse
               # of the raw bytes — the JSON.parse fast path when the stream
-              # completed, the repair walk + {} last resort otherwise
-              # (pi :453 / utils/json-parse.ts :20-90). The live Hash the
-              # machine grew is replaced here, exactly once.
+              # completed, the repair walk otherwise, and (I06) the loud
+              # in-band ToolArgumentsFailure marker when a NON-EMPTY
+              # scratch still will not parse — never pi's silent {}
+              # last resort. The live Hash the machine grew is replaced
+              # here, exactly once.
               block[:arguments] = Protocol.parse_streaming_json(raw)
               events << Event.new(type: :tool_call_end, content_index: index,
                 tool_call: {id: block[:id], name: block[:name], arguments: block[:arguments]},

data/lib/fast/completions/version.rb

@@ -2,6 +2,6 @@
 
 module Fast
   module Completions
-    VERSION = "0.7.0"
+    VERSION = "0.9.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast-completions
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -63,7 +63,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.3'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="