Fix dropped parallel tool calls in speculative streams

Apply ripple-inference PR #17 (d68cca40e1). Reconcile streamed tool calls at finish so speculative deltas cannot drop trailing calls or argument suffixes. Validated with CPU parser and chat-format regression tests on stock SGLang 0.5.19.

https://github.com/ricursive/ripple-inference/pull/17

inference/server/ripple_format.py

@@ -136,7 +136,7 @@ def _reasoning_detector_class():
 
 
 def _tool_detector_class():
-    from sglang.srt.function_call.core_types import StructureInfo
+    from sglang.srt.function_call.core_types import StructureInfo, ToolCallItem
     from sglang.srt.function_call.hermes_detector import HermesDetector
 
     class RippleToolDetector(HermesDetector):
@@ -147,6 +147,21 @@ def _tool_detector_class():
             super().__init__()
             self._held_newline = ""
             self._in_calls = False
+            # Hermes can leave whole calls buffered when one speculative delta spans
+            # multiple calls. Reconcile the full output with emitted deltas at finish.
+            self._seen = ""
+            self._emitted = {}
+
+        def _record(self, calls):
+            for call in calls:
+                emitted = self._emitted.setdefault(call.tool_index, ["", ""])
+                emitted[0] += call.name or ""
+                emitted[1] += call.parameters or ""
+                # SGLang's serving layer also flushes arguments after finish(). Keep
+                # its accounting current so it cannot send the same suffix twice.
+                while len(self.streamed_args_for_tool) <= call.tool_index:
+                    self.streamed_args_for_tool.append("")
+                self.streamed_args_for_tool[call.tool_index] = emitted[1]
 
         def detect_and_parse(self, text, tools):
             res = super().detect_and_parse(text, tools)
@@ -156,7 +171,9 @@ def _tool_detector_class():
             return res
 
         def parse_streaming_increment(self, new_text, tools):
+            self._seen += new_text
             res = super().parse_streaming_increment(new_text, tools)
+            self._record(res.calls)
             if self._in_calls:  # text after the first call is dropped, as in detect_and_parse
                 res.normal_text = ""
                 return res
@@ -175,6 +192,19 @@ def _tool_detector_class():
 
         def finish(self, tools):
             res = super().finish(tools)
+            self._record(res.calls)
+            if self.bot_token in self._seen:
+                for i, call in enumerate(self.detect_and_parse(self._seen, tools).calls):
+                    name, args = self._emitted.get(i, ["", ""])
+                    want = call.parameters or ""
+                    if want.startswith(args):
+                        suffix = want[len(args):]
+                        if suffix or not name:
+                            item = ToolCallItem(
+                                tool_index=i, name=None if name else call.name, parameters=suffix,
+                            )
+                            res.calls.append(item)
+                            self._record([item])
             if self._in_calls:
                 res.normal_text = ""
             elif self._held_newline: