fix(llm): SSE connect-phase timeout + Unity extractor parity with portable core

Author: NeoXider

Assets/CoreAI/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### Fixed (2026-07-11 audit wave)
 
+- **SSE connect phase honors `TransportTimeoutSeconds`.** `HttpClientOpenAiTransport` now bounds the
+  headers-not-yet-received phase of `OpenSseResponseStreamAsync` with the configured transport timeout
+  (the linked CTS is disposed once headers arrive, so the streaming body itself stays unbounded); a backend
+  that accepts the socket but never answers fails fast instead of eating the whole turn budget.
 - **Lua sandbox: nested guarded calls can no longer disarm the outer guard.** `LuaCsExecutionGuard` keeps a
   per-`LuaState` stack of installed hooks; leaving a nested `mods_call` restores the caller's hook instead of
   removing it, so step/time/alloc budgets stay armed across direct and indirect (`A→B→A`) cross-mod calls.

Assets/CoreAI/Runtime/Core/Features/Llm/HttpClientOpenAiTransport.cs

@@ -95,15 +95,34 @@ public async Task<OpenAiHttpSseOpenResult> OpenSseResponseStreamAsync(OpenAiHttp
             httpRequest.Content = new StringContent(request.JsonBody ?? "", Encoding.UTF8, "application/json");
             ApplyHeaders(httpRequest, request.Headers, request.AcceptEventStream);
 
-            HttpResponseMessage response =
-                await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+            // WHY: The streaming client's Timeout is infinite (SSE bodies are long-lived), so a backend
+            // that accepts TCP but never sends response headers used to hang the turn until external
+            // cancellation. Bound ONLY the time-to-headers phase with TransportTimeoutSeconds; the linked
+            // CTS is disposed the moment headers arrive so it never bounds the streaming body (idle-stall
+            // detection there stays with the caller). 0/unset keeps the legacy unbounded behavior.
+            // TimeoutLlmClientDecorator still bounds the WHOLE request at a higher layer; this shorter
+            // header bound only makes a headerless backend fail fast instead of eating the turn budget.
+            HttpResponseMessage response;
+            if (request.TransportTimeoutSeconds > 0)
+            {
+                using CancellationTokenSource headerCts =
+                    CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+                headerCts.CancelAfter(TimeSpan.FromSeconds(request.TransportTimeoutSeconds));
+                response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead,
+                    headerCts.Token);
+            }
+            else
+            {
+                response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead,
+                    cancellationToken);
+            }
 
             int statusCode = (int)response.StatusCode;
             IReadOnlyDictionary<string, IEnumerable<string>> headers = CopyHeaders(response);
 
             if (!response.IsSuccessStatusCode)
             {
-                string errBody = await response.Content.ReadAsStringAsync();
+                string errBody = await ReadBodyTextAsync(response.Content, cancellationToken);
                 response.Dispose();
                 return new OpenAiHttpSseOpenResult
                 {
@@ -122,6 +141,21 @@ public async Task<OpenAiHttpSseOpenResult> OpenSseResponseStreamAsync(OpenAiHttp
             }.WithStreamResponse(stream, response);
         }
 
+        /// <summary>
+        /// Reads a response body as UTF-8 text with cancellation support. This profile has no
+        /// <c>ReadAsStringAsync(CancellationToken)</c> overload, and after
+        /// <see cref="HttpCompletionOption.ResponseHeadersRead"/> the body still comes from the
+        /// network, so an uncancellable read could hang on a stalled backend.
+        /// </summary>
+        private static async Task<string> ReadBodyTextAsync(HttpContent content,
+            CancellationToken cancellationToken)
+        {
+            using Stream stream = await content.ReadAsStreamAsync();
+            using MemoryStream buffer = new();
+            await stream.CopyToAsync(buffer, 81920, cancellationToken);
+            return Encoding.UTF8.GetString(buffer.ToArray());
+        }
+
         private static void ApplyHeaders(HttpRequestMessage httpRequest,
             IReadOnlyList<KeyValuePair<string, string>> headers, bool acceptEventStream)
         {

Assets/CoreAiUnity/CHANGELOG.md

@@ -17,6 +17,10 @@ Unity host: **CoreAI.Source** build, EditMode / PlayMode tests, Editor menus, do
   reload no longer reach dead subscribers from previous scenes (duplicate world mutations).
 - **`world_command destroy` reports failure for missing targets** (was: unconditional success, so the model
   could never self-correct a typo'd object name).
+- **`MeaiLlmClient` text tool-call extraction now delegates to the portable `LlmToolCallTextExtractor`**, so the
+  Unity path gets the same hardening as core: exact call shape required, backtick/quote-cited examples and fenced
+  code blocks never execute, balanced-parenthesis scanning, and the full fallback syntax set (XML, function-call,
+  pseudo `Action=`); nested argument objects are still normalized for MEAI.
 
 ### Added
 

Assets/CoreAiUnity/Runtime/Source/Features/Llm/Infrastructure/MeaiLlmClient.cs

@@ -1715,101 +1715,21 @@ internal static bool TryBuildMalformedTextToolCall(
         }
 
         /// <summary>
-        /// Pattern-aware tool call extraction from text.
-        /// Matches JSON objects that contain both "name" and "arguments" keys (outside fenced ``` blocks),
-        /// then falls back to <see cref="LlmToolCallTextExtractor"/> for pseudo-syntax memory writes
-        /// (e.g. Qwen: <c>Action=write content="..."</c>).
+        /// Pattern-aware tool call extraction from text. Delegates to the portable
+        /// <see cref="LlmToolCallTextExtractor"/> so both layers share one parser: exact call shape
+        /// (top-level <c>"name"</c> string plus <c>"arguments"</c> object / <c>"arguments_json"</c>
+        /// string), backtick/quote-cited spans and fenced ``` blocks skipped, and pseudo-syntax
+        /// memory writes (e.g. Qwen: <c>Action=write content="..."</c>) picked up as fallback.
         /// </summary>
         internal static bool TryExtractToolCallsFromText(
             string text,
             out List<MEAI.FunctionCallContent> toolCalls,
             out string cleanedText)
         {
-            toolCalls = new List<MEAI.FunctionCallContent>();
-            cleanedText = text ?? string.Empty;
-            if (string.IsNullOrWhiteSpace(text))
-            {
-                return false;
-            }
-
-            // Strip fenced code blocks to avoid matching JSON inside them when giving **non-tool** examples.
-            string textForSearch = StripCodeBlocks(text);
-
-            // Find all balanced JSON objects that look like tool calls (only outside fenced ``` blocks;
-            // StripCodeBlocks blanks ```...``` so examples like ```json {"name":...} ``` are not matched).
-            List<JsonSpan> candidates = FindToolCallJsonSpans(textForSearch);
-
-            if (candidates.Count == 0)
-            {
-                return TryPortableToolExtract(text, out toolCalls, out cleanedText);
-            }
-
-            // Build cleaned text by removing all found tool-call JSON spans (from original text)
-            // *hidden* from search, the positions still correspond to the original text.
-            System.Text.StringBuilder cleanBuilder = new(text.Length);
-            int lastEnd = 0;
-            foreach (JsonSpan span in candidates)
-            {
-                // Verify span is valid in original text too
-                if (span.Start >= text.Length || span.Start + span.Length > text.Length)
-                {
-                    continue;
-                }
-
-                string originalFragment = text.Substring(span.Start, span.Length);
-
-                // Re-validate the fragment in the original text
-                if (!IsValidToolCallJson(originalFragment))
-                {
-                    continue;
-                }
-
-                try
-                {
-                    JObject json = JObject.Parse(originalFragment);
-                    string functionName = json["name"]?.ToString()?.Trim();
-                    // Support both "arguments" and "arguments_json" (Qwen3.5 via LLMUnity).
-                    JToken argsToken = json["arguments"] ?? json["arguments_json"];
-                    if (string.IsNullOrWhiteSpace(functionName) || argsToken == null)
-                    {
-                        continue;
-                    }
-
-                    // If args is a string (e.g. "arguments_json": "{...}"), parse it as JSON.
-                    string argsStr = argsToken.Type == JTokenType.String
-                        ? argsToken.ToString()
-                        : argsToken.ToString(Formatting.None);
-
-                    Dictionary<string, object?> arguments =
-                        JsonConvert.DeserializeObject<Dictionary<string, object?>>(argsStr)
-                        ?? new Dictionary<string, object?>();
-
-                    // Normalize JObject/JArray values to strings for MEAI compatibility.
-                    NormalizeJTokenValues(arguments);
-
-                    string callId = $"stream_call_{functionName}_{Guid.NewGuid():N}";
-                    toolCalls.Add(new MEAI.FunctionCallContent(callId, functionName, arguments));
-
-                    cleanBuilder.Append(text, lastEnd, span.Start - lastEnd);
-                    lastEnd = span.Start + span.Length;
-                }
-                catch
-                {
-                }
-            }
-
-            if (toolCalls.Count == 0)
-            {
-                return TryPortableToolExtract(text, out toolCalls, out cleanedText);
-            }
-
-            if (lastEnd < text.Length)
-            {
-                cleanBuilder.Append(text, lastEnd, text.Length - lastEnd);
-            }
-
-            cleanedText = cleanBuilder.ToString().Trim();
-            return true;
+            // WHY: This layer used to keep its own, laxer parser that executed cited schema
+            // examples (inline-code/quoted JSON, placeholder tool names). Delegating to the
+            // hardened portable extractor closes that gap instead of duplicating its guards.
+            return TryPortableToolExtract(text, out toolCalls, out cleanedText);
         }
 
         /// <summary>
@@ -1837,6 +1757,9 @@ private static bool TryPortableToolExtract(
                         JsonConvert.DeserializeObject<Dictionary<string, object?>>(m.ArgumentsJson)
                         ?? new Dictionary<string, object?>();
 
+                    // Normalize JObject/JArray values to strings for MEAI compatibility.
+                    NormalizeJTokenValues(arguments);
+
                     string callId = $"stream_call_{m.Name}_{Guid.NewGuid():N}";
                     toolCalls.Add(new MEAI.FunctionCallContent(callId, m.Name, arguments));
                 }
@@ -1875,17 +1798,13 @@ internal static string StripCodeBlocks(string text)
             return Regex.Replace(text, @"```[\s\S]*?```", m => new string(' ', m.Length));
         }
 
-        /// <summary>Checks if a JSON string looks like a tool call (has "name" and "arguments" or "arguments_json").</summary>
+        /// <summary>Checks if a JSON string has the exact tool-call shape (top-level "name" string plus "arguments" object or "arguments_json" string).</summary>
         internal static bool IsValidToolCallJson(string json)
         {
-            if (string.IsNullOrWhiteSpace(json))
-            {
-                return false;
-            }
-
-            // Quick heuristic before parsing: must contain both key patterns
-            return json.Contains("\"name\"") &&
-                   (json.Contains("\"arguments\"") || json.Contains("\"arguments_json\""));
+            // WHY: Shared with the portable extractor so the hybrid-hold span detection and the
+            // execution path agree on what counts as a tool call (substring hits alone treated
+            // quoted schema examples as commands).
+            return LlmToolCallTextExtractor.LooksLikeToolCallJson(json);
         }
 
         /// <summary>

Assets/CoreAiUnity/Tests/EditMode/MeaiLlmClientEditModeTests.cs

@@ -1200,6 +1200,58 @@ public void ToolCallWithArrayArguments_ExtractedCorrectly()
             Assert.AreEqual("batch_tool", calls[0].Name);
         }
 
+        [Test]
+        public void BacktickCitedSchemaExample_NotExtracted()
+        {
+            // Parity with the portable extractor: inline-code JSON is a citation, not a command.
+            string text =
+                "Use `{\"name\":\"memory\",\"arguments\":{\"action\":\"clear\"}}` to clear your memory.";
+            bool found = MeaiLlmClient.TryExtractToolCallsFromText(text, out List<MEAI.FunctionCallContent> calls,
+                out string _);
+
+            Assert.IsFalse(found, "Backtick-cited JSON must not execute.");
+            Assert.AreEqual(0, calls.Count);
+        }
+
+        [Test]
+        public void QuoteWrappedSchemaExample_NotExtracted()
+        {
+            string text =
+                "The docs show '{\"name\":\"memory\",\"arguments\":{\"action\":\"clear\"}}' as the format.";
+            bool found = MeaiLlmClient.TryExtractToolCallsFromText(text, out List<MEAI.FunctionCallContent> calls,
+                out string _);
+
+            Assert.IsFalse(found, "JSON wrapped in matching quotes is a citation, not a command.");
+            Assert.AreEqual(0, calls.Count);
+        }
+
+        [Test]
+        public void PlaceholderToolName_NotExtracted()
+        {
+            string text = "Reply with {\"name\":\"<tool_name>\",\"arguments\":{}} to call a tool.";
+            bool found = MeaiLlmClient.TryExtractToolCallsFromText(text, out List<MEAI.FunctionCallContent> calls,
+                out string _);
+
+            Assert.IsFalse(found, "Placeholder tool names are schema examples, not commands.");
+            Assert.IsFalse(MeaiLlmClient.IsValidToolCallJson("{\"name\":\"<tool_name>\",\"arguments\":{}}"),
+                "IsValidToolCallJson must require the exact tool-call shape (identifier-like name).");
+        }
+
+        [Test]
+        public void CitedExamplePlusRealCall_OnlyRealCallExtracted()
+        {
+            string text =
+                "Example: `{\"name\":\"memory\",\"arguments\":{\"action\":\"read\"}}` and now " +
+                "{\"name\":\"memory\",\"arguments\":{\"action\":\"write\",\"content\":\"real\"}}";
+            bool found = MeaiLlmClient.TryExtractToolCallsFromText(text, out List<MEAI.FunctionCallContent> calls,
+                out string cleaned);
+
+            Assert.IsTrue(found);
+            Assert.AreEqual(1, calls.Count, "Only the non-cited call should be extracted.");
+            Assert.AreEqual("write", calls[0].Arguments?["action"]?.ToString());
+            Assert.That(cleaned, Does.Contain("`"), "The cited example must stay in the cleaned text.");
+        }
+
         [Test]
         public void CleanedText_IsTrimmable_NoLeadingTrailingJson()
         {