From dbe825993760127f83cf65b7d96c83c35b401d39 Mon Sep 17 00:00:00 2001
From: Kyzcreig <9063726+Kyzcreig@users.noreply.github.com>
Date: Thu, 2 Jul 2026 07:32:51 -0700
Subject: [PATCH 1/3] feat(tui_gateway): client-identity source so
 desktop/dashboard/mobile aren't all "tui"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The desktop app, the in-browser dashboard chat, and the Ink stdio TUI all drive
the same tui_gateway JSON-RPC server, which hardcoded platform="tui" on every
agent it built. So every desktop-app turn recorded platform="tui" in blackbox
(turns.platform) — the source dimension on the token/cost dashboard couldn't
tell the desktop client from the terminal, and a future mobile app would fold
in too.

Let a client self-declare a `source` on session.create/resume; thread it
through _make_agent -> AIAgent(platform=...) (which already feeds the blackbox
on_session_end hook), and store it on the session dict so the deferred/lazy
build, /new reset, resume, and branch paths all preserve it. `source` is
untrusted client input feeding a persisted DB dimension, so it is sanitized to
a conservative slug (`^[a-z][a-z0-9_-]{0,23}$`) with a `tui` fallback — the
label stays open-ended (new clients name themselves; no central enum to keep in
sync, per the existing "fixed set of platform names goes stale" note).

Desktop app: stamp source:'desktop' once, centrally, in the requestGateway
wrapper for the session-originating methods (create/resume) — never overriding
an explicit caller source (e.g. the dashboard sidecar's 'tool').

No schema/blackbox change (the platform pipe already existed); stdio Ink and
internal rebuilds keep the historical "tui" default so nothing regresses.
Historical desktop turns are indistinguishable from real TUI turns, so the
clean split starts at deploy (no backfill possible).

Tests: tui_gateway/test_client_source_platform.py (sanitizer table + _make_agent
platform derivation); desktop use-gateway-request.test.tsx (injection contract:
stamps create/resume, skips other methods, never overrides explicit source).
---
 .../hooks/use-gateway-request.test.tsx        |  94 +++++++++++++++
 .../app/gateway/hooks/use-gateway-request.ts  |  26 ++++-
 .../test_client_source_platform.py            | 107 ++++++++++++++++++
 tests/tui_gateway/test_protocol.py            |  10 +-
 tui_gateway/server.py                         |  72 +++++++++++-
 5 files changed, 298 insertions(+), 11 deletions(-)
 create mode 100644 apps/desktop/src/app/gateway/hooks/use-gateway-request.test.tsx
 create mode 100644 tests/tui_gateway/test_client_source_platform.py

diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-request.test.tsx b/apps/desktop/src/app/gateway/hooks/use-gateway-request.test.tsx
new file mode 100644
index 0000000000000..ebb960fa5ed05
--- /dev/null
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-request.test.tsx
@@ -0,0 +1,94 @@
+import { act, cleanup, render } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $gateway } from '@/store/gateway'
+import { $gatewayState } from '@/store/session'
+
+import { useGatewayRequest } from './use-gateway-request'
+
+// The desktop app, dashboard SPA, and Ink stdio TUI all drive the same backend
+// JSON-RPC server, which historically stamped every turn platform="tui". This
+// hook now tags SESSION-ORIGINATING calls with source:'desktop' so the backend
+// attributes turns to the desktop client (→ blackbox turns.platform →
+// tokens.ace source chart). These tests pin that contract.
+
+type RequestCall = { method: string; params: Record<string, unknown> }
+
+function mountHook() {
+  const calls: RequestCall[] = []
+  const fakeGateway = {
+    request: vi.fn(async (method: string, params: Record<string, unknown>) => {
+      calls.push({ method, params })
+      return { ok: true }
+    })
+  }
+
+  let requestGateway!: ReturnType<typeof useGatewayRequest>['requestGateway']
+  function Probe() {
+    requestGateway = useGatewayRequest().requestGateway
+    return null
+  }
+
+  // The hook reads the active gateway from the $gateway store.
+  $gatewayState.set('open')
+  $gateway.set(fakeGateway as never)
+  render(<Probe />)
+
+  return { calls, fakeGateway, requestGateway: () => requestGateway }
+}
+
+describe('useGatewayRequest — client source tagging', () => {
+  beforeEach(() => {
+    $gatewayState.set('open')
+  })
+
+  afterEach(() => {
+    cleanup()
+    $gateway.set(null)
+    vi.restoreAllMocks()
+  })
+
+  it("stamps source:'desktop' on session.create", async () => {
+    const { calls, requestGateway } = mountHook()
+
+    await act(async () => {
+      await requestGateway()('session.create', { cols: 96 })
+    })
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toMatchObject({
+      method: 'session.create',
+      params: { cols: 96, source: 'desktop' }
+    })
+  })
+
+  it("stamps source:'desktop' on session.resume", async () => {
+    const { calls, requestGateway } = mountHook()
+
+    await act(async () => {
+      await requestGateway()('session.resume', { session_id: 's1' })
+    })
+
+    expect(calls[0].params).toMatchObject({ session_id: 's1', source: 'desktop' })
+  })
+
+  it('does NOT add source to non-session-originating methods', async () => {
+    const { calls, requestGateway } = mountHook()
+
+    await act(async () => {
+      await requestGateway()('session.steer', { session_id: 's1', text: 'hi' })
+    })
+
+    expect(calls[0].params).not.toHaveProperty('source')
+  })
+
+  it('never overrides an explicit caller-provided source', async () => {
+    const { calls, requestGateway } = mountHook()
+
+    await act(async () => {
+      await requestGateway()('session.create', { source: 'tool', close_on_disconnect: true })
+    })
+
+    expect(calls[0].params).toMatchObject({ source: 'tool' })
+  })
+})
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-request.ts b/apps/desktop/src/app/gateway/hooks/use-gateway-request.ts
index d6c9ab0e029bc..e568a4c1808b5 100644
--- a/apps/desktop/src/app/gateway/hooks/use-gateway-request.ts
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-request.ts
@@ -7,6 +7,17 @@ import { $gateway, ensureActiveGatewayOpen, isActivePrimary } from '@/store/gate
 import { $activeGatewayProfile } from '@/store/profile'
 import { $gatewayState, setConnection } from '@/store/session'
 
+// This client's source label, threaded to the backend on session-originating
+// RPCs so turns from the desktop app are attributed to "desktop" rather than
+// the shared "tui" default. The backend sanitizes it (see
+// tui_gateway.server._sanitize_client_source).
+const CLIENT_SOURCE = 'desktop'
+
+// RPC methods that MINT or (RE)ATTACH a session and therefore build an agent
+// whose platform should carry the client label. Other methods (steer, title,
+// usage, …) act on an existing session and ignore a `source` field.
+const SESSION_ORIGIN_METHODS = new Set(['session.create', 'session.resume'])
+
 export function useGatewayRequest() {
   const gatewayState = useStore($gatewayState)
   const gatewayRef = useRef<HermesGateway | null>(null)
@@ -101,8 +112,19 @@ export function useGatewayRequest() {
         throw new Error('Hermes gateway unavailable')
       }
 
+      // Tag session-originating calls with this client so the backend records
+      // the turn's platform/source as "desktop" instead of the shared "tui"
+      // default (the desktop app, dashboard, and Ink TUI all drive the same
+      // JSON-RPC server). Only stamp when the caller hasn't set an explicit
+      // source, and only on the methods that mint/attach a session — every
+      // other RPC ignores the field.
+      const outbound =
+        SESSION_ORIGIN_METHODS.has(method) && params.source === undefined
+          ? { ...params, source: CLIENT_SOURCE }
+          : params
+
       try {
-        return await gateway.request<T>(method, params, timeoutMs, signal)
+        return await gateway.request<T>(method, outbound, timeoutMs, signal)
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
 
@@ -128,7 +150,7 @@ export function useGatewayRequest() {
           throw error
         }
 
-        return recovered.request<T>(method, params, timeoutMs, signal)
+        return recovered.request<T>(method, outbound, timeoutMs, signal)
       }
     },
     [ensureGatewayOpen]
diff --git a/tests/tui_gateway/test_client_source_platform.py b/tests/tui_gateway/test_client_source_platform.py
new file mode 100644
index 0000000000000..01dd95d71148f
--- /dev/null
+++ b/tests/tui_gateway/test_client_source_platform.py
@@ -0,0 +1,107 @@
+"""Client-source → platform attribution for the shared tui_gateway server.
+
+The desktop app, dashboard SPA, Ink stdio TUI, and (future) mobile client all
+drive the same JSON-RPC ``tui_gateway.server``. Before this feature every one of
+them recorded turns as ``platform="tui"``; a client now self-declares a
+``source`` on session.create/resume and it must:
+
+  * flow through ``_make_agent`` to ``AIAgent(platform=...)`` (→ blackbox
+    ``turns.platform`` → tokens.ace source chart), and
+  * be sanitized, because it is untrusted client input feeding a persisted DB
+    dimension.
+
+These are behavior contracts (how source relates to the agent's platform), not
+snapshots of a frozen value. Mirrors test_make_agent_provider.py's import style
+(no sys.modules patching — that stubs get_hermes_home to a str and breaks the
+tool-registry imports _make_agent pulls in).
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# _sanitize_client_source — the untrusted-input guard
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "raw,expected",
+    [
+        ("desktop", "desktop"),
+        ("dashboard", "dashboard"),
+        ("mobile", "mobile"),
+        ("tui", "tui"),
+        ("DESKTOP", "desktop"),  # case-normalized
+        ("  desktop  ", "desktop"),  # trimmed
+        ("web-app_2", "web-app_2"),  # allowed slug chars
+        # Rejected → fall back to the stdio default, never raw-through:
+        ("", "tui"),
+        (None, "tui"),
+        ("tui; DROP TABLE turns", "tui"),  # spaces/punctuation rejected
+        ("<script>", "tui"),
+        ("has spaces", "tui"),
+        ("1leading-digit", "tui"),  # must start with a letter
+        ("x" * 40, "tui"),  # over length cap
+        (123, "tui"),  # non-string
+    ],
+)
+def test_sanitize_client_source(raw, expected):
+    from tui_gateway.server import _sanitize_client_source
+
+    assert _sanitize_client_source(raw) == expected
+
+
+# ---------------------------------------------------------------------------
+# _make_agent — source drives the agent's platform
+# ---------------------------------------------------------------------------
+
+
+def _make_agent_platform_for_source(source):
+    """Invoke _make_agent with the heavy deps stubbed; return AIAgent's platform."""
+    fake_runtime = {
+        "provider": "anthropic",
+        "base_url": "https://api.anthropic.com",
+        "api_key": "sk-test",
+        "api_mode": "anthropic_messages",
+        "command": None,
+        "args": None,
+        "credential_pool": None,
+    }
+    fake_cfg = {
+        "model": {"default": "claude-opus-4-8", "provider": "anthropic"},
+        "agent": {"system_prompt": "test"},
+    }
+    with (
+        patch("tui_gateway.server._load_cfg", return_value=fake_cfg),
+        patch("tui_gateway.server._get_db", return_value=MagicMock()),
+        patch("tui_gateway.server._load_tool_progress_mode", return_value="compact"),
+        patch("tui_gateway.server._load_reasoning_config", return_value=None),
+        patch("tui_gateway.server._load_service_tier", return_value=None),
+        patch("tui_gateway.server._load_enabled_toolsets", return_value=None),
+        patch(
+            "hermes_cli.runtime_provider.resolve_runtime_provider",
+            return_value=fake_runtime,
+        ),
+        patch("run_agent.AIAgent") as mock_agent,
+    ):
+        from tui_gateway.server import _make_agent
+
+        _make_agent("sid-1", "key-1", source=source)
+        return mock_agent.call_args.kwargs["platform"]
+
+
+def test_make_agent_source_becomes_platform():
+    """A declared client source is the agent's platform verbatim."""
+    assert _make_agent_platform_for_source("desktop") == "desktop"
+
+
+def test_make_agent_default_source_is_tui():
+    """No source (stdio Ink / internal rebuild) keeps the historical default."""
+    assert _make_agent_platform_for_source(None) == "tui"
+
+
+def test_make_agent_sanitizes_hostile_source():
+    """_make_agent doesn't trust its caller: a malformed source → tui."""
+    assert _make_agent_platform_for_source("not a slug!") == "tui"
diff --git a/tests/tui_gateway/test_protocol.py b/tests/tui_gateway/test_protocol.py
index 170e78aec643b..fe119c2b9060c 100644
--- a/tests/tui_gateway/test_protocol.py
+++ b/tests/tui_gateway/test_protocol.py
@@ -315,7 +315,7 @@ def get_messages_as_conversation(self, _sid, include_ancestors=False):
             ]
 
     monkeypatch.setattr(server, "_get_db", lambda: _DB())
-    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_id=None, session_db=None: object())
+    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_id=None, session_db=None, **_kw: object())
     monkeypatch.setattr(server, "_init_session", lambda sid, key, agent, history, cols=80, **_kwargs: None)
     monkeypatch.setattr(server, "_session_info", lambda _agent, _session=None: {"model": "test/model"})
 
@@ -509,7 +509,7 @@ def get_messages_as_conversation(self, _sid, include_ancestors=False):
             return [multimodal_user, text_only_assistant]
 
     monkeypatch.setattr(server, "_get_db", lambda: _DB())
-    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_id=None, session_db=None: object())
+    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_id=None, session_db=None, **_kw: object())
     monkeypatch.setattr(server, "_init_session", lambda sid, key, agent, history, cols=80, **_kwargs: None)
     monkeypatch.setattr(server, "_session_info", lambda _agent, _session=None: {"model": "test/model"})
 
@@ -795,7 +795,7 @@ def __init__(self, sid, session_id):
         def close(self):
             closed_sids.append(self.sid)
 
-    def make_agent(sid, key, session_id=None, session_db=None):
+    def make_agent(sid, key, session_id=None, session_db=None, **_kw):
         created_sids.append(sid)
         first_agent_started.set()
         assert agent_can_finish.wait(timeout=1)
@@ -1006,7 +1006,7 @@ def close(self):
     monkeypatch.setattr(
         server,
         "_make_agent",
-        lambda _sid, key, session_id=None, session_db=None: types.SimpleNamespace(
+        lambda _sid, key, session_id=None, session_db=None, **_kw: types.SimpleNamespace(
             model="test/model", session_id=session_id or key
         ),
     )
@@ -1144,7 +1144,7 @@ def set_session_title(self, _key, _title):
     monkeypatch.setattr(
         server,
         "_make_agent",
-        lambda _sid, key, session_id=None, session_db=None: types.SimpleNamespace(
+        lambda _sid, key, session_id=None, session_db=None, **_kw: types.SimpleNamespace(
             model="test/model", session_id=session_id or key
         ),
     )
diff --git a/tui_gateway/server.py b/tui_gateway/server.py
index f9f97cdc5c557..c9182e1f9cc20 100644
--- a/tui_gateway/server.py
+++ b/tui_gateway/server.py
@@ -8,6 +8,7 @@
 import logging
 import os
 import queue
+import re
 import subprocess
 import sys
 import threading
@@ -1206,6 +1207,10 @@ def _build() -> None:
                 # id — pass it through so the upgrade continues that session
                 # instead of starting a fresh one under the same key.
                 kw = {"session_db": session_db}
+                # The deferred build happens turns after session.create/resume,
+                # so carry the originating client (desktop/dashboard/…) off the
+                # session dict rather than losing it to the "tui" default.
+                kw["source"] = _session_source(current)
                 if resume_sid := current.get("resume_session_id"):
                     kw["session_id"] = resume_sid
                 resume_overrides = current.get("resume_runtime_overrides")
@@ -1475,6 +1480,27 @@ def _display_session_cwd(session: dict | None) -> str:
     return healed
 
 
+# A client (Ink stdio, desktop app, dashboard SPA, future mobile) may name
+# itself via the ``source`` param on session.create/resume so telemetry and the
+# blackbox ``platform`` dimension can tell them apart — they all share this one
+# JSON-RPC server, so without a self-declared label every client records as
+# "tui". The label is free-form (new clients name themselves; no central enum to
+# keep in sync — see the "fixed set of platform names goes stale" note below),
+# but it flows into a persisted DB dimension, so it is sanitized to a short
+# slug and anything malformed/absent falls back to "tui" (the stdio default).
+_CLIENT_SOURCE_RE = re.compile(r"^[a-z][a-z0-9_-]{0,23}$")
+
+
+def _sanitize_client_source(raw: object) -> str:
+    """Normalize a client-declared source label; fall back to ``tui``.
+
+    Untrusted client input feeds a persisted ``source``/``platform`` value, so
+    lowercase, strip, and accept only a conservative slug; reject → ``tui``.
+    """
+    label = str(raw or "").strip().lower()
+    return label if _CLIENT_SOURCE_RE.match(label) else "tui"
+
+
 def _session_source(session: dict | None) -> str:
     if session:
         source = str(session.get("source") or "").strip()
@@ -4036,6 +4062,8 @@ def _reset_session_agent(sid: str, session: dict) -> dict:
             # session set). See the cross-session-contamination note in
             # _apply_model_switch.
             model_override=session.get("model_override"),
+            # Preserve the originating client (desktop/dashboard/…) across /new.
+            source=_session_source(session),
         )
     finally:
         _clear_session_context(tokens)
@@ -4184,6 +4212,7 @@ def _make_agent(
     provider_override: str | None = None,
     reasoning_config_override: dict | None = None,
     service_tier_override: str | None = None,
+    source: str | None = None,
 ):
     from run_agent import AIAgent
 
@@ -4326,7 +4355,10 @@ def _make_agent(
         provider_sort=_pr.get("sort"),
         provider_require_parameters=_pr.get("require_parameters", False),
         provider_data_collection=_pr.get("data_collection"),
-        platform="tui",
+        # Which client drove this session (desktop / dashboard / mobile / tui).
+        # Sanitized at the RPC edge; ``None`` (stdio Ink, internal rebuilds)
+        # keeps the historical "tui" default so nothing regresses.
+        platform=_sanitize_client_source(source),
         session_id=session_id or key,
         session_db=session_db if session_db is not None else _get_db(),
         ephemeral_system_prompt=system_prompt or None,
@@ -4347,6 +4379,7 @@ def _init_session(
     cols: int = 80,
     cwd: str | None = None,
     session_db=None,
+    source: str | None = None,
 ):
     now = time.time()
     with _sessions_lock:
@@ -4373,6 +4406,11 @@ def _init_session(
             # Honored on rebuild (/new, resume) so a switch in THIS session
             # never leaks into siblings via process-global env vars.
             "model_override": None,
+            # Originating client (desktop/dashboard/mobile/tui). Keeps this
+            # session dict's source in step with the agent's platform so a turn's
+            # HERMES_SESSION_SOURCE (DB-row source) and blackbox platform agree.
+            # None (stdio Ink, internal rebuilds) → the historical "tui" default.
+            "source": _sanitize_client_source(source),
             # Pin async event emissions to whichever transport created the
             # session (stdio for Ink, JSON-RPC WS for the dashboard sidebar).
             "transport": current_transport() or _stdio_transport,
@@ -4876,7 +4914,7 @@ def _(rid, params: dict) -> dict:
     except Exception:
         explicit_cwd = False
     resolved_cwd = _completion_cwd(params)
-    source = str(params.get("source") or "tui").strip() or "tui"
+    source = _sanitize_client_source(params.get("source"))
     _enable_gateway_prompts()
 
     # ``profile`` (app-global remote mode): a new chat started under a non-launch
@@ -5506,6 +5544,12 @@ def _reuse_live_payload(sid: str, session: dict) -> dict:
                 target,
                 session_id=target,
                 session_db=db,
+                # Prefer the client's declared source on this resume; else keep
+                # the label the session was persisted with (never silently
+                # relabel a desktop/dashboard session to "tui" on resume).
+                source=_sanitize_client_source(
+                    params.get("source") or found.get("source")
+                ),
                 **stored_runtime_overrides,
             )
         finally:
@@ -5556,6 +5600,9 @@ def _reuse_live_payload(sid: str, session: dict) -> dict:
                     cols=cols,
                     cwd=profile_resume_cwd,
                     session_db=db,
+                    source=_sanitize_client_source(
+                        params.get("source") or found.get("source")
+                    ),
                 )
             finally:
                 if init_home_token is not None:
@@ -7876,11 +7923,28 @@ def _(rid, params: dict) -> dict:
     try:
         tokens = _set_session_context(new_key)
         try:
-            agent = _make_agent(new_sid, new_key, session_id=new_key)
+            agent = _make_agent(
+                new_sid,
+                new_key,
+                session_id=new_key,
+                # A branch inherits its parent's client label unless the caller
+                # names one explicitly, so a forked chat stays attributed to the
+                # desktop/dashboard it was branched from.
+                source=_sanitize_client_source(
+                    params.get("source") or _session_source(session)
+                ),
+            )
         finally:
             _clear_session_context(tokens)
         _init_session(
-            new_sid, new_key, agent, list(history), cols=session.get("cols", 80)
+            new_sid,
+            new_key,
+            agent,
+            list(history),
+            cols=session.get("cols", 80),
+            source=_sanitize_client_source(
+                params.get("source") or _session_source(session)
+            ),
         )
         if new_sid in _sessions:
             _sessions[new_sid]["active_session_lease"] = lease

From 2d737f2ba8b414f2987c4a69de89e3e4ea8228c8 Mon Sep 17 00:00:00 2001
From: Kyzcreig <9063726+Kyzcreig@users.noreply.github.com>
Date: Thu, 2 Jul 2026 07:40:42 -0700
Subject: [PATCH 2/3] =?UTF-8?q?test:=20accept=20=5Fmake=5Fagent(source=3D?=
 =?UTF-8?q?=E2=80=A6)=20in=20remaining=20narrow=20test=20fakes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The new source kwarg on _make_agent tripped three narrow monkeypatch fakes in
tests/test_tui_gateway_server.py (session_id/session_db-only signatures). Widen
them to **_kw so they tolerate the new kwarg, matching the sibling fakes that
already splat. No behavior change.
---
 tests/test_tui_gateway_server.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_tui_gateway_server.py b/tests/test_tui_gateway_server.py
index a099e0fb05145..c6d493e60f9a7 100644
--- a/tests/test_tui_gateway_server.py
+++ b/tests/test_tui_gateway_server.py
@@ -5372,7 +5372,7 @@ def __init__(self):
     release_build = threading.Event()
     build_entered = threading.Event()
 
-    def _slow_make_agent(sid, key, session_id=None, session_db=None):
+    def _slow_make_agent(sid, key, session_id=None, session_db=None, **_kw):
         build_started.set()
         build_entered.set()
         release_build.wait(timeout=3.0)
@@ -5494,7 +5494,7 @@ def __init__(self):
             self.base_url = ""
             self.api_key = ""
 
-    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_db=None: _FakeAgent())
+    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_db=None, **_kw: _FakeAgent())
     monkeypatch.setattr(server, "_SlashWorker", _FakeWorker)
     monkeypatch.setattr(
         server,
@@ -5611,7 +5611,7 @@ def __init__(self):
 
     emits = []
 
-    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_db=None: _FakeAgent())
+    monkeypatch.setattr(server, "_make_agent", lambda sid, key, session_db=None, **_kw: _FakeAgent())
     monkeypatch.setattr(server, "_SlashWorker", _FakeWorker)
     monkeypatch.setattr(server, "_get_db", lambda: None)
     monkeypatch.setattr(server, "_session_info", lambda _a, *a2: {"model": "x"})

From 36faa684cf1442ccbfb97acf7258cfcdad48bf16 Mon Sep 17 00:00:00 2001
From: Kyzcreig <9063726+Kyzcreig@users.noreply.github.com>
Date: Thu, 2 Jul 2026 07:42:09 -0700
Subject: [PATCH 3/3] fix(tui_gateway): reject non-str source (Greptile P2)

_sanitize_client_source used str(raw or ''), so a JSON-RPC boolean true would
coerce to the slug 'true' instead of falling back to 'tui'. Guard with
isinstance(raw, str) up front; add True/0/[] cases to the sanitizer table.
---
 tests/tui_gateway/test_client_source_platform.py | 3 +++
 tui_gateway/server.py                            | 8 ++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/tests/tui_gateway/test_client_source_platform.py b/tests/tui_gateway/test_client_source_platform.py
index 01dd95d71148f..411dbed24b741 100644
--- a/tests/tui_gateway/test_client_source_platform.py
+++ b/tests/tui_gateway/test_client_source_platform.py
@@ -45,6 +45,9 @@
         ("1leading-digit", "tui"),  # must start with a letter
         ("x" * 40, "tui"),  # over length cap
         (123, "tui"),  # non-string
+        (True, "tui"),  # a JSON-RPC `true` must NOT coerce to the slug "true"
+        (0, "tui"),  # non-string falsy
+        ([], "tui"),  # non-string container
     ],
 )
 def test_sanitize_client_source(raw, expected):
diff --git a/tui_gateway/server.py b/tui_gateway/server.py
index c9182e1f9cc20..d72cc9c683674 100644
--- a/tui_gateway/server.py
+++ b/tui_gateway/server.py
@@ -1495,9 +1495,13 @@ def _sanitize_client_source(raw: object) -> str:
     """Normalize a client-declared source label; fall back to ``tui``.
 
     Untrusted client input feeds a persisted ``source``/``platform`` value, so
-    lowercase, strip, and accept only a conservative slug; reject → ``tui``.
+    accept only a genuine ``str`` (a JSON-RPC ``true``/``0`` is not a source
+    label — guard with ``isinstance`` so ``True`` can't coerce to ``"true"``),
+    lowercase, strip, and require a conservative slug; anything else → ``tui``.
     """
-    label = str(raw or "").strip().lower()
+    if not isinstance(raw, str):
+        return "tui"
+    label = raw.strip().lower()
     return label if _CLIENT_SOURCE_RE.match(label) else "tui"