1
"""Test ToolRouter functionality."""
2
3
+import logging
4
+import os
5
import typing as t
6
from unittest.mock import MagicMock, patch
7
8
import httpx
9
import pytest
8
-from composio_client import omit
10
+from composio_client import ConflictError, omit
11
from pydantic import BaseModel, Field
12
13
from composio.client import HttpClient
30
ToolRouterSession,
31
ToolRouterSessionWithMcp,
32
)
31
-from composio.exceptions import InvalidParams, ValidationError
33
+from composio.exceptions import (
34
+ InvalidParams,
35
+ MCPDestinationError,
36
+ SessionConfigConflictError,
37
+ ValidationError,
38
+)
39
40
experimental_api = ExperimentalAPI()
41
49
"""Create a mock HTTP client."""
50
client = MagicMock()
51
client.api_key = "test-api-key"
52
+ client.user_api_key = None
53
+ client.base_url = httpx.URL("https://backend.composio.dev")
54
+ client.default_headers = {}
55
56
# Mock session responses
57
mock_session_response = MagicMock()
58
mock_session_response.session_id = "session_123"
59
+ mock_session_response.config_version = 7
60
mock_session_response.mcp = MagicMock()
61
mock_session_response.mcp.type = "http"
51
- mock_session_response.mcp.url = "https://mcp.example.com/session_123"
62
+ mock_session_response.mcp.url = (
63
+ "https://backend.composio.dev/api/v3/tool_router/session/session_123"
64
+ )
65
mock_session_response.tool_router_tools = [
66
"GMAIL_FETCH_EMAILS",
67
"SLACK_SEND_MESSAGE",
160
# Verify session properties
161
assert session.session_id == "session_123"
162
assert session.mcp.type == ToolRouterMCPServerType.HTTP
150
- assert session.mcp.url == "https://mcp.example.com/session_123"
163
+ assert (
164
+ session.mcp.url
165
+ == "https://backend.composio.dev/api/v3/tool_router/session/session_123"
166
+ )
167
assert session.mcp.headers == {"x-api-key": "test-api-key"}
168
assert callable(session.tools)
169
assert callable(session.authorize)
189
assert isinstance(session, ToolRouterSessionWithMcp)
190
# The MCP endpoint is populated on the runtime object either way.
191
assert session.mcp.type == ToolRouterMCPServerType.HTTP
176
- assert session.mcp.url == "https://mcp.example.com/session_123"
192
+ assert (
193
+ session.mcp.url
194
+ == "https://backend.composio.dev/api/v3/tool_router/session/session_123"
195
+ )
196
197
def test_use_session_default_returns_base_session(self, tool_router):
198
"""Default use() (mcp omitted) returns the base ToolRouterSession."""
206
session = tool_router.use("session_123", mcp=True)
207
208
assert isinstance(session, ToolRouterSessionWithMcp)
190
- assert session.mcp.url == "https://mcp.example.com/session_123"
209
+ assert (
210
+ session.mcp.url
211
+ == "https://backend.composio.dev/api/v3/tool_router/session/session_123"
212
+ )
213
214
def test_delete_session_by_id(self, tool_router, mock_client):
215
"""delete() removes a session by ID."""
1059
mock_response_with_experimental.session_id = "session_exp"
1060
mock_response_with_experimental.mcp = MagicMock()
1061
mock_response_with_experimental.mcp.type = "http"
1040
- mock_response_with_experimental.mcp.url = "https://mcp.example.com/session_exp"
1062
+ mock_response_with_experimental.mcp.url = (
1063
+ "https://backend.composio.dev/api/v3/tool_router/session/session_exp"
1064
+ )
1065
mock_response_with_experimental.tool_router_tools = ["TOOL_1"]
1066
mock_response_with_experimental.experimental = MagicMock()
1067
mock_response_with_experimental.experimental.assistive_prompt = (
1127
# Verify session properties
1128
assert session.session_id == "session_123"
1129
assert session.mcp.type == ToolRouterMCPServerType.HTTP
1106
- assert session.mcp.url == "https://mcp.example.com/session_123"
1130
+ assert (
1131
+ session.mcp.url
1132
+ == "https://backend.composio.dev/api/v3/tool_router/session/session_123"
1133
+ )
1134
assert session.mcp.headers == {"x-api-key": "test-api-key"}
1135
assert session.experimental.files is not None
1136
assert hasattr(session.experimental.files, "list")
1350
mock_attach_response.session_id = "session_456"
1351
mock_attach_response.mcp = MagicMock()
1352
mock_attach_response.mcp.type = "http"
1326
- mock_attach_response.mcp.url = "https://mcp.example.com/session_456"
1353
+ mock_attach_response.mcp.url = (
1354
+ "https://backend.composio.dev/api/v3/tool_router/session/session_456"
1355
+ )
1356
mock_attach_response.tool_router_tools = ["TOOL_1"]
1357
mock_attach_response.config = MagicMock()
1358
mock_attach_response.config.user_id = "custom_user_789"
1748
mock_sse_response.session_id = "session_sse"
1749
mock_sse_response.mcp = MagicMock()
1750
mock_sse_response.mcp.type = "sse"
1722
- mock_sse_response.mcp.url = "https://mcp.example.com/sse/session_sse"
1751
+ mock_sse_response.mcp.url = (
1752
+ "https://backend.composio.dev/api/v3/tool_router/session/sse/session_sse"
1753
+ )
1754
mock_sse_response.tool_router_tools = ["TOOL_1"]
1755
1756
mock_client.tool_router.session.create.return_value = mock_sse_response
1759
1760
assert session.mcp.type == ToolRouterMCPServerType.SSE
1761
assert session.mcp.type.value == "sse"
1731
- assert session.mcp.url == "https://mcp.example.com/sse/session_sse"
1762
+ assert (
1763
+ session.mcp.url
1764
+ == "https://backend.composio.dev/api/v3/tool_router/session/sse/session_sse"
1765
+ )
1766
1767
def test_multiple_sessions_independently(self, tool_router, mock_client):
1768
"""Test that multiple sessions can be created independently."""
1770
mock_session_1.session_id = "session_1"
1771
mock_session_1.mcp = MagicMock()
1772
mock_session_1.mcp.type = "http"
1739
- mock_session_1.mcp.url = "https://mcp.example.com/session_1"
1773
+ mock_session_1.mcp.url = (
1774
+ "https://backend.composio.dev/api/v3/tool_router/session/session_1"
1775
+ )
1776
mock_session_1.tool_router_tools = ["TOOL_1"]
1777
1778
mock_session_2 = MagicMock()
1779
mock_session_2.session_id = "session_2"
1780
mock_session_2.mcp = MagicMock()
1781
mock_session_2.mcp.type = "http"
1746
- mock_session_2.mcp.url = "https://mcp.example.com/session_2"
1782
+ mock_session_2.mcp.url = (
1783
+ "https://backend.composio.dev/api/v3/tool_router/session/session_2"
1784
+ )
1785
mock_session_2.tool_router_tools = ["TOOL_2"]
1786
1787
mock_client.tool_router.session.create.side_effect = [
1803
mock_create_response.session_id = "created_session"
1804
mock_create_response.mcp = MagicMock()
1805
mock_create_response.mcp.type = "http"
1768
- mock_create_response.mcp.url = "https://mcp.example.com/created"
1806
+ mock_create_response.mcp.url = (
1807
+ "https://backend.composio.dev/api/v3/tool_router/session/created"
1808
+ )
1809
mock_create_response.tool_router_tools = ["TOOL_1"]
1810
1811
mock_attach_response = MagicMock()
1812
mock_attach_response.session_id = "retrieved_session"
1813
mock_attach_response.mcp = MagicMock()
1814
mock_attach_response.mcp.type = "http"
1775
- mock_attach_response.mcp.url = "https://mcp.example.com/retrieved"
1815
+ mock_attach_response.mcp.url = (
1816
+ "https://backend.composio.dev/api/v3/tool_router/session/retrieved"
1817
+ )
1818
mock_attach_response.tool_router_tools = ["TOOL_2"]
1819
mock_attach_response.config = MagicMock()
1820
mock_attach_response.config.user_id = "user_456"
2202
2203
assert created_session.session_id == retrieved_session.session_id
2204
assert created_session.mcp.url == retrieved_session.mcp.url
2205
+
2206
+
2207
+MCP_SAME_ORIGIN_URL = (
2208
+ "https://backend.composio.dev/api/v3/tool_router/session/session_123/mcp"
2209
+)
2210
+
2211
+
2212
+def _session_json(mcp_url: str) -> t.Dict[str, t.Any]:
2213
+ return {
2214
+ "session_id": "session_123",
2215
+ "mcp": {"type": "http", "url": mcp_url},
2216
+ "config": {
2217
+ "user_id": "user_123",
2218
+ "execute": {},
2219
+ "search": {},
2220
+ "preload": {"tools": []},
2221
+ },
2222
+ "config_version": 3,
2223
+ "warnings": [],
2224
+ }
2225
+
2226
+
2227
+def _transport_client(
2228
+ *,
2229
+ api_key: t.Optional[str],
2230
+ base_url: str,
2231
+ disable_api_key: bool = False,
2232
+ user_api_key: t.Optional[str] = None,
2233
+ default_headers: t.Optional[t.Dict[str, str]] = None,
2234
+ mcp_url: str = MCP_SAME_ORIGIN_URL,
2235
+) -> t.Tuple[HttpClient, t.List[httpx.Request]]:
2236
+ requests: t.List[httpx.Request] = []
2237
+
2238
+ def handler(request: httpx.Request) -> httpx.Response:
2239
+ requests.append(request)
2240
+ return httpx.Response(200, json=_session_json(mcp_url))
2241
+
2242
+ client = HttpClient(
2243
+ provider="test",
2244
+ api_key=api_key,
2245
+ disable_api_key=disable_api_key,
2246
+ user_api_key=user_api_key,
2247
+ base_url=base_url,
2248
+ default_headers=default_headers,
2249
+ http_client=httpx.Client(transport=httpx.MockTransport(handler)),
2250
+ )
2251
+ return client, requests
2252
+
2253
+
2254
+class TestMcpAuthContext:
2255
+ """The exported MCP headers match the effective session auth context."""
2256
+
2257
+ def test_project_key_session_exports_only_the_project_key(self):
2258
+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "ak_foreign_env_key"}):
2259
+ client, requests = _transport_client(
2260
+ api_key="ak_project_key",
2261
+ base_url="https://backend.composio.dev",
2262
+ default_headers={"x-request-id": "req-1"},
2263
+ )
2264
+ session = ToolRouter(client=client, provider=MagicMock()).create(
2265
+ user_id="user_123", mcp=True
2266
+ )
2267
+
2268
+ assert requests[0].headers["x-api-key"] == "ak_project_key"
2269
+ assert session.mcp.headers == {"x-api-key": "ak_project_key"}
2270
+
2271
+ def test_user_key_option_session_exports_only_the_user_key(self):
2272
+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "ak_foreign_env_key"}):
2273
+ client, requests = _transport_client(
2274
+ api_key=None,
2275
+ disable_api_key=True,
2276
+ user_api_key="uak_user_key",
2277
+ base_url="https://backend.composio.dev",
2278
+ default_headers={"x-request-id": "r"},
2279
+ )
2280
+ session = ToolRouter(client=client, provider=MagicMock()).create(
2281
+ user_id="user_123", mcp=True
2282
+ )
2283
+
2284
+ assert "x-api-key" not in requests[0].headers
2285
+ assert requests[0].headers["x-user-api-key"] == "uak_user_key"
2286
+ assert session.mcp.headers == {"x-user-api-key": "uak_user_key"}
2287
+
2288
+ def test_user_key_header_session_exports_only_the_user_key(self):
2289
+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "ak_foreign_env_key"}):
2290
+ client, requests = _transport_client(
2291
+ api_key=None,
2292
+ disable_api_key=True,
2293
+ base_url="https://backend.composio.dev",
2294
+ default_headers={"x-user-api-key": "uak_user_key", "x-request-id": "r"},
2295
+ )
2296
+ session = ToolRouter(client=client, provider=MagicMock()).create(
2297
+ user_id="user_123", mcp=True
2298
+ )
2299
+
2300
+ assert "x-api-key" not in requests[0].headers
2301
+ assert requests[0].headers["x-user-api-key"] == "uak_user_key"
2302
+ assert session.mcp.headers == {"x-user-api-key": "uak_user_key"}
2303
+
2304
+ def test_scope_headers_are_exported_with_the_user_key(self):
2305
+ client, requests = _transport_client(
2306
+ api_key=None,
2307
+ disable_api_key=True,
2308
+ user_api_key="uak_user_key",
2309
+ base_url="https://backend.composio.dev",
2310
+ default_headers={
2311
+ "x-org-id": "org_nano_abc",
2312
+ "x-project-id": "proj_nano_xyz",
2313
+ "x-request-id": "r",
2314
+ },
2315
+ )
2316
+ session = ToolRouter(client=client, provider=MagicMock()).use(
2317
+ "session_123", mcp=True
2318
+ )
2319
+
2320
+ assert requests[0].headers["x-org-id"] == "org_nano_abc"
2321
+ assert requests[0].headers["x-project-id"] == "proj_nano_xyz"
2322
+ assert session.mcp.headers == {
2323
+ "x-user-api-key": "uak_user_key",
2324
+ "x-org-id": "org_nano_abc",
2325
+ "x-project-id": "proj_nano_xyz",
2326
+ }
2327
+
2328
+ def test_retrieve_preserves_the_user_key_after_environment_changes(self):
2329
+ with patch.dict(os.environ, {}, clear=True):
2330
+ client, requests = _transport_client(
2331
+ api_key=None,
2332
+ disable_api_key=True,
2333
+ base_url="https://backend.composio.dev",
2334
+ default_headers={"X-User-Api-Key": "uak_user_key"},
2335
+ )
2336
+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "ak_later_env_key"}):
2337
+ session = ToolRouter(client=client, provider=MagicMock()).use(
2338
+ "session_123", mcp=True
2339
+ )
2340
+
2341
+ assert "x-api-key" not in requests[0].headers
2342
+ assert session.mcp.headers == {"x-user-api-key": "uak_user_key"}
2343
+
2344
+ def test_no_credential_exports_no_headers_without_reading_the_environment(
2345
+ self, tool_router, mock_client
2346
+ ):
2347
+ mock_client.api_key = None
2348
+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "ak_ambient"}):
2349
+ session = tool_router.create(user_id="user_123", mcp=True)
2350
+
2351
+ assert session.mcp.headers == {}
2352
+
2353
+ def test_cross_origin_mcp_url_raises_without_leaking_the_key(
2354
+ self, tool_router, mock_client
2355
+ ):
2356
+ response = mock_client.tool_router.session.create.return_value
2357
+ response.mcp.url = "https://mcp.example.com/session_123"
2358
+
2359
+ with pytest.raises(MCPDestinationError) as excinfo:
2360
+ tool_router.create(user_id="user_123", mcp=True)
2361
+
2362
+ message = str(excinfo.value)
2363
+ assert message == (
2364
+ "The session MCP endpoint origin https://mcp.example.com does not match the API origin https://backend.composio.dev; the session credential was not attached"
2365
+ )
2366
+ assert "test-api-key" not in message
2367
+ assert excinfo.value.mcp_origin == "https://mcp.example.com"
2368
+ assert excinfo.value.api_origin == "https://backend.composio.dev"
2369
+
2370
+ def test_cross_origin_mcp_url_raises_on_use_when_mcp_is_requested(
2371
+ self, tool_router, mock_client
2372
+ ):
2373
+ response = mock_client.tool_router.session.retrieve.return_value
2374
+ response.mcp.url = "https://mcp.example.com/session_123"
2375
+
2376
+ with pytest.raises(MCPDestinationError) as excinfo:
2377
+ tool_router.use("session_123", mcp=True)
2378
+
2379
+ message = str(excinfo.value)
2380
+ assert message == (
2381
+ "The session MCP endpoint origin https://mcp.example.com does not match the API origin https://backend.composio.dev; the session credential was not attached"
2382
+ )
2383
+ assert "test-api-key" not in message
2384
+
2385
+ def test_cross_origin_mcp_url_without_mcp_flag_exports_no_headers_and_warns(
2386
+ self, tool_router, mock_client, caplog
2387
+ ):
2388
+ for response in (
2389
+ mock_client.tool_router.session.create.return_value,
2390
+ mock_client.tool_router.session.retrieve.return_value,
2391
+ ):
2392
+ response.mcp.url = "https://mcp.example.com/session_123"
2393
+
2394
+ with caplog.at_level(logging.WARNING):
2395
+ created = tool_router.create(user_id="user_123")
2396
+ used = tool_router.use("session_123")
2397
+
2398
+ assert created.mcp.url == "https://mcp.example.com/session_123"
2399
+ assert created.mcp.headers == {}
2400
+ assert used.mcp.headers == {}
2401
+ warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
2402
+ assert len(warnings) == 2
2403
+ message = warnings[0].getMessage()
2404
+ assert message == (
2405
+ "The session MCP endpoint origin https://mcp.example.com does not match the API origin https://backend.composio.dev; the session credential was not attached"
2406
+ ". session.mcp.headers was left empty; pass mcp=True to make this an error"
2407
+ )
2408
+ assert "test-api-key" not in caplog.text
2409
+
2410
+ def test_opaque_origin_mcp_url_is_rejected_before_comparison(
2411
+ self, tool_router, mock_client, caplog
2412
+ ):
2413
+ response = mock_client.tool_router.session.create.return_value
2414
+ response.mcp.url = "data:text/plain,session_123"
2415
+
2416
+ with pytest.raises(MCPDestinationError) as excinfo:
2417
+ tool_router.create(user_id="user_123", mcp=True)
2418
+ assert str(excinfo.value) == "The MCP URL has an opaque origin"
2419
+ assert excinfo.value.mcp_origin == ""
2420
+
2421
+ with caplog.at_level(logging.WARNING):
2422
+ session = tool_router.create(user_id="user_123")
2423
+ assert session.mcp.headers == {}
2424
+ assert "The MCP URL has an opaque origin" in caplog.text
2425
+ assert "test-api-key" not in caplog.text
2426
+
2427
+ def test_user_key_default_header_wins_over_the_configured_project_key(self):
2428
+ client, requests = _transport_client(
2429
+ api_key="ak_project_key",
2430
+ base_url="https://backend.composio.dev",
2431
+ default_headers={"x-user-api-key": "uak_header_key"},
2432
+ )
2433
+ session = ToolRouter(client=client, provider=MagicMock()).create(
2434
+ user_id="user_123", mcp=True
2435
+ )
2436
+
2437
+ assert "x-api-key" not in requests[0].headers
2438
+ assert requests[0].headers["x-user-api-key"] == "uak_header_key"
2439
+ assert session.mcp.headers == {"x-user-api-key": "uak_header_key"}
2440
+
2441
+ def test_invalid_port_in_mcp_url_raises_the_typed_error(self):
2442
+ client, _ = _transport_client(
2443
+ api_key="ak_project_key",
2444
+ base_url="https://backend.composio.dev",
2445
+ mcp_url="https://backend.composio.dev:bad/mcp",
2446
+ )
2447
+ with pytest.raises(MCPDestinationError) as excinfo:
2448
+ ToolRouter(client=client, provider=MagicMock()).create(
2449
+ user_id="user_123", mcp=True
2450
+ )
2451
+
2452
+ assert str(excinfo.value) == "The MCP URL is not a valid absolute URL"
2453
+
2454
+ def test_malformed_mcp_url_is_not_echoed_in_the_error(self):
2455
+ client, _ = _transport_client(
2456
+ api_key="ak_project_key",
2457
+ base_url="https://backend.composio.dev",
2458
+ mcp_url="not-a-url?token=secret_value",
2459
+ )
2460
+ with pytest.raises(MCPDestinationError) as excinfo:
2461
+ ToolRouter(client=client, provider=MagicMock()).create(
2462
+ user_id="user_123", mcp=True
2463
+ )
2464
+
2465
+ assert str(excinfo.value) == "The MCP URL is not a valid absolute URL"
2466
+ assert "secret_value" not in str(excinfo.value)
2467
+
2468
+ def test_same_origin_mcp_url_does_not_warn(self, tool_router, caplog):
2469
+ with caplog.at_level(logging.WARNING):
2470
+ session = tool_router.create(user_id="user_123")
2471
+
2472
+ assert session.mcp.headers == {"x-api-key": "test-api-key"}
2473
+ assert not [r for r in caplog.records if r.levelno == logging.WARNING]
2474
+
2475
+ def test_same_origin_plain_http_base_url_exports_credentials(self):
2476
+ client, requests = _transport_client(
2477
+ api_key="ak_project_key",
2478
+ base_url="http://localhost:3000",
2479
+ mcp_url="http://localhost:3000/api/v3/tool_router/session/session_123/mcp",
2480
+ )
2481
+ session = ToolRouter(client=client, provider=MagicMock()).create(
2482
+ user_id="user_123", mcp=True
2483
+ )
2484
+
2485
+ assert requests[0].headers["x-api-key"] == "ak_project_key"
2486
+ assert session.mcp.headers == {"x-api-key": "ak_project_key"}
2487
+
2488
+ def test_same_origin_https_mcp_url_behaves_as_before(self, tool_router):
2489
+ session = tool_router.create(user_id="user_123", mcp=True)
2490
+
2491
+ assert session.mcp.url == (
2492
+ "https://backend.composio.dev/api/v3/tool_router/session/session_123"
2493
+ )
2494
+ assert session.mcp.headers == {"x-api-key": "test-api-key"}
2495
+
2496
+
2497
+class TestSessionUpdateContract:
2498
+ """update() nullable fields, empty allowlists, and version preconditions."""
2499
+
2500
+ @pytest.fixture
2501
+ def session(self, tool_router, mock_client):
2502
+ patched = MagicMock()
2503
+ patched.preload = MagicMock()
2504
+ patched.preload.tools = ["SLACK_SEND_MESSAGE"]
2505
+ mock_client.tool_router.session.patch.return_value.config = patched
2506
+ mock_client.tool_router.session.patch.return_value.config_version = 8
2507
+ return tool_router.use(session_id="session_123")
2508
+
2509
+ @staticmethod
2510
+ def _conflict() -> ConflictError:
2511
+ response = httpx.Response(
2512
+ 409,
2513
+ request=httpx.Request("PATCH", "https://backend.composio.dev/patch"),
2514
+ json={"error": "version conflict"},
2515
+ )
2516
+ return ConflictError(
2517
+ "Conflict", response=response, body={"error": "version conflict"}
2518
+ )
2519
+
2520
+ def test_session_tracks_config_version(self, session):
2521
+ assert session.config_version == 7
2522
+
2523
+ def test_update_sends_the_observed_version_by_default_without_retries(
2524
+ self, session, mock_client
2525
+ ):
2526
+ session.update(toolkits={"enable": ["gmail"]})
2527
+
2528
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2529
+ assert kwargs["extra_body"] == {"expected_config_version": 7}
2530
+ assert kwargs["request_options"] == {"max_retries": 0}
2531
+ assert session.config_version == 8
2532
+ assert session.preload.tools == ["SLACK_SEND_MESSAGE"]
2533
+
2534
+ def test_update_opt_out_sends_no_precondition(self, session, mock_client):
2535
+ session.update(toolkits={"enable": ["gmail"]}, expected_config_version=False)
2536
+
2537
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2538
+ assert kwargs["extra_body"] is None
2539
+
2540
+ def test_update_sends_an_explicit_expected_version(self, session, mock_client):
2541
+ session.update(toolkits={"enable": ["gmail"]}, expected_config_version=9)
2542
+
2543
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2544
+ assert kwargs["extra_body"] == {"expected_config_version": 9}
2545
+
2546
+ def test_update_rejects_non_positive_expected_version(self, session, mock_client):
2547
+ with pytest.raises(InvalidParams):
2548
+ session.update(toolkits={"enable": ["gmail"]}, expected_config_version=0)
2549
+ mock_client.tool_router.session.patch.assert_not_called()
2550
+
2551
+ def test_update_passes_null_callback_url_through(self, session, mock_client):
2552
+ session.update(manage_connections={"callback_url": None})
2553
+
2554
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2555
+ assert kwargs["manage_connections"] == {"callback_url": None}
2556
+
2557
+ def test_update_preserves_empty_toolkit_allowlist(self, session, mock_client):
2558
+ session.update(toolkits={"enable": []})
2559
+
2560
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2561
+ assert kwargs["toolkits"] == {"enable": []}
2562
+
2563
+ def test_update_sends_none_for_cleared_blocks(self, session, mock_client):
2564
+ session.update(
2565
+ toolkits=None,
2566
+ tools=None,
2567
+ tags=None,
2568
+ auth_configs=None,
2569
+ connected_accounts=None,
2570
+ preload=None,
2571
+ multi_account=None,
2572
+ search=None,
2573
+ execute=None,
2574
+ experimental=None,
2575
+ )
2576
+
2577
+ kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2578
+ for name in (
2579
+ "toolkits",
2580
+ "tools",
2581
+ "tags",
2582
+ "auth_configs",
2583
+ "connected_accounts",
2584
+ "preload",
2585
+ "multi_account",
2586
+ "search",
2587
+ "execute",
2588
+ "experimental",
2589
+ ):
2590
+ assert kwargs[name] is None, name
2591
+ assert kwargs["manage_connections"] is omit
2592
+ assert kwargs["workbench"] is omit
2593
+
2594
+ def test_update_conflict_is_typed_and_keeps_local_state(self, session, mock_client):
2595
+ preload_before = session.preload
2596
+ mock_client.tool_router.session.patch.side_effect = self._conflict()
2597
+
2598
+ with pytest.raises(SessionConfigConflictError) as excinfo:
2599
+ session.update(toolkits={"enable": ["gmail"]})
2600
+
2601
+ assert "re-fetch" in str(excinfo.value).lower()
2602
+ assert "retry" in str(excinfo.value).lower()
2603
+ assert excinfo.value.status_code == 409
2604
+ assert excinfo.value.session_id == "session_123"
2605
+ assert excinfo.value.expected_config_version == 7
2606
+ assert session.preload is preload_before
2607
+ assert session.config_version == 7
2608
+
2609
+ def test_update_conflict_without_precondition_reports_in_flight_change(
2610
+ self, session, mock_client
2611
+ ):
2612
+ config_before = session.config
2613
+ mock_client.tool_router.session.patch.side_effect = self._conflict()
2614
+
2615
+ with pytest.raises(SessionConfigConflictError) as excinfo:
2616
+ session.update(
2617
+ toolkits={"enable": ["gmail"]}, expected_config_version=False
2618
+ )
2619
+
2620
+ message = str(excinfo.value)
2621
+ assert "changed while this update was in flight" in message
2622
+ assert "no longer at version" not in message
2623
+ assert excinfo.value.expected_config_version is None
2624
+ assert session.config is config_before
2625
+ assert session.config_version == 7
2626
+
2627
+ def test_two_handles_at_the_same_version(self, tool_router, mock_client):
2628
+ mock_client.tool_router.session.patch.return_value.config_version = 8
2629
+ first = tool_router.use(session_id="session_123")
2630
+ second = tool_router.use(session_id="session_123")
2631
+ assert first.config_version == second.config_version == 7
2632
+
2633
+ first.update(toolkits={"enable": ["gmail"]})
2634
+ assert mock_client.tool_router.session.patch.call_args.kwargs["extra_body"] == {
2635
+ "expected_config_version": 7
2636
+ }
2637
+ assert first.config_version == 8
2638
+
2639
+ mock_client.tool_router.session.patch.side_effect = self._conflict()
2640
+ with pytest.raises(SessionConfigConflictError):
2641
+ second.update(toolkits={"enable": ["slack"]})
2642
+ assert second.config_version == 7
2643
+
2644
+ mock_client.tool_router.session.patch.side_effect = None
2645
+ mock_client.tool_router.session.retrieve.return_value.config_version = 8
2646
+ mock_client.tool_router.session.patch.return_value.config_version = 9
2647
+ reread = tool_router.use(session_id="session_123")
2648
+ assert reread.config_version == 8
2649
+ reread.update(toolkits={"enable": ["slack"]})
2650
+ assert mock_client.tool_router.session.patch.call_args.kwargs["extra_body"] == {
2651
+ "expected_config_version": 8
2652
+ }
2653
+ assert reread.config_version == 9