feat: pluggable tool-call adapter + OpenAI tool support (closes #95, #96, #97)

[pekkah]

Summary

Completes the tool-calling feature across both HTTP wire formats by introducing a per-architecture translation layer between the model's free-text tool-call output and the structured tool_use / tool_calls shapes the endpoints emit.

• New IToolCallAdapter + ToolCallAdapterRegistry in SharpInference.Core keyed on the GGUF general.architecture field. Adapter ships for Qwen2/3 (<tool_call> wrapper, JSON or XML inside), Qwen3-Coder (bare <function=name>...</function>, closes Tool-call parser misses Qwen3-Coder's bare <function=...> format (no <tool_call> wrapper) #95), Llama-3 (<|python_tag|>{json}<|eom_id|>), and DeepSeek-R1 multi-call envelope.
• Anthropic /v1/messages streaming + non-streaming now drive through the adapter. Streaming open/close-marker scan replaces the hard-coded <tool_call> matcher; the buffer guard becomes adapter.MaxOpenTagLength - 1. tool_result history-replay goes through adapter.RenderToolResult so families that need a non-tool role (e.g. Llama-3 ipython) replay correctly.
• OpenAI /v1/chat/completions gains full tool support (OpenAI /v1/chat/completions: tool-call wire-format support (parity with /v1/messages) #97): tools / tool_choice request fields, tool_calls array on the assistant message, tool_calls streaming deltas, finish_reason: "tool_calls", history-side role: "tool" echoes via tool_call_id. The buffering state machine activates only when tools are present so the existing no-tools per-chunk streaming cadence is preserved.

Test plan

• 21 adapter unit tests in SharpInference.Tests.Core (registry + Qwen, Qwen3-Coder, Llama, DeepSeek wire formats).
• 7 endpoint tests in SharpInference.Tests.Server: Qwen3-Coder /v1/messages non-stream + stream (closes Tool-call parser misses Qwen3-Coder's bare <function=...> format (no <tool_call> wrapper) #95), OpenAI tool roundtrip non-stream + stream, OpenAI tool history echo, OpenAI no-tools per-chunk cadence regression guard.
• Existing 7 Anthropic tool tests remain green.
• Full suite: 505/505 passing (Core 78, ForwardPass 261, Pipeline 33, TurboQuant 41, Server 92).

Closes #95, #96, #97.

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request introduces a translation layer for LLM tool calls by implementing IToolCallAdapter and concrete adapters for Qwen, Llama, and DeepSeek model families, integrating them into the Anthropic and OpenAI endpoints. The review feedback identifies critical robustness issues, including potential ArgumentOutOfRangeException and NullReferenceException crashes when handling malformed model outputs or request payloads, as well as a memory leak from an undisposed JsonDocument in ParseJsonCallBlock.

[gemini-code-assist]

If the model output is malformed and does not contain a valid function name (e.g., <function=>), nameEnd can be less than or equal to funcStart + funcTag.Length. This causes an ArgumentOutOfRangeException when slicing the string. Adding a guard prevents potential server crashes on untrusted model outputs.

        int nameEnd = block.IndexOf('>', funcStart);
        if (nameEnd < 0 || nameEnd <= funcStart + funcTag.Length) return null;
        string funcName = block[(funcStart + funcTag.Length)..nameEnd].Trim();

[gemini-code-assist]

Similarly to the function name parsing, if a parameter tag is malformed (e.g., <parameter=>), paramNameEnd can be less than or equal to paramStart + paramTag.Length. This leads to an ArgumentOutOfRangeException during slicing. A guard is needed here to safely handle malformed parameters.

            int paramNameEnd = funcBody.IndexOf('>', paramStart);
            if (paramNameEnd < 0 || paramNameEnd <= paramStart + paramTag.Length) break;
            string paramName = funcBody[(paramStart + paramTag.Length)..paramNameEnd].Trim();

[gemini-code-assist]

If a client sends a history message with a tool_calls array where the function property is missing or null, accessing tc.Function.Name or tc.Function.Arguments directly will throw a NullReferenceException. Using null-conditional operators prevents server crashes on malformed request payloads.

                            ["function"] = new Dictionary<string, object?>(StringComparer.Ordinal)
                            {
                                ["name"]      = tc.Function?.Name,
                                // OpenAI stringifies arguments; pass through as-is.
                                ["arguments"] = tc.Function?.Arguments,
                            },

[gemini-code-assist]

If an incoming tool definition in the request payload has a null or missing function object (e.g., {"type": "function"}), accessing t.Function.Name will result in a NullReferenceException. Null-conditional operators should be used to handle such malformed inputs gracefully.

                    ["function"] = new Dictionary<string, object?>(StringComparer.Ordinal)
                    {
                        ["name"]        = t.Function?.Name,
                        ["description"] = t.Function?.Description,
                        ["parameters"]  = t.Function?.Parameters,
                    },

[gemini-code-assist]

JsonDocument.Parse allocates unmanaged resources and implements IDisposable. Failing to dispose of the parsed document results in memory leaks, which can degrade performance over time in high-throughput environments. Wrapping the parsing in a using block resolves this leak.

            object? parsed = null;
            if (argsElem.ValueKind == JsonValueKind.String)
            {
                using var innerDoc = JsonDocument.Parse(argsElem.GetString() ?? "{}");
                parsed = JsonElementToObject(innerDoc.RootElement);
            }
            else
            {
                parsed = JsonElementToObject(argsElem);
            }