fix(openai): tolerate empty/null fields in streaming tool-call deltas (pgadmin-org#9828)

Some OpenAI-compatible providers emit empty or null name/arguments/id
fields in streaming continuation deltas to keep the response schema
stable. pgAdmin's accumulator overwrote the real tool name (captured in
the first delta) with the later null, producing a tool call named "null"
that could not be dispatched.

Skip falsy name/arguments/id when accumulating (matching the OpenAI
Python SDK, which ignores nulls the same way) so the values captured in
the first delta survive. Also guard against a null `function` object in
a delta, which previously raised TypeError. Without the id guard a null
id in a continuation delta clobbered the real id, which the final build
then replaced with a random uuid rather than the provider's id.

Adds a unit test covering the null-continuation, multi-chunk-arguments,
and null-function cases, and a 9.16 release note.

Author: tcx4c70

docs/en_US/release_notes_9_16.rst

@@ -33,6 +33,7 @@ Bug fixes
 *********
 
   | `Issue #9677 <https://github.com/pgadmin-org/pgadmin4/issues/9677>`_ -  Fix the Unlogged table toggle in table properties not generating any ALTER TABLE ... SET LOGGED/UNLOGGED statement.
+  | `Issue #9828 <https://github.com/pgadmin-org/pgadmin4/issues/9828>`_ -  Fix tool calls failing against OpenAI-compatible providers that emit empty/null name, arguments, or id fields in streaming continuation deltas.
   | `Issue #9892 <https://github.com/pgadmin-org/pgadmin4/issues/9892>`_ -  Fix blank difference counts on the top-level group rows in Schema Diff.
   | `Issue #9896 <https://github.com/pgadmin-org/pgadmin4/issues/9896>`_ -  Fix invalid DDL reconstruction for SERIAL columns in Schema Diff and the generated SQL/CREATE Script so the output round-trips on a clean target.
   | `Issue #9935 <https://github.com/pgadmin-org/pgadmin4/issues/9935>`_ -  Fix "Illegal instruction" crash on startup of the Linux DEB and RPM packages on older x86_64 CPUs by pinning the psycopg C extension build to the x86-64 baseline.

web/pgadmin/llm/providers/openai.py

@@ -780,12 +780,16 @@ def _read_openai_stream(
                         'id': '', 'name': '', 'arguments': ''
                     }
                 tc = tool_calls_data[idx]
-                if 'id' in tc_delta:
+                # Some providers emit empty/null fields in continuation
+                # deltas to keep the schema stable; skip them so a later
+                # null doesn't clobber the real id/name captured earlier
+                # (see the OpenAI SDK, which skips nulls the same way).
+                if tc_delta.get('id'):
                     tc['id'] = tc_delta['id']
-                func = tc_delta.get('function', {})
-                if 'name' in func:
+                func = tc_delta.get('function') or {}
+                if func.get('name'):
                     tc['name'] = func['name']
-                if 'arguments' in func:
+                if func.get('arguments'):
                     tc['arguments'] += func['arguments']
 
         # Build final response

web/pgadmin/llm/tests/test_openai_stream.py

@@ -0,0 +1,120 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2026, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+"""Tests for OpenAI streaming tool-call accumulation."""
+
+import json
+
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.llm.models import LLMResponse
+from pgadmin.llm.providers.openai import OpenAIClient
+
+
+class _FakeStream:
+    """Minimal response stand-in exposing readline() over SSE lines."""
+
+    def __init__(self, lines):
+        # Each yielded line mimics the bytes a real socket returns,
+        # including the trailing newline the parser strips.
+        self._lines = [(line + '\n').encode('utf-8') for line in lines]
+        self._idx = 0
+
+    def readline(self):
+        if self._idx >= len(self._lines):
+            return b''
+        line = self._lines[self._idx]
+        self._idx += 1
+        return line
+
+
+def _sse(obj):
+    return 'data: ' + json.dumps(obj)
+
+
+class OpenAIStreamToolCallTestCase(BaseTestGenerator):
+    """Accumulating tool-call deltas must tolerate empty/null fields."""
+
+    scenarios = [
+        ('Null name/id in continuation delta is ignored', dict(
+            stream=[
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'role': 'assistant',
+                    'tool_calls': [{
+                        'index': 0, 'id': 'call_abc',
+                        'function': {'name': 'get_database_schema',
+                                     'arguments': ''}}]}}]}),
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'tool_calls': [{
+                        'index': 0, 'id': None,
+                        'function': {'name': None,
+                                     'arguments': '{}'}}]}}]}),
+                _sse({'choices': [{'index': 0,
+                                   'finish_reason': 'tool_calls',
+                                   'delta': {}}]}),
+                'data: [DONE]',
+            ],
+            expected_name='get_database_schema',
+            expected_arguments={},
+            expected_id='call_abc',
+        )),
+        ('Arguments streamed across chunks are concatenated', dict(
+            stream=[
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'tool_calls': [{
+                        'index': 0, 'id': 'call_xyz',
+                        'function': {'name': 'run_query',
+                                     'arguments': '{"sql":'}}]}}]}),
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'tool_calls': [{
+                        'index': 0,
+                        'function': {'arguments': '"SELECT 1"}'}}]}}]}),
+                _sse({'choices': [{'index': 0,
+                                   'finish_reason': 'tool_calls',
+                                   'delta': {}}]}),
+                'data: [DONE]',
+            ],
+            expected_name='run_query',
+            expected_arguments={'sql': 'SELECT 1'},
+            expected_id='call_xyz',
+        )),
+        ('Null function object in a delta does not raise', dict(
+            stream=[
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'tool_calls': [{
+                        'index': 0, 'id': 'call_1',
+                        'function': {'name': 'noop',
+                                     'arguments': '{}'}}]}}]}),
+                _sse({'choices': [{'index': 0, 'delta': {
+                    'tool_calls': [{'index': 0, 'function': None}]}}]}),
+                _sse({'choices': [{'index': 0,
+                                   'finish_reason': 'tool_calls',
+                                   'delta': {}}]}),
+                'data: [DONE]',
+            ],
+            expected_name='noop',
+            expected_arguments={},
+            expected_id='call_1',
+        )),
+    ]
+
+    def runTest(self):
+        client = OpenAIClient(api_key='test-key', model='gpt-4o')
+        result = None
+        for item in client._read_openai_stream(_FakeStream(self.stream)):
+            if isinstance(item, LLMResponse):
+                result = item
+
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.tool_calls), 1)
+        tc = result.tool_calls[0]
+        self.assertEqual(tc.name, self.expected_name)
+        self.assertEqual(tc.arguments, self.expected_arguments)
+        # The real provider id must survive a null id in a later delta,
+        # rather than being clobbered (and replaced by a random uuid).
+        self.assertEqual(tc.id, self.expected_id)